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
];
126 /* Record the symbols defined for each context in a list.
127 We don't create a struct block for the context until we
128 know how long to make it. */
132 struct coff_pending
*next
;
133 struct symbol
*symbol
;
136 /* Here are the three lists that symbols are put on. */
138 struct coff_pending
*coff_file_symbols
; /* static at top level, and types */
140 struct coff_pending
*coff_global_symbols
; /* global functions and variables */
142 struct coff_pending
*coff_local_symbols
; /* everything local to lexical context */
144 /* List of unclosed lexical contexts
145 (that will become blocks, eventually). */
147 struct coff_context_stack
149 struct coff_context_stack
*next
;
150 struct coff_pending
*locals
;
151 struct pending_block
*old_blocks
;
153 CORE_ADDR start_addr
;
157 struct coff_context_stack
*coff_context_stack
;
159 /* Nonzero if within a function (so symbols should be local,
160 if nothing says specifically). */
165 /* The type of the function we are currently reading in. This is
166 used by define_symbol to record the type of arguments to a function. */
168 struct type
*in_function_type
;
171 struct pending_block
*pending_blocks
;
173 /* Complaints about various problems in the file being read */
175 struct complaint ef_complaint
=
176 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
178 struct complaint bf_no_aux_complaint
=
179 {"`.bf' symbol %d has no aux entry", 0, 0};
181 struct complaint ef_no_aux_complaint
=
182 {"`.ef' symbol %d has no aux entry", 0, 0};
184 struct complaint lineno_complaint
=
185 {"Line number pointer %d lower than start of line numbers", 0, 0};
187 struct complaint unexpected_type_complaint
=
188 {"Unexpected type for symbol %s", 0, 0};
190 struct complaint bad_sclass_complaint
=
191 {"Bad n_sclass for symbol %s", 0, 0};
193 struct complaint misordered_blocks_complaint
=
194 {"Blocks out of order at address %x", 0, 0};
196 struct complaint tagndx_bad_complaint
=
197 {"Symbol table entry for %s has bad tagndx value", 0, 0};
199 struct complaint eb_complaint
=
200 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
202 /* Simplified internal version of coff symbol table information */
206 int c_symnum
; /* symbol number of this entry */
207 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
215 coff_read_struct_type
PARAMS ((int, int, int));
218 decode_base_type
PARAMS ((struct coff_symbol
*, unsigned int,
219 union internal_auxent
*));
222 decode_type
PARAMS ((struct coff_symbol
*, unsigned int,
223 union internal_auxent
*));
226 decode_function_type
PARAMS ((struct coff_symbol
*, unsigned int,
227 union internal_auxent
*));
230 coff_read_enum_type
PARAMS ((int, int, int));
232 static struct blockvector
*
233 make_blockvector
PARAMS ((struct objfile
*));
235 static struct symbol
*
236 process_coff_symbol
PARAMS ((struct coff_symbol
*, union internal_auxent
*,
240 patch_opaque_types
PARAMS ((struct symtab
*));
243 patch_type
PARAMS ((struct type
*, struct type
*));
246 enter_linenos
PARAMS ((long, int, int));
249 free_linetab
PARAMS ((void));
252 init_lineno
PARAMS ((int, long, int));
255 getfilename
PARAMS ((union internal_auxent
*));
258 getsymname
PARAMS ((struct internal_syment
*));
261 free_stringtab
PARAMS ((void));
264 init_stringtab
PARAMS ((int, long));
267 read_one_sym
PARAMS ((struct coff_symbol
*, struct internal_syment
*,
268 union internal_auxent
*));
271 read_coff_symtab
PARAMS ((long, int, struct objfile
*));
274 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
277 coff_symfile_init
PARAMS ((struct objfile
*));
280 coff_new_init
PARAMS ((struct objfile
*));
283 coff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
286 coff_symfile_finish
PARAMS ((struct objfile
*));
289 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
));
292 coff_end_symtab
PARAMS ((struct objfile
*));
295 complete_symtab
PARAMS ((char *, CORE_ADDR
, unsigned int));
298 coff_start_symtab
PARAMS ((void));
301 coff_record_line
PARAMS ((int, CORE_ADDR
));
304 coff_finish_block
PARAMS ((struct symbol
*, struct coff_pending
**,
305 struct pending_block
*, CORE_ADDR
, CORE_ADDR
,
309 coff_add_symbol_to_list
PARAMS ((struct symbol
*, struct coff_pending
**));
312 coff_alloc_type
PARAMS ((int));
314 static struct type
**
315 coff_lookup_type
PARAMS ((int));
318 /* Look up a coff type-number index. Return the address of the slot
319 where the type for that index is stored.
320 The type-number is in INDEX.
322 This can be used for finding the type associated with that index
323 or for associating a new type with the index. */
325 static struct type
**
326 coff_lookup_type (index
)
329 if (index
>= type_vector_length
)
331 int old_vector_length
= type_vector_length
;
333 type_vector_length
*= 2;
334 if (index
/* is still */ >= type_vector_length
) {
335 type_vector_length
= index
* 2;
337 type_vector
= (struct type
**)
338 xrealloc ((char *) type_vector
,
339 type_vector_length
* sizeof (struct type
*));
340 memset (&type_vector
[old_vector_length
], 0,
341 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
343 return &type_vector
[index
];
346 /* Make sure there is a type allocated for type number index
347 and return the type object.
348 This can create an empty (zeroed) type object. */
351 coff_alloc_type (index
)
354 register struct type
**type_addr
= coff_lookup_type (index
);
355 register struct type
*type
= *type_addr
;
357 /* If we are referring to a type not known at all yet,
358 allocate an empty type for it.
359 We will fill it in later if we find out how. */
362 type
= alloc_type (current_objfile
);
368 /* maintain the lists of symbols and blocks */
370 /* Add a symbol to one of the lists of symbols. */
372 coff_add_symbol_to_list (symbol
, listhead
)
373 struct symbol
*symbol
;
374 struct coff_pending
**listhead
;
376 register struct coff_pending
*link
377 = (struct coff_pending
*) xmalloc (sizeof (struct coff_pending
));
379 link
->next
= *listhead
;
380 link
->symbol
= symbol
;
384 /* Take one of the lists of symbols and make a block from it.
385 Put the block on the list of pending blocks. */
388 coff_finish_block (symbol
, listhead
, old_blocks
, start
, end
, objfile
)
389 struct symbol
*symbol
;
390 struct coff_pending
**listhead
;
391 struct pending_block
*old_blocks
;
392 CORE_ADDR start
, end
;
393 struct objfile
*objfile
;
395 register struct coff_pending
*next
, *next1
;
396 register struct block
*block
;
397 register struct pending_block
*pblock
;
398 struct pending_block
*opblock
;
401 /* Count the length of the list of symbols. */
403 for (next
= *listhead
, i
= 0; next
; next
= next
->next
, i
++);
405 block
= (struct block
*)
406 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct block
) + (i
- 1) * sizeof (struct symbol
*));
408 /* Copy the symbols into the block. */
410 BLOCK_NSYMS (block
) = i
;
411 for (next
= *listhead
; next
; next
= next
->next
)
412 BLOCK_SYM (block
, --i
) = next
->symbol
;
414 BLOCK_START (block
) = start
;
415 BLOCK_END (block
) = end
;
416 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
418 /* Put the block in as the value of the symbol that names it. */
422 SYMBOL_BLOCK_VALUE (symbol
) = block
;
423 BLOCK_FUNCTION (block
) = symbol
;
426 BLOCK_FUNCTION (block
) = 0;
428 /* Now free the links of the list, and empty the list. */
430 for (next
= *listhead
; next
; next
= next1
)
437 /* Install this block as the superblock
438 of all blocks made since the start of this scope
439 that don't have superblocks yet. */
442 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
444 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0)
445 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
449 /* Record this block on the list of all blocks in the file.
450 Put it after opblock, or at the beginning if opblock is 0.
451 This puts the block in the list after all its subblocks. */
453 pblock
= (struct pending_block
*) xmalloc (sizeof (struct pending_block
));
454 pblock
->block
= block
;
457 pblock
->next
= opblock
->next
;
458 opblock
->next
= pblock
;
462 pblock
->next
= pending_blocks
;
463 pending_blocks
= pblock
;
467 static struct blockvector
*
468 make_blockvector (objfile
)
469 struct objfile
*objfile
;
471 register struct pending_block
*next
, *next1
;
472 register struct blockvector
*blockvector
;
475 /* Count the length of the list of blocks. */
477 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
479 blockvector
= (struct blockvector
*)
480 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct blockvector
) + (i
- 1) * sizeof (struct block
*));
482 /* Copy the blocks into the blockvector.
483 This is done in reverse order, which happens to put
484 the blocks into the proper order (ascending starting address).
485 coff_finish_block has hair to insert each block into the list
486 after its subblocks in order to make sure this is true. */
488 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
489 for (next
= pending_blocks
; next
; next
= next
->next
)
490 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
492 /* Now free the links of the list, and empty the list. */
494 for (next
= pending_blocks
; next
; next
= next1
)
504 /* Manage the vector of line numbers. */
507 coff_record_line (line
, pc
)
511 struct linetable_entry
*e
;
512 /* Make sure line vector is big enough. */
514 if (line_vector_index
+ 2 >= line_vector_length
)
516 line_vector_length
*= 2;
517 line_vector
= (struct linetable
*)
518 xrealloc ((char *) line_vector
, sizeof (struct linetable
)
519 + (line_vector_length
520 * sizeof (struct linetable_entry
)));
523 e
= line_vector
->item
+ line_vector_index
++;
524 e
->line
= line
; e
->pc
= pc
;
527 /* Start a new symtab for a new source file.
528 This is called when a COFF ".file" symbol is seen;
529 it indicates the start of data for one original source file. */
534 coff_file_symbols
= 0;
535 coff_global_symbols
= 0;
536 coff_context_stack
= 0;
538 last_source_file
= NULL
;
540 /* Initialize the source file line number information for this file. */
542 if (line_vector
) /* Unlikely, but maybe possible? */
543 free ((PTR
)line_vector
);
544 line_vector_index
= 0;
545 line_vector_length
= 1000;
546 prev_line_number
= -2; /* Force first line number to be explicit */
547 line_vector
= (struct linetable
*)
548 xmalloc (sizeof (struct linetable
)
549 + line_vector_length
* sizeof (struct linetable_entry
));
552 /* Save the vital information from when starting to read a file,
553 for use when closing off the current file.
554 NAME is the file name the symbols came from, START_ADDR is the first
555 text address for the file, and SIZE is the number of bytes of text. */
558 complete_symtab (name
, start_addr
, size
)
560 CORE_ADDR start_addr
;
563 last_source_file
= savestring (name
, strlen (name
));
564 cur_src_start_addr
= start_addr
;
565 cur_src_end_addr
= start_addr
+ size
;
567 if (current_objfile
-> ei
.entry_point
>= cur_src_start_addr
&&
568 current_objfile
-> ei
.entry_point
< cur_src_end_addr
)
570 current_objfile
-> ei
.entry_file_lowpc
= cur_src_start_addr
;
571 current_objfile
-> ei
.entry_file_highpc
= cur_src_end_addr
;
575 /* Finish the symbol definitions for one main source file,
576 close off all the lexical contexts for that file
577 (creating struct block's for them), then make the
578 struct symtab for that file and put it in the list of all such. */
581 coff_end_symtab (objfile
)
582 struct objfile
*objfile
;
584 register struct symtab
*symtab
;
585 register struct coff_context_stack
*cstk
;
586 register struct blockvector
*blockvector
;
587 register struct linetable
*lv
;
589 /* Finish the lexical context of the last function in the file. */
591 if (coff_context_stack
)
593 cstk
= coff_context_stack
;
594 coff_context_stack
= 0;
595 /* Make a block for the local symbols within. */
596 coff_finish_block (cstk
->name
, &coff_local_symbols
, cstk
->old_blocks
,
597 cstk
->start_addr
, cur_src_end_addr
, objfile
);
601 /* Ignore a file that has no functions with real debugging info. */
602 if (pending_blocks
== 0 && coff_file_symbols
== 0 && coff_global_symbols
== 0)
604 free ((PTR
)line_vector
);
606 line_vector_length
= -1;
607 last_source_file
= NULL
;
611 /* It is unfortunate that in amdcoff, pending blocks might not be ordered
612 in this stage. Especially, blocks for static functions will show up at
613 the end. We need to sort them, so tools like `find_pc_function' and
614 `find_pc_block' can work reliably. */
615 if (pending_blocks
) {
616 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
619 struct pending_block
*pb
, *pbnext
;
621 pb
= pending_blocks
, pbnext
= pb
->next
;
626 /* swap blocks if unordered! */
628 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
)) {
629 struct block
*tmp
= pb
->block
;
630 complain (&misordered_blocks_complaint
, BLOCK_START (pb
->block
));
631 pb
->block
= pbnext
->block
;
636 pbnext
= pbnext
->next
;
641 /* Create the two top-level blocks for this file (STATIC_BLOCK and
643 coff_finish_block (0, &coff_file_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
, objfile
);
644 coff_finish_block (0, &coff_global_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
, objfile
);
646 /* Create the blockvector that points to all the file's blocks. */
647 blockvector
= make_blockvector (objfile
);
649 /* Now create the symtab object for this source file. */
650 symtab
= allocate_symtab (last_source_file
, objfile
);
652 /* Fill in its components. */
653 symtab
->blockvector
= blockvector
;
654 symtab
->free_code
= free_linetable
;
655 symtab
->free_ptr
= 0;
656 symtab
->filename
= last_source_file
;
657 symtab
->dirname
= NULL
;
659 lv
->nitems
= line_vector_index
;
660 symtab
->linetable
= (struct linetable
*)
661 xrealloc ((char *) lv
, (sizeof (struct linetable
)
662 + lv
->nitems
* sizeof (struct linetable_entry
)));
664 free_named_symtabs (symtab
->filename
);
666 /* Reinitialize for beginning of new file. */
668 line_vector_length
= -1;
669 last_source_file
= NULL
;
673 record_minimal_symbol (name
, address
, type
)
676 enum minimal_symbol_type type
;
678 /* We don't want TDESC entry points in the minimal symbol table */
679 if (name
[0] == '@') return;
681 prim_record_minimal_symbol (savestring (name
, strlen (name
)), address
, type
);
684 /* coff_symfile_init ()
685 is the coff-specific initialization routine for reading symbols.
686 It is passed a struct objfile which contains, among other things,
687 the BFD for the file whose symbols are being read, and a slot for
688 a pointer to "private data" which we fill with cookies and other
689 treats for coff_symfile_read ().
691 We will only be called if this is a COFF or COFF-like file.
692 BFD handles figuring out the format of the file, and code in symtab.c
693 uses BFD's determination to vector to us.
695 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
697 struct coff_symfile_info
{
698 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
699 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
702 static int text_bfd_scnum
;
705 coff_symfile_init (objfile
)
706 struct objfile
*objfile
;
709 bfd
*abfd
= objfile
->obfd
;
711 /* Allocate struct to keep track of the symfile */
712 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
713 sizeof (struct coff_symfile_info
));
715 init_entry_point_info (objfile
);
717 /* Save the section number for the text section */
718 section
= bfd_get_section_by_name(abfd
,".text");
720 text_bfd_scnum
= section
->index
;
725 /* This function is called for every section; it finds the outer limits
726 of the line table (minimum and maximum file offset) so that the
727 mainline code can read the whole thing for efficiency. */
731 find_linenos (abfd
, asect
, vpinfo
)
736 struct coff_symfile_info
*info
;
738 file_ptr offset
, maxoff
;
740 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
741 count
= asect
->lineno_count
;
746 size
= count
* local_linesz
;
748 info
= (struct coff_symfile_info
*)vpinfo
;
749 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
750 offset
= asect
->line_filepos
;
753 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
754 info
->min_lineno_offset
= offset
;
756 maxoff
= offset
+ size
;
757 if (maxoff
> info
->max_lineno_offset
)
758 info
->max_lineno_offset
= maxoff
;
762 /* The BFD for this file -- only good while we're actively reading
763 symbols into a psymtab or a symtab. */
765 static bfd
*symfile_bfd
;
767 /* Read a symbol file, after initialization by coff_symfile_init. */
768 /* FIXME! Addr and Mainline are not used yet -- this will not work for
769 shared libraries or add_file! */
773 coff_symfile_read (objfile
, section_offsets
, mainline
)
774 struct objfile
*objfile
;
775 struct section_offsets
*section_offsets
;
778 struct coff_symfile_info
*info
;
779 bfd
*abfd
= objfile
->obfd
;
780 coff_data_type
*cdata
= coff_data (abfd
);
781 char *name
= bfd_get_filename (abfd
);
786 int stringtab_offset
;
787 struct cleanup
*back_to
;
789 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
790 symfile_bfd
= abfd
; /* Kludge for swap routines */
792 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
793 desc
= fileno ((FILE *)(abfd
->iostream
)); /* File descriptor */
794 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
795 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
796 stringtab_offset
= symtab_offset
+ /* String table file offset */
797 num_symbols
* cdata
->local_symesz
;
799 /* Set a few file-statics that give us specific information about
800 the particular COFF file format we're reading. */
801 local_linesz
= cdata
->local_linesz
;
802 local_n_btmask
= cdata
->local_n_btmask
;
803 local_n_btshft
= cdata
->local_n_btshft
;
804 local_n_tmask
= cdata
->local_n_tmask
;
805 local_n_tshift
= cdata
->local_n_tshift
;
806 local_linesz
= cdata
->local_linesz
;
807 local_symesz
= cdata
->local_symesz
;
808 local_auxesz
= cdata
->local_auxesz
;
810 /* Allocate space for raw symbol and aux entries, based on their
811 space requirements as reported by BFD. */
812 temp_sym
= (char *) xmalloc
813 (cdata
->local_symesz
+ cdata
->local_auxesz
);
814 temp_aux
= temp_sym
+ cdata
->local_symesz
;
815 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
818 /* Read the line number table, all at once. */
819 info
->min_lineno_offset
= 0;
820 info
->max_lineno_offset
= 0;
821 bfd_map_over_sections (abfd
, find_linenos
, (PTR
)info
);
823 make_cleanup (free_linetab
, 0);
824 val
= init_lineno (desc
, info
->min_lineno_offset
,
825 info
->max_lineno_offset
- info
->min_lineno_offset
);
827 error ("\"%s\": error reading line numbers\n", name
);
829 /* Now read the string table, all at once. */
831 make_cleanup (free_stringtab
, 0);
832 val
= init_stringtab (desc
, stringtab_offset
);
834 error ("\"%s\": can't get string table", name
);
836 init_minimal_symbol_collection ();
837 make_cleanup (discard_minimal_symbols
, 0);
839 /* Now that the executable file is positioned at symbol table,
840 process it and define symbols accordingly. */
842 read_coff_symtab ((long)symtab_offset
, num_symbols
, objfile
);
844 /* Sort symbols alphabetically within each block. */
846 sort_all_symtab_syms ();
848 /* Install any minimal symbols that have been collected as the current
849 minimal symbols for this objfile. */
851 install_minimal_symbols (objfile
);
853 do_cleanups (back_to
);
857 coff_new_init (ignore
)
858 struct objfile
*ignore
;
863 /* Perform any local cleanups required when we are done with a particular
864 objfile. I.E, we are in the process of discarding all symbol information
865 for an objfile, freeing up all memory held for it, and unlinking the
866 objfile struct from the global list of known objfiles. */
869 coff_symfile_finish (objfile
)
870 struct objfile
*objfile
;
872 if (objfile
-> sym_private
!= NULL
)
874 mfree (objfile
-> md
, objfile
-> sym_private
);
879 /* Given pointers to a symbol table in coff style exec file,
880 analyze them and create struct symtab's describing the symbols.
881 NSYMS is the number of symbols in the symbol table.
882 We read them one at a time using read_one_sym (). */
885 read_coff_symtab (symtab_offset
, nsyms
, objfile
)
888 struct objfile
*objfile
;
891 register struct coff_context_stack
*new;
892 struct coff_symbol coff_symbol
;
893 register struct coff_symbol
*cs
= &coff_symbol
;
894 static struct internal_syment main_sym
;
895 static union internal_auxent main_aux
;
896 struct coff_symbol fcn_cs_saved
;
897 static struct internal_syment fcn_sym_saved
;
898 static union internal_auxent fcn_aux_saved
;
901 /* A .file is open. */
902 int in_source_file
= 0;
903 int num_object_files
= 0;
904 int next_file_symnum
= -1;
906 /* Name of the current file. */
907 char *filestring
= "";
909 int fcn_first_line
= 0;
910 int fcn_last_line
= 0;
911 int fcn_start_addr
= 0;
912 long fcn_line_ptr
= 0;
915 stream
= bfd_cache_lookup(objfile
->obfd
);
917 perror_with_name(objfile
->name
);
919 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
920 it's hard to know I've really worked around it. The fix should be
921 harmless, anyway). The symptom of the bug is that the first
922 fread (in read_one_sym), will (in my example) actually get data
923 from file offset 268, when the fseek was to 264 (and ftell shows
924 264). This causes all hell to break loose. I was unable to
925 reproduce this on a short test program which operated on the same
926 file, performing (I think) the same sequence of operations.
928 It stopped happening when I put in this rewind().
930 FIXME: Find out if this has been reported to Sun, whether it has
931 been fixed in a later release, etc. */
935 /* Position to read the symbol table. */
936 val
= fseek (stream
, (long)symtab_offset
, 0);
938 perror_with_name (objfile
->name
);
940 current_objfile
= objfile
;
941 nlist_stream_global
= stream
;
942 nlist_nsyms_global
= nsyms
;
943 last_source_file
= NULL
;
944 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
946 if (type_vector
) /* Get rid of previous one */
947 free ((PTR
)type_vector
);
948 type_vector_length
= 160;
949 type_vector
= (struct type
**)
950 xmalloc (type_vector_length
* sizeof (struct type
*));
951 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
953 coff_start_symtab ();
956 while (symnum
< nsyms
)
958 QUIT
; /* Make this command interruptable. */
959 read_one_sym (cs
, &main_sym
, &main_aux
);
962 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
963 cs
->c_name
[2] << 8 | cs
->c_name
[3];
964 if (int_sem_val
== temp_sem_val
)
965 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
968 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
970 if (last_source_file
)
971 coff_end_symtab (objfile
);
973 coff_start_symtab ();
974 complete_symtab ("_globals_", 0, first_object_file_end
);
975 /* done with all files, everything from here on out is globals */
978 /* Special case for file with type declarations only, no text. */
979 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
980 && cs
->c_secnum
== N_DEBUG
)
981 complete_symtab (filestring
, 0, 0);
983 /* Typedefs should not be treated as symbol definitions. */
984 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
986 /* Record all functions -- external and static -- in minsyms. */
987 record_minimal_symbol (cs
->c_name
, cs
->c_value
, mst_text
);
989 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
990 fcn_start_addr
= cs
->c_value
;
992 fcn_sym_saved
= main_sym
;
993 fcn_aux_saved
= main_aux
;
997 switch (cs
->c_sclass
)
1006 complain (&bad_sclass_complaint
, cs
->c_name
);
1011 * c_value field contains symnum of next .file entry in table
1012 * or symnum of first global after last .file.
1014 next_file_symnum
= cs
->c_value
;
1015 filestring
= getfilename (&main_aux
);
1017 * Complete symbol table for last object file
1018 * containing debugging information.
1020 if (last_source_file
)
1022 coff_end_symtab (objfile
);
1023 coff_start_symtab ();
1029 if (cs
->c_name
[0] == '.') {
1030 if (STREQ (cs
->c_name
, ".text")) {
1031 /* FIXME: don't wire in ".text" as section name
1033 if (++num_object_files
== 1) {
1034 /* last address of startup file */
1035 first_object_file_end
= cs
->c_value
+
1036 main_aux
.x_scn
.x_scnlen
;
1038 /* Check for in_source_file deals with case of
1039 a file with debugging symbols
1040 followed by a later file with no symbols. */
1042 complete_symtab (filestring
, cs
->c_value
,
1043 main_aux
.x_scn
.x_scnlen
);
1046 /* flush rest of '.' symbols */
1049 else if (!SDB_TYPE (cs
->c_type
)
1050 && cs
->c_name
[0] == 'L'
1051 && (strncmp (cs
->c_name
, "LI%", 3) == 0
1052 || strncmp (cs
->c_name
, "LF%", 3) == 0
1053 || strncmp (cs
->c_name
,"LC%",3) == 0
1054 || strncmp (cs
->c_name
,"LP%",3) == 0
1055 || strncmp (cs
->c_name
,"LPB%",4) == 0
1056 || strncmp (cs
->c_name
,"LBB%",4) == 0
1057 || strncmp (cs
->c_name
,"LBE%",4) == 0
1058 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
1059 /* At least on a 3b1, gcc generates swbeg and string labels
1060 that look like this. Ignore them. */
1062 /* fall in for static symbols that don't start with '.' */
1064 /* Record external symbols in minsyms if we don't have debug
1065 info for them. FIXME, this is probably the wrong thing
1066 to do. Why don't we record them even if we do have
1067 debug symbol info? What really belongs in the minsyms
1069 if (!SDB_TYPE (cs
->c_type
)) {
1070 /* FIXME: This is BOGUS Will Robinson!
1071 Coff should provide the SEC_CODE flag for executable sections,
1072 then if we could look up sections by section number we
1073 could see if the flags indicate SEC_CODE. If so, then
1074 record this symbol as a function in the minimal symbol table.
1075 But why are absolute syms recorded as functions, anyway? */
1076 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
1077 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
1081 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
1086 process_coff_symbol (cs
, &main_aux
, objfile
);
1090 if (STREQ (cs
->c_name
, ".bf"))
1092 within_function
= 1;
1094 /* value contains address of first non-init type code */
1095 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1096 contains line number of '{' } */
1097 if (cs
->c_naux
!= 1)
1098 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
1099 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1101 new = (struct coff_context_stack
*)
1102 xmalloc (sizeof (struct coff_context_stack
));
1103 new->depth
= depth
= 0;
1105 coff_context_stack
= new;
1107 new->old_blocks
= pending_blocks
;
1108 new->start_addr
= fcn_start_addr
;
1109 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1110 new->name
= process_coff_symbol (&fcn_cs_saved
,
1111 &fcn_aux_saved
, objfile
);
1113 else if (STREQ (cs
->c_name
, ".ef"))
1115 /* the value of .ef is the address of epilogue code;
1116 * not useful for gdb
1118 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1119 contains number of lines to '}' */
1120 new = coff_context_stack
;
1123 complain (&ef_complaint
, cs
->c_symnum
);
1124 within_function
= 0;
1127 if (cs
->c_naux
!= 1) {
1128 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
1129 fcn_last_line
= 0x7FFFFFFF;
1131 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1133 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
1135 coff_finish_block (new->name
, &coff_local_symbols
, new->old_blocks
,
1137 #if defined (FUNCTION_EPILOGUE_SIZE)
1138 /* This macro should be defined only on
1140 fcn_aux_saved.x_sym.x_misc.x_fsize
1141 field is always zero.
1142 So use the .bf record information that
1143 points to the epilogue and add the size
1145 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
1147 fcn_cs_saved
.c_value
+
1148 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
1152 coff_context_stack
= 0;
1153 within_function
= 0;
1159 if (STREQ (cs
->c_name
, ".bb"))
1161 new = (struct coff_context_stack
*)
1162 xmalloc (sizeof (struct coff_context_stack
));
1165 new->next
= coff_context_stack
;
1166 coff_context_stack
= new;
1167 new->locals
= coff_local_symbols
;
1168 new->old_blocks
= pending_blocks
;
1169 new->start_addr
= cs
->c_value
;
1171 coff_local_symbols
= 0;
1173 else if (STREQ (cs
->c_name
, ".eb"))
1175 new = coff_context_stack
;
1176 if (new == 0 || depth
!= new->depth
)
1178 complain (&eb_complaint
, (char *)symnum
);
1181 if (coff_local_symbols
&& coff_context_stack
->next
)
1183 /* Make a block for the local symbols within. */
1184 coff_finish_block (0, &coff_local_symbols
, new->old_blocks
,
1185 new->start_addr
, cs
->c_value
, objfile
);
1188 coff_local_symbols
= new->locals
;
1189 coff_context_stack
= new->next
;
1195 process_coff_symbol (cs
, &main_aux
, objfile
);
1200 if (last_source_file
)
1201 coff_end_symtab (objfile
);
1203 /* Patch up any opaque types (references to types that are not defined
1204 in the file where they are referenced, e.g. "struct foo *bar"). */
1205 ALL_OBJFILE_SYMTABS (objfile
, s
)
1206 patch_opaque_types (s
);
1208 current_objfile
= NULL
;
1211 /* Routines for reading headers and symbols from executable. */
1214 /* Move these XXXMAGIC symbol defns into BFD! */
1216 /* Read COFF file header, check magic number,
1217 and return number of symbols. */
1218 read_file_hdr (chan
, file_hdr
)
1222 lseek (chan
, 0L, 0);
1223 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1226 switch (file_hdr
->f_magic
)
1241 #if defined (MC68KWRMAGIC) \
1242 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1256 case I960ROMAGIC
: /* Intel 960 */
1259 case I960RWMAGIC
: /* Intel 960 */
1261 return file_hdr
->f_nsyms
;
1265 if (BADMAG(file_hdr
))
1268 return file_hdr
->f_nsyms
;
1276 /* Read the next symbol, swap it, and return it in both internal_syment
1277 form, and coff_symbol form. Also return its first auxent, if any,
1278 in internal_auxent form, and skip any other auxents. */
1281 read_one_sym (cs
, sym
, aux
)
1282 register struct coff_symbol
*cs
;
1283 register struct internal_syment
*sym
;
1284 register union internal_auxent
*aux
;
1288 cs
->c_symnum
= symnum
;
1289 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1290 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1291 cs
->c_naux
= sym
->n_numaux
& 0xff;
1292 if (cs
->c_naux
>= 1)
1294 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1295 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1297 /* If more than one aux entry, read past it (only the first aux
1299 for (i
= 1; i
< cs
->c_naux
; i
++)
1300 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1302 cs
->c_name
= getsymname (sym
);
1303 cs
->c_value
= sym
->n_value
;
1304 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1305 cs
->c_secnum
= sym
->n_scnum
;
1306 cs
->c_type
= (unsigned) sym
->n_type
;
1307 if (!SDB_TYPE (cs
->c_type
))
1310 symnum
+= 1 + cs
->c_naux
;
1313 /* Support for string table handling */
1315 static char *stringtab
= NULL
;
1318 init_stringtab (chan
, offset
)
1324 unsigned char lengthbuf
[4];
1328 if (lseek (chan
, offset
, 0) < 0)
1331 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1332 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1334 /* If no string table is needed, then the file may end immediately
1335 after the symbols. Just return with `stringtab' set to null. */
1336 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1339 stringtab
= (char *) xmalloc (length
);
1340 if (stringtab
== NULL
)
1343 memcpy (stringtab
, &length
, sizeof length
);
1344 if (length
== sizeof length
) /* Empty table -- just the count */
1347 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1348 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1363 getsymname (symbol_entry
)
1364 struct internal_syment
*symbol_entry
;
1366 static char buffer
[SYMNMLEN
+1];
1369 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1371 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1375 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1376 buffer
[SYMNMLEN
] = '\0';
1382 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1383 only the last component of the name. Result is in static storage and
1384 is only good for temporary use. */
1387 getfilename (aux_entry
)
1388 union internal_auxent
*aux_entry
;
1390 static char buffer
[BUFSIZ
];
1391 register char *temp
;
1394 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1395 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1398 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1399 buffer
[FILNMLEN
] = '\0';
1402 if ((temp
= strrchr (result
, '/')) != NULL
)
1407 /* Support for line number handling */
1408 static char *linetab
= NULL
;
1409 static long linetab_offset
;
1410 static unsigned long linetab_size
;
1412 /* Read in all the line numbers for fast lookups later. Leave them in
1413 external (unswapped) format in memory; we'll swap them as we enter
1414 them into GDB's data structures. */
1417 init_lineno (chan
, offset
, size
)
1424 linetab_offset
= offset
;
1425 linetab_size
= size
;
1432 if (lseek (chan
, offset
, 0) < 0)
1435 /* Allocate the desired table, plus a sentinel */
1436 linetab
= (char *) xmalloc (size
+ local_linesz
);
1438 if (linetab
== NULL
)
1441 val
= myread (chan
, linetab
, size
);
1445 /* Terminate it with an all-zero sentinel record */
1446 memset (linetab
+ size
, 0, local_linesz
);
1459 #if !defined (L_LNNO32)
1460 #define L_LNNO32(lp) ((lp)->l_lnno)
1464 enter_linenos (file_offset
, first_line
, last_line
)
1466 register int first_line
;
1467 register int last_line
;
1469 register char *rawptr
;
1470 struct internal_lineno lptr
;
1472 if (file_offset
< linetab_offset
)
1474 complain (&lineno_complaint
, file_offset
);
1475 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1477 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1480 rawptr
= &linetab
[file_offset
- linetab_offset
];
1482 /* skip first line entry for each function */
1483 rawptr
+= local_linesz
;
1484 /* line numbers start at one for the first line of the function */
1488 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1489 rawptr
+= local_linesz
;
1490 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1491 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1492 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1499 patch_type (type
, real_type
)
1501 struct type
*real_type
;
1503 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1504 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1505 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1507 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1508 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1509 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1511 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1513 if (TYPE_NAME (real_target
))
1515 if (TYPE_NAME (target
))
1516 free (TYPE_NAME (target
));
1517 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1521 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1522 so that they can be used to print out opaque data structures properly. */
1525 patch_opaque_types (s
)
1528 register struct block
*b
;
1530 register struct symbol
*real_sym
;
1532 /* Go through the per-file symbols only */
1533 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1534 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1536 /* Find completed typedefs to use to fix opaque ones.
1537 Remove syms from the chain when their types are stored,
1538 but search the whole chain, as there may be several syms
1539 from different files with the same name. */
1540 real_sym
= BLOCK_SYM (b
, i
);
1541 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1542 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1543 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1544 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1546 register char *name
= SYMBOL_NAME (real_sym
);
1547 register int hash
= hashname (name
);
1548 register struct symbol
*sym
, *prev
;
1551 for (sym
= opaque_type_chain
[hash
]; sym
;)
1553 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1554 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1558 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1562 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1565 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1569 sym
= SYMBOL_VALUE_CHAIN (prev
);
1573 sym
= opaque_type_chain
[hash
];
1579 sym
= SYMBOL_VALUE_CHAIN (sym
);
1586 static struct symbol
*
1587 process_coff_symbol (cs
, aux
, objfile
)
1588 register struct coff_symbol
*cs
;
1589 register union internal_auxent
*aux
;
1590 struct objfile
*objfile
;
1592 register struct symbol
*sym
1593 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1594 sizeof (struct symbol
));
1596 struct type
*temptype
;
1598 memset (sym
, 0, sizeof (struct symbol
));
1600 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1601 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1604 /* default assumptions */
1605 SYMBOL_VALUE (sym
) = cs
->c_value
;
1606 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1608 if (ISFCN (cs
->c_type
))
1611 /* FIXME: This has NOT been tested. The DBX version has.. */
1612 /* Generate a template for the type of this function. The
1613 types of the arguments will be added as we read the symbol
1615 struct type
*new = (struct type
*)
1616 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1618 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1619 sizeof(struct type
));
1620 SYMBOL_TYPE (sym
) = new;
1621 in_function_type
= SYMBOL_TYPE(sym
);
1624 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1627 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1628 if (cs
->c_sclass
== C_STAT
)
1629 coff_add_symbol_to_list (sym
, &coff_file_symbols
);
1630 else if (cs
->c_sclass
== C_EXT
)
1631 coff_add_symbol_to_list (sym
, &coff_global_symbols
);
1635 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1636 switch (cs
->c_sclass
)
1642 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1643 coff_add_symbol_to_list (sym
, &coff_local_symbols
);
1647 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1648 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1649 coff_add_symbol_to_list (sym
, &coff_global_symbols
);
1653 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1654 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1655 if (within_function
) {
1656 /* Static symbol of local scope */
1657 coff_add_symbol_to_list (sym
, &coff_local_symbols
);
1660 /* Static symbol at top level of file */
1661 coff_add_symbol_to_list (sym
, &coff_file_symbols
);
1665 #ifdef C_GLBLREG /* AMD coff */
1669 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1670 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1671 coff_add_symbol_to_list (sym
, &coff_local_symbols
);
1678 SYMBOL_CLASS (sym
) = LOC_ARG
;
1680 /* FIXME: This has not been tested. */
1681 /* Add parameter to function. */
1682 add_param_to_type(&in_function_type
,sym
);
1684 coff_add_symbol_to_list (sym
, &coff_local_symbols
);
1685 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1686 /* If PCC says a parameter is a short or a char,
1687 aligned on an int boundary, realign it to the "little end"
1689 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1690 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1691 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1692 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1694 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1695 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1701 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1702 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1703 coff_add_symbol_to_list (sym
, &coff_local_symbols
);
1704 #if !defined (BELIEVE_PCC_PROMOTION)
1705 /* FIXME: This should retain the current type, since it's just
1706 a register value. gnu@adobe, 26Feb93 */
1707 /* If PCC says a parameter is a short or a char,
1708 it is really an int. */
1709 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1710 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1711 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1713 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1714 ? lookup_fundamental_type (current_objfile
,
1715 FT_UNSIGNED_INTEGER
)
1722 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1723 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1725 /* If type has no name, give it one */
1726 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1727 TYPE_NAME (SYMBOL_TYPE (sym
)) = concat (SYMBOL_NAME (sym
), NULL
);
1729 /* Keep track of any type which points to empty structured type,
1730 so it can be filled from a definition from another file. A
1731 simple forward reference (TYPE_CODE_UNDEF) is not an
1732 empty structured type, though; the forward references
1733 work themselves out via the magic of coff_lookup_type. */
1734 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1735 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1736 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1739 register int i
= hashname (SYMBOL_NAME (sym
));
1741 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1742 opaque_type_chain
[i
] = sym
;
1744 coff_add_symbol_to_list (sym
, &coff_file_symbols
);
1750 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1751 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1753 /* Some compilers try to be helpful by inventing "fake"
1754 names for anonymous enums, structures, and unions, like
1755 "~0fake" or ".0fake". Thanks, but no thanks... */
1756 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1757 if (SYMBOL_NAME(sym
) != NULL
1758 && *SYMBOL_NAME(sym
) != '~'
1759 && *SYMBOL_NAME(sym
) != '.')
1760 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1761 concat (SYMBOL_NAME (sym
), NULL
);
1763 coff_add_symbol_to_list (sym
, &coff_file_symbols
);
1773 /* Decode a coff type specifier;
1774 return the type that is meant. */
1778 decode_type (cs
, c_type
, aux
)
1779 register struct coff_symbol
*cs
;
1780 unsigned int c_type
;
1781 register union internal_auxent
*aux
;
1783 register struct type
*type
= 0;
1784 unsigned int new_c_type
;
1786 if (c_type
& ~N_BTMASK
)
1788 new_c_type
= DECREF (c_type
);
1791 type
= decode_type (cs
, new_c_type
, aux
);
1792 type
= lookup_pointer_type (type
);
1794 else if (ISFCN (c_type
))
1796 type
= decode_type (cs
, new_c_type
, aux
);
1797 type
= lookup_function_type (type
);
1799 else if (ISARY (c_type
))
1802 register unsigned short *dim
;
1803 struct type
*base_type
, *index_type
, *range_type
;
1805 /* Define an array type. */
1806 /* auxent refers to array, not base type */
1807 if (aux
->x_sym
.x_tagndx
.l
== 0)
1810 /* shift the indices down */
1811 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1814 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1818 base_type
= decode_type (cs
, new_c_type
, aux
);
1819 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1821 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1823 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1828 /* Reference to existing type. This only occurs with the
1829 struct, union, and enum types. EPI a29k coff
1830 fakes us out by producing aux entries with a nonzero
1831 x_tagndx for definitions of structs, unions, and enums, so we
1832 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1833 with pointers to pointers to defined structs, and generates
1834 negative x_tagndx fields. */
1835 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1837 if (cs
->c_sclass
!= C_STRTAG
1838 && cs
->c_sclass
!= C_UNTAG
1839 && cs
->c_sclass
!= C_ENTAG
1840 && aux
->x_sym
.x_tagndx
.l
>= 0)
1842 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1845 complain (&tagndx_bad_complaint
, cs
->c_name
);
1846 /* And fall through to decode_base_type... */
1850 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1853 /* Decode a coff type specifier for function definition;
1854 return the type that the function returns. */
1858 decode_function_type (cs
, c_type
, aux
)
1859 register struct coff_symbol
*cs
;
1860 unsigned int c_type
;
1861 register union internal_auxent
*aux
;
1863 if (aux
->x_sym
.x_tagndx
.l
== 0)
1864 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1866 return decode_type (cs
, DECREF (c_type
), aux
);
1873 decode_base_type (cs
, c_type
, aux
)
1874 register struct coff_symbol
*cs
;
1875 unsigned int c_type
;
1876 register union internal_auxent
*aux
;
1883 /* shows up with "void (*foo)();" structure members */
1884 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1887 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1890 /* Shows up in DGUX, I think. Not sure where. */
1891 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1897 /* Intel 960 COFF has this symbol and meaning. */
1898 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1902 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1905 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1908 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1911 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1914 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1917 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1920 if (cs
->c_naux
!= 1)
1922 /* anonymous structure type */
1923 type
= coff_alloc_type (cs
->c_symnum
);
1924 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1925 TYPE_NAME (type
) = NULL
;
1926 /* This used to set the tag to "<opaque>". But I think setting it
1927 to NULL is right, and the printing code can print it as
1929 TYPE_TAG_NAME (type
) = NULL
;
1930 INIT_CPLUS_SPECIFIC(type
);
1931 TYPE_LENGTH (type
) = 0;
1932 TYPE_FIELDS (type
) = 0;
1933 TYPE_NFIELDS (type
) = 0;
1937 type
= coff_read_struct_type (cs
->c_symnum
,
1938 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1939 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1944 if (cs
->c_naux
!= 1)
1946 /* anonymous union type */
1947 type
= coff_alloc_type (cs
->c_symnum
);
1948 TYPE_NAME (type
) = NULL
;
1949 /* This used to set the tag to "<opaque>". But I think setting it
1950 to NULL is right, and the printing code can print it as
1952 TYPE_TAG_NAME (type
) = NULL
;
1953 INIT_CPLUS_SPECIFIC(type
);
1954 TYPE_LENGTH (type
) = 0;
1955 TYPE_FIELDS (type
) = 0;
1956 TYPE_NFIELDS (type
) = 0;
1960 type
= coff_read_struct_type (cs
->c_symnum
,
1961 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1962 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1964 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1968 if (cs
->c_naux
!= 1)
1970 /* anonymous enum type */
1971 type
= coff_alloc_type (cs
->c_symnum
);
1972 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1973 TYPE_NAME (type
) = NULL
;
1974 /* This used to set the tag to "<opaque>". But I think setting it
1975 to NULL is right, and the printing code can print it as
1977 TYPE_TAG_NAME (type
) = NULL
;
1978 TYPE_LENGTH (type
) = 0;
1979 TYPE_FIELDS (type
) = 0;
1980 TYPE_NFIELDS(type
) = 0;
1984 type
= coff_read_enum_type (cs
->c_symnum
,
1985 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1986 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1991 /* shouldn't show up here */
1995 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1998 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
2001 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2004 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2006 complain (&unexpected_type_complaint
, cs
->c_name
);
2007 return lookup_fundamental_type (current_objfile
, FT_VOID
);
2010 /* This page contains subroutines of read_type. */
2012 /* Read the description of a structure (or union type)
2013 and return an object describing the type. */
2015 static struct type
*
2016 coff_read_struct_type (index
, length
, lastsym
)
2023 struct nextfield
*next
;
2027 register struct type
*type
;
2028 register struct nextfield
*list
= 0;
2029 struct nextfield
*new;
2033 struct coff_symbol member_sym
;
2034 register struct coff_symbol
*ms
= &member_sym
;
2035 struct internal_syment sub_sym
;
2036 union internal_auxent sub_aux
;
2039 type
= coff_alloc_type (index
);
2040 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2041 INIT_CPLUS_SPECIFIC(type
);
2042 TYPE_LENGTH (type
) = length
;
2044 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2046 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2048 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2050 switch (ms
->c_sclass
)
2055 /* Get space to record the next field's data. */
2056 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2060 /* Save the data. */
2061 list
->field
.name
= savestring (name
, strlen (name
));
2062 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
2063 list
->field
.bitpos
= 8 * ms
->c_value
;
2064 list
->field
.bitsize
= 0;
2070 /* Get space to record the next field's data. */
2071 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2075 /* Save the data. */
2076 list
->field
.name
= savestring (name
, strlen (name
));
2077 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
2078 list
->field
.bitpos
= ms
->c_value
;
2079 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2088 /* Now create the vector of fields, and record how big it is. */
2090 TYPE_NFIELDS (type
) = nfields
;
2091 TYPE_FIELDS (type
) = (struct field
*)
2092 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2094 /* Copy the saved-up fields into the field vector. */
2096 for (n
= nfields
; list
; list
= list
->next
)
2097 TYPE_FIELD (type
, --n
) = list
->field
;
2102 /* Read a definition of an enumeration type,
2103 and create and return a suitable type object.
2104 Also defines the symbols that represent the values of the type. */
2107 static struct type
*
2108 coff_read_enum_type (index
, length
, lastsym
)
2113 register struct symbol
*sym
;
2114 register struct type
*type
;
2117 struct coff_pending
**symlist
;
2118 struct coff_symbol member_sym
;
2119 register struct coff_symbol
*ms
= &member_sym
;
2120 struct internal_syment sub_sym
;
2121 union internal_auxent sub_aux
;
2122 struct coff_pending
*osyms
, *syms
;
2126 type
= coff_alloc_type (index
);
2127 if (within_function
)
2128 symlist
= &coff_local_symbols
;
2130 symlist
= &coff_file_symbols
;
2133 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2135 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2137 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2139 switch (ms
->c_sclass
)
2142 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
2143 memset (sym
, 0, sizeof (struct symbol
));
2145 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
2146 SYMBOL_CLASS (sym
) = LOC_CONST
;
2147 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2148 SYMBOL_VALUE (sym
) = ms
->c_value
;
2149 coff_add_symbol_to_list (sym
, symlist
);
2154 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2155 up the count of how many symbols to read. So stop
2162 /* Now fill in the fields of the type-structure. */
2165 TYPE_LENGTH (type
) = length
;
2167 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
2168 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2169 TYPE_NFIELDS (type
) = nsyms
;
2170 TYPE_FIELDS (type
) = (struct field
*)
2171 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2173 /* Find the symbols for the values and put them into the type.
2174 The symbols can be found in the symlist that we put them on
2175 to cause them to be defined. osyms contains the old value
2176 of that symlist; everything up to there was defined by us. */
2178 for (syms
= *symlist
, n
= nsyms
; syms
!= osyms
; syms
= syms
->next
)
2180 SYMBOL_TYPE (syms
->symbol
) = type
;
2181 TYPE_FIELD_NAME (type
, --n
) = SYMBOL_NAME (syms
->symbol
);
2182 TYPE_FIELD_VALUE (type
, n
) = 0;
2183 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (syms
->symbol
);
2184 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2187 /* This screws up perfectly good C programs with enums. FIXME. */
2188 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2189 if(TYPE_NFIELDS(type
) == 2 &&
2190 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2191 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2192 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2193 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2194 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2199 /* Fake up support for relocating symbol addresses. FIXME. */
2201 struct section_offsets coff_symfile_faker
= {0};
2203 struct section_offsets
*
2204 coff_symfile_offsets (objfile
, addr
)
2205 struct objfile
*objfile
;
2208 return &coff_symfile_faker
;
2211 /* Register our ability to parse symbols for coff BFD files */
2213 static struct sym_fns coff_sym_fns
=
2215 "coff", /* sym_name: name or name prefix of BFD target type */
2216 4, /* sym_namelen: number of significant sym_name chars */
2217 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2218 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2219 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2220 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2221 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2222 NULL
/* next: pointer to next struct sym_fns */
2226 _initialize_coffread ()
2228 add_symtab_fns(&coff_sym_fns
);