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 (C) 1987-1991 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 #include "breakpoint.h"
32 #include "internalcoff.h" /* Internal format of COFF symbols in BFD */
33 #include "libcoff.h" /* FIXME secret internal data from BFD */
35 static void add_symbol_to_list ();
36 static void read_coff_symtab ();
37 static void patch_opaque_types ();
38 static struct type
*decode_function_type ();
39 static struct type
*decode_type ();
40 static struct type
*decode_base_type ();
41 static struct type
*read_enum_type ();
42 static struct type
*read_struct_type ();
43 static void finish_block ();
44 static struct blockvector
*make_blockvector ();
45 static struct symbol
*process_coff_symbol ();
46 static int init_stringtab ();
47 static void free_stringtab ();
48 static char *getfilename ();
49 static char *getsymname ();
50 static int init_lineno ();
51 static void enter_linenos ();
52 static void read_one_sym ();
56 /* To be an sdb debug type, type must have at least a basic or primary
57 derived type. Using this rather than checking against T_NULL is
58 said to prevent core dumps if we try to operate on Michael Bloom
61 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
64 * Convert from an sdb register number to an internal gdb register number.
65 * This should be defined in tm.h, if REGISTER_NAMES is not set up
66 * to map one to one onto the sdb register numbers.
68 #ifndef SDB_REG_TO_REGNUM
69 # define SDB_REG_TO_REGNUM(value) (value)
72 /* Name of source file whose symbol data we are now processing.
73 This comes from a symbol named ".file". */
75 static char *last_source_file
;
77 /* Core address of start and end of text of current source file.
78 This comes from a ".text" symbol where x_nlinno > 0. */
80 static CORE_ADDR cur_src_start_addr
;
81 static CORE_ADDR cur_src_end_addr
;
83 /* Core address of the end of the first object file. */
84 static CORE_ADDR first_object_file_end
;
86 /* The addresses of the symbol table stream and number of symbols
87 of the object file we are reading (as copied into core). */
89 static FILE *nlist_stream_global
;
90 static int nlist_nsyms_global
;
92 /* The index in the symbol table of the last coff symbol that was processed. */
96 /* Vector of types defined so far, indexed by their coff symnum. */
98 static struct type
**type_vector
;
100 /* Number of elements allocated for type_vector currently. */
102 static int type_vector_length
;
104 /* Vector of line number information. */
106 static struct linetable
*line_vector
;
108 /* Index of next entry to go in line_vector_index. */
110 static int line_vector_index
;
112 /* Last line number recorded in the line vector. */
114 static int prev_line_number
;
116 /* Number of elements allocated for line_vector currently. */
118 static int line_vector_length
;
120 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
122 static char *temp_sym
;
123 static char *temp_aux
;
125 /* Local variables that hold the shift and mask values for the
126 COFF file that we are currently reading. These come back to us
127 from BFD, and are referenced by their macro names, as well as
128 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
129 macros from ../internalcoff.h . */
131 static unsigned local_n_btmask
;
132 static unsigned local_n_btshft
;
133 static unsigned local_n_tmask
;
134 static unsigned local_n_tshift
;
136 #define N_BTMASK local_n_btmask
137 #define N_BTSHFT local_n_btshft
138 #define N_TMASK local_n_tmask
139 #define N_TSHIFT local_n_tshift
141 /* Local variables that hold the sizes in the file of various COFF structures.
142 (We only need to know this to read them from the file -- BFD will then
143 translate the data in them, into `internal_xxx' structs in the right
144 byte order, alignment, etc.) */
146 static unsigned local_linesz
;
147 static unsigned local_symesz
;
148 static unsigned local_auxesz
;
151 /* Chain of typedefs of pointers to empty struct/union types.
152 They are chained thru the SYMBOL_VALUE_CHAIN. */
155 static struct symbol
*opaque_type_chain
[HASHSIZE
];
157 /* Record the symbols defined for each context in a list.
158 We don't create a struct block for the context until we
159 know how long to make it. */
163 struct pending
*next
;
164 struct symbol
*symbol
;
167 /* Here are the three lists that symbols are put on. */
169 struct pending
*file_symbols
; /* static at top level, and types */
171 struct pending
*global_symbols
; /* global functions and variables */
173 struct pending
*local_symbols
; /* everything local to lexical context */
175 /* List of unclosed lexical contexts
176 (that will become blocks, eventually). */
180 struct context_stack
*next
;
181 struct pending
*locals
;
182 struct pending_block
*old_blocks
;
184 CORE_ADDR start_addr
;
188 struct context_stack
*context_stack
;
190 /* Nonzero if within a function (so symbols should be local,
191 if nothing says specifically). */
196 /* The type of the function we are currently reading in. This is
197 used by define_symbol to record the type of arguments to a function. */
199 struct type
*in_function_type
;
202 /* List of blocks already made (lexical contexts already closed).
203 This is used at the end to make the blockvector. */
207 struct pending_block
*next
;
211 struct pending_block
*pending_blocks
;
213 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
214 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
216 /* Complaints about various problems in the file being read */
218 struct complaint ef_complaint
=
219 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
221 struct complaint no_aux_complaint
=
222 {"symbol %d without one aux entry", 0, 0};
224 struct complaint lineno_complaint
=
225 {"Line number pointer %d lower than start of line numbers", 0, 0};
228 /* Look up a coff type-number index. Return the address of the slot
229 where the type for that index is stored.
230 The type-number is in INDEX.
232 This can be used for finding the type associated with that index
233 or for associating a new type with the index. */
235 static struct type
**
236 coff_lookup_type (index
)
239 if (index
>= type_vector_length
)
241 int old_vector_length
= type_vector_length
;
243 type_vector_length
*= 2;
244 if (type_vector_length
< index
) {
245 type_vector_length
= index
* 2;
247 type_vector
= (struct type
**)
248 xrealloc (type_vector
, type_vector_length
* sizeof (struct type
*));
249 bzero (&type_vector
[old_vector_length
],
250 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
252 return &type_vector
[index
];
255 /* Make sure there is a type allocated for type number index
256 and return the type object.
257 This can create an empty (zeroed) type object. */
260 coff_alloc_type (index
)
263 register struct type
**type_addr
= coff_lookup_type (index
);
264 register struct type
*type
= *type_addr
;
266 /* If we are referring to a type not known at all yet,
267 allocate an empty type for it.
268 We will fill it in later if we find out how. */
271 type
= (struct type
*) obstack_alloc (symbol_obstack
,
272 sizeof (struct type
));
273 bzero (type
, sizeof (struct type
));
274 TYPE_VPTR_FIELDNO (type
) = -1;
280 /* maintain the lists of symbols and blocks */
282 /* Add a symbol to one of the lists of symbols. */
284 add_symbol_to_list (symbol
, listhead
)
285 struct symbol
*symbol
;
286 struct pending
**listhead
;
288 register struct pending
*link
289 = (struct pending
*) xmalloc (sizeof (struct pending
));
291 link
->next
= *listhead
;
292 link
->symbol
= symbol
;
296 /* Take one of the lists of symbols and make a block from it.
297 Put the block on the list of pending blocks. */
300 finish_block (symbol
, listhead
, old_blocks
, start
, end
)
301 struct symbol
*symbol
;
302 struct pending
**listhead
;
303 struct pending_block
*old_blocks
;
304 CORE_ADDR start
, end
;
306 register struct pending
*next
, *next1
;
307 register struct block
*block
;
308 register struct pending_block
*pblock
;
309 struct pending_block
*opblock
;
312 /* Count the length of the list of symbols. */
314 for (next
= *listhead
, i
= 0; next
; next
= next
->next
, i
++);
316 block
= (struct block
*)
317 obstack_alloc (symbol_obstack
, sizeof (struct block
) + (i
- 1) * sizeof (struct symbol
*));
319 /* Copy the symbols into the block. */
321 BLOCK_NSYMS (block
) = i
;
322 for (next
= *listhead
; next
; next
= next
->next
)
323 BLOCK_SYM (block
, --i
) = next
->symbol
;
325 BLOCK_START (block
) = start
;
326 BLOCK_END (block
) = end
;
327 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
329 /* Put the block in as the value of the symbol that names it. */
333 SYMBOL_BLOCK_VALUE (symbol
) = block
;
334 BLOCK_FUNCTION (block
) = symbol
;
337 BLOCK_FUNCTION (block
) = 0;
339 /* Now free the links of the list, and empty the list. */
341 for (next
= *listhead
; next
; next
= next1
)
348 /* Install this block as the superblock
349 of all blocks made since the start of this scope
350 that don't have superblocks yet. */
353 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
355 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0)
356 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
360 /* Record this block on the list of all blocks in the file.
361 Put it after opblock, or at the beginning if opblock is 0.
362 This puts the block in the list after all its subblocks. */
364 pblock
= (struct pending_block
*) xmalloc (sizeof (struct pending_block
));
365 pblock
->block
= block
;
368 pblock
->next
= opblock
->next
;
369 opblock
->next
= pblock
;
373 pblock
->next
= pending_blocks
;
374 pending_blocks
= pblock
;
378 static struct blockvector
*
381 register struct pending_block
*next
, *next1
;
382 register struct blockvector
*blockvector
;
385 /* Count the length of the list of blocks. */
387 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
389 blockvector
= (struct blockvector
*)
390 obstack_alloc (symbol_obstack
, sizeof (struct blockvector
) + (i
- 1) * sizeof (struct block
*));
392 /* Copy the blocks into the blockvector.
393 This is done in reverse order, which happens to put
394 the blocks into the proper order (ascending starting address).
395 finish_block has hair to insert each block into the list
396 after its subblocks in order to make sure this is true. */
398 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
399 for (next
= pending_blocks
; next
; next
= next
->next
)
400 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
402 /* Now free the links of the list, and empty the list. */
404 for (next
= pending_blocks
; next
; next
= next1
)
414 /* Manage the vector of line numbers. */
417 record_line (line
, pc
)
421 struct linetable_entry
*e
;
422 /* Make sure line vector is big enough. */
424 if (line_vector_index
+ 2 >= line_vector_length
)
426 line_vector_length
*= 2;
427 line_vector
= (struct linetable
*)
428 xrealloc (line_vector
, sizeof (struct linetable
)
429 + (line_vector_length
430 * sizeof (struct linetable_entry
)));
433 e
= line_vector
->item
+ line_vector_index
++;
434 e
->line
= line
; e
->pc
= pc
;
437 /* Start a new symtab for a new source file.
438 This is called when a COFF ".file" symbol is seen;
439 it indicates the start of data for one original source file. */
448 last_source_file
= 0;
450 /* Initialize the source file line number information for this file. */
452 if (line_vector
) /* Unlikely, but maybe possible? */
454 line_vector_index
= 0;
455 line_vector_length
= 1000;
456 prev_line_number
= -2; /* Force first line number to be explicit */
457 line_vector
= (struct linetable
*)
458 xmalloc (sizeof (struct linetable
)
459 + line_vector_length
* sizeof (struct linetable_entry
));
462 /* Save the vital information from when starting to read a file,
463 for use when closing off the current file.
464 NAME is the file name the symbols came from, START_ADDR is the first
465 text address for the file, and SIZE is the number of bytes of text. */
468 complete_symtab (name
, start_addr
, size
)
470 CORE_ADDR start_addr
;
473 last_source_file
= savestring (name
, strlen (name
));
474 cur_src_start_addr
= start_addr
;
475 cur_src_end_addr
= start_addr
+ size
;
477 if (entry_point
< cur_src_end_addr
478 && entry_point
>= cur_src_start_addr
)
480 startup_file_start
= cur_src_start_addr
;
481 startup_file_end
= cur_src_end_addr
;
485 /* Finish the symbol definitions for one main source file,
486 close off all the lexical contexts for that file
487 (creating struct block's for them), then make the
488 struct symtab for that file and put it in the list of all such. */
492 struct objfile
*objfile
;
494 register struct symtab
*symtab
;
495 register struct context_stack
*cstk
;
496 register struct blockvector
*blockvector
;
497 register struct linetable
*lv
;
499 /* Finish the lexical context of the last function in the file. */
503 cstk
= context_stack
;
505 /* Make a block for the local symbols within. */
506 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
507 cstk
->start_addr
, cur_src_end_addr
);
511 /* Ignore a file that has no functions with real debugging info. */
512 if (pending_blocks
== 0 && file_symbols
== 0 && global_symbols
== 0)
516 line_vector_length
= -1;
517 last_source_file
= 0;
521 /* Create the two top-level blocks for this file (STATIC_BLOCK and
523 finish_block (0, &file_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
);
524 finish_block (0, &global_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
);
526 /* Create the blockvector that points to all the file's blocks. */
527 blockvector
= make_blockvector ();
529 /* Now create the symtab object for this source file. */
530 symtab
= allocate_symtab (last_source_file
, objfile
);
532 /* Fill in its components. */
533 symtab
->blockvector
= blockvector
;
534 symtab
->free_code
= free_linetable
;
535 symtab
->free_ptr
= 0;
536 symtab
->filename
= last_source_file
;
537 symtab
->dirname
= NULL
;
539 lv
->nitems
= line_vector_index
;
540 symtab
->linetable
= (struct linetable
*)
541 xrealloc (lv
, (sizeof (struct linetable
)
542 + lv
->nitems
* sizeof (struct linetable_entry
)));
544 free_named_symtabs (symtab
->filename
);
546 /* Link the new symtab into the list of such. */
547 symtab
->next
= symtab_list
;
548 symtab_list
= symtab
;
550 /* Reinitialize for beginning of new file. */
552 line_vector_length
= -1;
553 last_source_file
= 0;
557 record_misc_function (name
, address
)
561 /* We don't want TDESC entry points on the misc_function_vector */
562 if (name
[0] == '@') return;
564 /* mf_text isn't true, but apparently COFF doesn't tell us what it really
565 is, so this guess is more useful than mf_unknown. */
566 prim_record_misc_function (savestring (name
, strlen (name
)),
571 /* coff_symfile_init ()
572 is the coff-specific initialization routine for reading symbols.
573 It is passed a struct sym_fns which contains, among other things,
574 the BFD for the file whose symbols are being read, and a slot for
575 a pointer to "private data" which we fill with cookies and other
576 treats for coff_symfile_read ().
578 We will only be called if this is a COFF or COFF-like file.
579 BFD handles figuring out the format of the file, and code in symtab.c
580 uses BFD's determination to vector to us.
582 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
584 struct coff_symfile_info
{
585 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
586 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
589 static int text_bfd_scnum
;
592 coff_symfile_init (sf
)
596 bfd
*abfd
= sf
->sym_bfd
;
598 /* Allocate struct to keep track of the symfile */
599 /* FIXME memory leak */
600 sf
->sym_private
= xmalloc (sizeof (struct coff_symfile_info
));
602 /* Save startup file's range of PC addresses to help blockframe.c
603 decide where the bottom of the stack is. */
604 if (bfd_get_file_flags (abfd
) & EXEC_P
)
606 /* Executable file -- record its entry point so we'll recognize
607 the startup file because it contains the entry point. */
608 entry_point
= bfd_get_start_address (abfd
);
612 /* Examination of non-executable.o files. Short-circuit this stuff. */
613 /* ~0 will not be in any file, we hope. */
615 /* set the startup file to be an empty range. */
616 startup_file_start
= 0;
617 startup_file_end
= 0;
619 /* Save the section number for the text section */
620 if (section
= bfd_get_section_by_name(abfd
,".text"))
621 text_bfd_scnum
= section
->index
;
626 /* This function is called for every section; it finds the outer limits
627 of the line table (minimum and maximum file offset) so that the
628 mainline code can read the whole thing for efficiency. */
632 find_linenos (abfd
, asect
, vpinfo
)
637 struct coff_symfile_info
*info
;
639 file_ptr offset
, maxoff
;
641 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
642 count
= asect
->lineno_count
;
647 size
= count
* local_linesz
;
649 info
= (struct coff_symfile_info
*)vpinfo
;
650 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
651 offset
= asect
->line_filepos
;
654 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
655 info
->min_lineno_offset
= offset
;
657 maxoff
= offset
+ size
;
658 if (maxoff
> info
->max_lineno_offset
)
659 info
->max_lineno_offset
= maxoff
;
663 /* The BFD for this file -- only good while we're actively reading
664 symbols into a psymtab or a symtab. */
666 static bfd
*symfile_bfd
;
668 /* Read a symbol file, after initialization by coff_symfile_init. */
669 /* FIXME! Addr and Mainline are not used yet -- this will not work for
670 shared libraries or add_file! */
674 coff_symfile_read (sf
, addr
, mainline
)
679 struct coff_symfile_info
*info
= (struct coff_symfile_info
*)sf
->sym_private
;
680 bfd
*abfd
= sf
->objfile
->obfd
;
681 coff_data_type
*cdata
= coff_data (abfd
);
682 char *name
= bfd_get_filename (abfd
);
687 int stringtab_offset
;
689 symfile_bfd
= abfd
; /* Kludge for swap routines */
691 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
692 desc
= fileno ((FILE *)(abfd
->iostream
)); /* File descriptor */
693 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
694 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
695 stringtab_offset
= symtab_offset
+ /* String table file offset */
696 num_symbols
* cdata
->local_symesz
;
698 /* Set a few file-statics that give us specific information about
699 the particular COFF file format we're reading. */
700 local_linesz
= cdata
->local_linesz
;
701 local_n_btmask
= cdata
->local_n_btmask
;
702 local_n_btshft
= cdata
->local_n_btshft
;
703 local_n_tmask
= cdata
->local_n_tmask
;
704 local_n_tshift
= cdata
->local_n_tshift
;
705 local_linesz
= cdata
->local_linesz
;
706 local_symesz
= cdata
->local_symesz
;
707 local_auxesz
= cdata
->local_auxesz
;
709 /* Allocate space for raw symbol and aux entries, based on their
710 space requirements as reported by BFD. */
711 temp_sym
= (char *) xmalloc
712 (cdata
->local_symesz
+ cdata
->local_auxesz
);
713 temp_aux
= temp_sym
+ cdata
->local_symesz
;
714 make_cleanup (free_current_contents
, &temp_sym
);
717 /* Read the line number table, all at once. */
718 info
->min_lineno_offset
= 0;
719 info
->max_lineno_offset
= 0;
720 bfd_map_over_sections (abfd
, find_linenos
, info
);
722 val
= init_lineno (desc
, info
->min_lineno_offset
,
723 info
->max_lineno_offset
- info
->min_lineno_offset
);
725 error ("\"%s\": error reading line numbers\n", name
);
727 /* Now read the string table, all at once. */
729 val
= init_stringtab (desc
, stringtab_offset
);
731 error ("\"%s\": can't get string table", name
);
732 make_cleanup (free_stringtab
, 0);
734 /* Position to read the symbol table. Do not read it all at once. */
735 val
= lseek (desc
, (long)symtab_offset
, 0);
737 perror_with_name (name
);
739 init_misc_bunches ();
740 make_cleanup (discard_misc_bunches
, 0);
742 /* Now that the executable file is positioned at symbol table,
743 process it and define symbols accordingly. */
745 read_coff_symtab (desc
, num_symbols
, sf
->objfile
);
747 patch_opaque_types ();
749 /* Sort symbols alphabetically within each block. */
751 sort_all_symtab_syms ();
753 /* Go over the misc symbol bunches and install them in vector. */
755 condense_misc_bunches (!mainline
);
757 /* Make a default for file to list. */
759 select_source_symtab (0); /* FIXME, this might be too slow, see dbxread */
768 /* Simplified internal version of coff symbol table information */
772 int c_symnum
; /* symbol number of this entry */
773 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
780 /* Given pointers to a symbol table in coff style exec file,
781 analyze them and create struct symtab's describing the symbols.
782 NSYMS is the number of symbols in the symbol table.
783 We read them one at a time using read_one_sym (). */
786 read_coff_symtab (desc
, nsyms
, objfile
)
789 struct objfile
*objfile
;
791 int newfd
; /* Avoid multiple closes on same desc */
793 register struct context_stack
*new;
794 struct coff_symbol coff_symbol
;
795 register struct coff_symbol
*cs
= &coff_symbol
;
796 static struct internal_syment main_sym
;
797 static union internal_auxent main_aux
;
798 struct coff_symbol fcn_cs_saved
;
799 static struct internal_syment fcn_sym_saved
;
800 static union internal_auxent fcn_aux_saved
;
802 /* A .file is open. */
803 int in_source_file
= 0;
804 int num_object_files
= 0;
805 int next_file_symnum
= -1;
807 /* Name of the current file. */
808 char *filestring
= "";
814 struct cleanup
*old_chain
;
819 fatal ("Too many open files");
820 stream
= fdopen (newfd
, "r");
822 /* These cleanups will be discarded below if we succeed. */
823 old_chain
= make_cleanup (free_objfile
, objfile
);
824 make_cleanup (fclose
, stream
);
826 nlist_stream_global
= stream
;
827 nlist_nsyms_global
= nsyms
;
828 last_source_file
= 0;
829 bzero (opaque_type_chain
, sizeof opaque_type_chain
);
831 if (type_vector
) /* Get rid of previous one */
833 type_vector_length
= 160;
834 type_vector
= (struct type
**)
835 xmalloc (type_vector_length
* sizeof (struct type
*));
836 bzero (type_vector
, type_vector_length
* sizeof (struct type
*));
841 while (symnum
< nsyms
)
843 QUIT
; /* Make this command interruptable. */
844 read_one_sym (cs
, &main_sym
, &main_aux
);
847 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
848 cs
->c_name
[2] << 8 | cs
->c_name
[3];
849 if (int_sem_val
== temp_sem_val
)
850 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
853 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
855 if (last_source_file
)
856 end_symtab (objfile
);
859 complete_symtab ("_globals_", 0, first_object_file_end
);
860 /* done with all files, everything from here on out is globals */
863 /* Special case for file with type declarations only, no text. */
864 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
865 && cs
->c_secnum
== N_DEBUG
)
866 complete_symtab (filestring
, 0, 0);
868 /* Typedefs should not be treated as symbol definitions. */
869 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
871 /* record as misc function. if we get '.bf' next,
872 * then we undo this step
874 record_misc_function (cs
->c_name
, cs
->c_value
);
876 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
877 fcn_start_addr
= cs
->c_value
;
879 fcn_sym_saved
= main_sym
;
880 fcn_aux_saved
= main_aux
;
884 switch (cs
->c_sclass
)
893 printf ("Bad n_sclass = %d\n", cs
->c_sclass
);
898 * c_value field contains symnum of next .file entry in table
899 * or symnum of first global after last .file.
901 next_file_symnum
= cs
->c_value
;
902 filestring
= getfilename (&main_aux
);
904 * Complete symbol table for last object file
905 * containing debugging information.
907 if (last_source_file
)
909 end_symtab (objfile
);
916 if (cs
->c_name
[0] == '.') {
917 if (strcmp (cs
->c_name
, ".text") == 0) {
918 /* FIXME: don't wire in ".text" as section name
920 if (++num_object_files
== 1) {
921 /* last address of startup file */
922 first_object_file_end
= cs
->c_value
+
923 main_aux
.x_scn
.x_scnlen
;
925 /* Check for in_source_file deals with case of
926 a file with debugging symbols
927 followed by a later file with no symbols. */
929 complete_symtab (filestring
, cs
->c_value
,
930 main_aux
.x_scn
.x_scnlen
);
933 /* flush rest of '.' symbols */
936 else if (!SDB_TYPE (cs
->c_type
)
937 && cs
->c_name
[0] == 'L'
938 && (strncmp (cs
->c_name
, "LI%", 3) == 0
939 || strncmp (cs
->c_name
, "LF%", 3) == 0
940 || strncmp (cs
->c_name
,"LC%",3) == 0
941 || strncmp (cs
->c_name
,"LP%",3) == 0
942 || strncmp (cs
->c_name
,"LPB%",4) == 0
943 || strncmp (cs
->c_name
,"LBB%",4) == 0
944 || strncmp (cs
->c_name
,"LBE%",4) == 0
945 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
946 /* At least on a 3b1, gcc generates swbeg and string labels
947 that look like this. Ignore them. */
949 /* fall in for static symbols that don't start with '.' */
951 if (!SDB_TYPE (cs
->c_type
)) {
952 /* FIXME: This is BOGUS Will Robinson!
953 Coff should provide the SEC_CODE flag for executable sections,
954 then if we could look up sections by section number we
955 could see if the flags indicate SEC_CODE. If so, then
956 record this symbol as a miscellaneous function. But why
957 are absolute syms recorded as functions, anyway? */
958 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
959 record_misc_function (cs
->c_name
, cs
->c_value
);
965 (void) process_coff_symbol (cs
, &main_aux
);
969 if (strcmp (cs
->c_name
, ".bf") == 0)
973 /* value contains address of first non-init type code */
974 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
975 contains line number of '{' } */
977 complain (no_aux_complaint
, cs
->c_symnum
);
978 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
980 new = (struct context_stack
*)
981 xmalloc (sizeof (struct context_stack
));
982 new->depth
= depth
= 0;
986 new->old_blocks
= pending_blocks
;
987 new->start_addr
= fcn_start_addr
;
988 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
989 new->name
= process_coff_symbol (&fcn_cs_saved
,
992 else if (strcmp (cs
->c_name
, ".ef") == 0)
994 /* the value of .ef is the address of epilogue code;
997 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
998 contains number of lines to '}' */
1002 complain (&ef_complaint
, cs
->c_symnum
);
1003 within_function
= 0;
1006 if (cs
->c_naux
!= 1) {
1007 complain (no_aux_complaint
, cs
->c_symnum
);
1008 fcn_last_line
= 0x7FFFFFFF;
1010 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1012 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
1014 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1016 #if defined (FUNCTION_EPILOGUE_SIZE)
1017 /* This macro should be defined only on
1019 fcn_aux_saved.x_sym.x_misc.x_fsize
1020 field is always zero.
1021 So use the .bf record information that
1022 points to the epilogue and add the size
1024 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
1026 fcn_cs_saved
.c_value
+
1027 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1031 within_function
= 0;
1037 if (strcmp (cs
->c_name
, ".bb") == 0)
1039 new = (struct context_stack
*)
1040 xmalloc (sizeof (struct context_stack
));
1043 new->next
= context_stack
;
1044 context_stack
= new;
1045 new->locals
= local_symbols
;
1046 new->old_blocks
= pending_blocks
;
1047 new->start_addr
= cs
->c_value
;
1051 else if (strcmp (cs
->c_name
, ".eb") == 0)
1053 new = context_stack
;
1054 if (new == 0 || depth
!= new->depth
)
1055 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1057 if (local_symbols
&& context_stack
->next
)
1059 /* Make a block for the local symbols within. */
1060 finish_block (0, &local_symbols
, new->old_blocks
,
1061 new->start_addr
, cs
->c_value
);
1064 local_symbols
= new->locals
;
1065 context_stack
= new->next
;
1071 (void) process_coff_symbol (cs
, &main_aux
);
1076 if (last_source_file
)
1077 end_symtab (objfile
);
1079 discard_cleanups (old_chain
);
1082 /* Routines for reading headers and symbols from executable. */
1085 /* Move these XXXMAGIC symbol defns into BFD! */
1087 /* Read COFF file header, check magic number,
1088 and return number of symbols. */
1089 read_file_hdr (chan
, file_hdr
)
1093 lseek (chan
, 0L, 0);
1094 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1097 switch (file_hdr
->f_magic
)
1112 #if defined (MC68KWRMAGIC) \
1113 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1127 case I960ROMAGIC
: /* Intel 960 */
1130 case I960RWMAGIC
: /* Intel 960 */
1132 return file_hdr
->f_nsyms
;
1136 if (BADMAG(file_hdr
))
1139 return file_hdr
->f_nsyms
;
1147 /* Read the next symbol, swap it, and return it in both internal_syment
1148 form, and coff_symbol form. Also return its first auxent, if any,
1149 in internal_auxent form, and skip any other auxents. */
1152 read_one_sym (cs
, sym
, aux
)
1153 register struct coff_symbol
*cs
;
1154 register struct internal_syment
*sym
;
1155 register union internal_auxent
*aux
;
1159 cs
->c_symnum
= symnum
;
1160 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1161 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1162 cs
->c_naux
= sym
->n_numaux
& 0xff;
1163 if (cs
->c_naux
>= 1)
1165 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1166 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1168 /* If more than one aux entry, read past it (only the first aux
1170 for (i
= 1; i
< cs
->c_naux
; i
++)
1171 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1173 cs
->c_name
= getsymname (sym
);
1174 cs
->c_value
= sym
->n_value
;
1175 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1176 cs
->c_secnum
= sym
->n_scnum
;
1177 cs
->c_type
= (unsigned) sym
->n_type
;
1178 if (!SDB_TYPE (cs
->c_type
))
1181 symnum
+= 1 + cs
->c_naux
;
1184 /* Support for string table handling */
1186 static char *stringtab
= NULL
;
1189 init_stringtab (chan
, offset
)
1195 unsigned char lengthbuf
[4];
1203 if (lseek (chan
, offset
, 0) < 0)
1206 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1207 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1209 /* If no string table is needed, then the file may end immediately
1210 after the symbols. Just return with `stringtab' set to null. */
1211 if (val
!= sizeof length
|| length
< sizeof length
)
1214 stringtab
= (char *) xmalloc (length
);
1215 if (stringtab
== NULL
)
1218 bcopy (&length
, stringtab
, sizeof length
);
1219 if (length
== sizeof length
) /* Empty table -- just the count */
1222 val
= myread (chan
, stringtab
+ sizeof length
, length
- sizeof length
);
1223 if (val
!= length
- sizeof length
|| stringtab
[length
- 1] != '\0')
1238 getsymname (symbol_entry
)
1239 struct internal_syment
*symbol_entry
;
1241 static char buffer
[SYMNMLEN
+1];
1244 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1246 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1250 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1251 buffer
[SYMNMLEN
] = '\0';
1258 getfilename (aux_entry
)
1259 union internal_auxent
*aux_entry
;
1261 static char buffer
[BUFSIZ
];
1262 register char *temp
;
1264 extern char *rindex ();
1266 #ifndef COFF_NO_LONG_FILE_NAMES
1267 #if defined (x_zeroes)
1269 if (aux_entry
->x_zeroes
== 0)
1270 strcpy (buffer
, stringtab
+ aux_entry
->x_offset
);
1271 #else /* no x_zeroes */
1272 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1273 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1274 #endif /* no x_zeroes */
1276 #endif /* COFF_NO_LONG_FILE_NAMES */
1278 #if defined (x_name)
1280 strncpy (buffer
, aux_entry
->x_name
, FILNMLEN
);
1282 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1284 buffer
[FILNMLEN
] = '\0';
1287 if ((temp
= rindex (result
, '/')) != NULL
)
1292 /* Support for line number handling */
1293 static char *linetab
= NULL
;
1294 static long linetab_offset
;
1295 static unsigned long linetab_size
;
1297 /* Read in all the line numbers for fast lookups later. Leave them in
1298 external (unswapped) format in memory; we'll swap them as we enter
1299 them into GDB's data structures. */
1302 init_lineno (chan
, offset
, size
)
1309 linetab_offset
= offset
;
1310 linetab_size
= size
;
1315 if (lseek (chan
, offset
, 0) < 0)
1318 /* Allocate the desired table, plus a sentinel */
1319 linetab
= (char *) xmalloc (size
+ local_linesz
);
1321 val
= myread (chan
, linetab
, size
);
1325 /* Terminate it with an all-zero sentinel record */
1326 bzero (linetab
+ size
, local_linesz
);
1328 make_cleanup (free
, linetab
); /* Be sure it gets de-allocated. */
1332 #if !defined (L_LNNO32)
1333 #define L_LNNO32(lp) ((lp)->l_lnno)
1337 enter_linenos (file_offset
, first_line
, last_line
)
1339 register int first_line
;
1340 register int last_line
;
1342 register char *rawptr
;
1343 struct internal_lineno lptr
;
1345 if (file_offset
< linetab_offset
)
1347 complain (&lineno_complaint
, file_offset
);
1348 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1350 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1353 rawptr
= &linetab
[file_offset
- linetab_offset
];
1355 /* skip first line entry for each function */
1356 rawptr
+= local_linesz
;
1357 /* line numbers start at one for the first line of the function */
1361 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1362 rawptr
+= local_linesz
;
1363 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1364 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1365 record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1375 register char *p
= name
;
1376 register int total
= p
[0];
1389 return total
% HASHSIZE
;
1393 patch_type (type
, real_type
)
1395 struct type
*real_type
;
1397 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1398 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1399 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1401 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1402 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1403 TYPE_FIELDS (target
) = (struct field
*)
1404 obstack_alloc (symbol_obstack
, field_size
);
1406 bcopy (TYPE_FIELDS (real_target
), TYPE_FIELDS (target
), field_size
);
1408 if (TYPE_NAME (real_target
))
1410 if (TYPE_NAME (target
))
1411 free (TYPE_NAME (target
));
1412 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1416 /* Patch up all appropriate typdef symbols in the opaque_type_chains
1417 so that they can be used to print out opaque data structures properly */
1420 patch_opaque_types ()
1424 /* Look at each symbol in the per-file block of each symtab. */
1425 for (s
= symtab_list
; s
; s
= s
->next
)
1427 register struct block
*b
;
1430 /* Go through the per-file symbols only */
1431 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1432 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1434 register struct symbol
*real_sym
;
1436 /* Find completed typedefs to use to fix opaque ones.
1437 Remove syms from the chain when their types are stored,
1438 but search the whole chain, as there may be several syms
1439 from different files with the same name. */
1440 real_sym
= BLOCK_SYM (b
, i
);
1441 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1442 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1443 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1444 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1446 register char *name
= SYMBOL_NAME (real_sym
);
1447 register int hash
= hashname (name
);
1448 register struct symbol
*sym
, *prev
;
1451 for (sym
= opaque_type_chain
[hash
]; sym
;)
1453 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1454 !strcmp (name
+ 1, SYMBOL_NAME (sym
) + 1))
1457 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1459 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1461 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1464 sym
= SYMBOL_VALUE_CHAIN (prev
);
1466 sym
= opaque_type_chain
[hash
];
1471 sym
= SYMBOL_VALUE_CHAIN (sym
);
1479 #if defined (clipper)
1480 #define BELIEVE_PCC_PROMOTION 1
1483 static struct symbol
*
1484 process_coff_symbol (cs
, aux
)
1485 register struct coff_symbol
*cs
;
1486 register union internal_auxent
*aux
;
1488 register struct symbol
*sym
1489 = (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
1491 #ifdef NAMES_HAVE_UNDERSCORE
1497 bzero (sym
, sizeof (struct symbol
));
1499 name
= (name
[0] == '_' ? name
+ offset
: name
);
1500 SYMBOL_NAME (sym
) = obstack_copy0 (symbol_obstack
, name
, strlen (name
));
1502 /* default assumptions */
1503 SYMBOL_VALUE (sym
) = cs
->c_value
;
1504 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1506 if (ISFCN (cs
->c_type
))
1509 /* FIXME: This has NOT been tested. The DBX version has.. */
1510 /* Generate a template for the type of this function. The
1511 types of the arguments will be added as we read the symbol
1513 struct type
*new = (struct type
*)
1514 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1516 bcopy(lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1517 new, sizeof(struct type
));
1518 SYMBOL_TYPE (sym
) = new;
1519 in_function_type
= SYMBOL_TYPE(sym
);
1522 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1525 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1526 if (cs
->c_sclass
== C_STAT
)
1527 add_symbol_to_list (sym
, &file_symbols
);
1528 else if (cs
->c_sclass
== C_EXT
)
1529 add_symbol_to_list (sym
, &global_symbols
);
1533 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1534 switch (cs
->c_sclass
)
1540 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1541 add_symbol_to_list (sym
, &local_symbols
);
1545 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1546 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1547 add_symbol_to_list (sym
, &global_symbols
);
1551 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1552 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1553 if (within_function
) {
1554 /* Static symbol of local scope */
1555 add_symbol_to_list (sym
, &local_symbols
);
1558 /* Static symbol at top level of file */
1559 add_symbol_to_list (sym
, &file_symbols
);
1563 #ifdef C_GLBLREG /* AMD coff */
1567 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1568 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1569 add_symbol_to_list (sym
, &local_symbols
);
1576 SYMBOL_CLASS (sym
) = LOC_ARG
;
1578 /* FIXME: This has not bee tested. */
1579 /* Add parameter to function. */
1580 add_param_to_type(&in_function_type
,sym
);
1582 add_symbol_to_list (sym
, &local_symbols
);
1583 #if !defined (BELIEVE_PCC_PROMOTION)
1584 /* If PCC says a parameter is a short or a char,
1585 it is really an int. */
1586 if (SYMBOL_TYPE (sym
) == builtin_type_char
1587 || SYMBOL_TYPE (sym
) == builtin_type_short
)
1588 SYMBOL_TYPE (sym
) = builtin_type_int
;
1589 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
1590 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
1591 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
1596 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1597 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1598 add_symbol_to_list (sym
, &local_symbols
);
1599 #if !defined (BELIEVE_PCC_PROMOTION)
1600 /* If PCC says a parameter is a short or a char,
1601 it is really an int. */
1602 if (SYMBOL_TYPE (sym
) == builtin_type_char
1603 || SYMBOL_TYPE (sym
) == builtin_type_short
)
1604 SYMBOL_TYPE (sym
) = builtin_type_int
;
1605 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
1606 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
1607 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
1612 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1613 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1615 /* If type has no name, give it one */
1616 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
1617 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
1618 TYPE_NAME (SYMBOL_TYPE (sym
))
1619 = concat (SYMBOL_NAME (sym
), NULL
);
1621 /* Keep track of any type which points to empty structured type,
1622 so it can be filled from a definition from another file */
1623 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1624 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0)
1626 register int i
= hashname (SYMBOL_NAME (sym
));
1628 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1629 opaque_type_chain
[i
] = sym
;
1631 add_symbol_to_list (sym
, &file_symbols
);
1637 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1638 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1639 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
1640 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
1641 TYPE_NAME (SYMBOL_TYPE (sym
))
1643 (cs
->c_sclass
== C_ENTAG
1645 : (cs
->c_sclass
== C_STRTAG
1646 ? "struct " : "union ")),
1647 SYMBOL_NAME (sym
), NULL
);
1648 add_symbol_to_list (sym
, &file_symbols
);
1658 /* Decode a coff type specifier;
1659 return the type that is meant. */
1663 decode_type (cs
, c_type
, aux
)
1664 register struct coff_symbol
*cs
;
1665 unsigned int c_type
;
1666 register union internal_auxent
*aux
;
1668 register struct type
*type
= 0;
1669 unsigned int new_c_type
;
1671 if (c_type
& ~N_BTMASK
)
1673 new_c_type
= DECREF (c_type
);
1676 type
= decode_type (cs
, new_c_type
, aux
);
1677 type
= lookup_pointer_type (type
);
1679 else if (ISFCN (c_type
))
1681 type
= decode_type (cs
, new_c_type
, aux
);
1682 type
= lookup_function_type (type
);
1684 else if (ISARY (c_type
))
1687 register unsigned short *dim
;
1688 struct type
*base_type
;
1690 /* Define an array type. */
1691 /* auxent refers to array, not base type */
1692 if (aux
->x_sym
.x_tagndx
.l
== 0)
1695 /* shift the indices down */
1696 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1699 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1703 type
= (struct type
*)
1704 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1705 bzero (type
, sizeof (struct type
));
1707 base_type
= decode_type (cs
, new_c_type
, aux
);
1709 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1710 TYPE_TARGET_TYPE (type
) = base_type
;
1711 TYPE_LENGTH (type
) = n
* TYPE_LENGTH (base_type
);
1716 /* Reference to existing type */
1717 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1719 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1723 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1726 /* Decode a coff type specifier for function definition;
1727 return the type that the function returns. */
1731 decode_function_type (cs
, c_type
, aux
)
1732 register struct coff_symbol
*cs
;
1733 unsigned int c_type
;
1734 register union internal_auxent
*aux
;
1736 if (aux
->x_sym
.x_tagndx
.l
== 0)
1737 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1739 return decode_type (cs
, DECREF (c_type
), aux
);
1746 decode_base_type (cs
, c_type
, aux
)
1747 register struct coff_symbol
*cs
;
1748 unsigned int c_type
;
1749 register union internal_auxent
*aux
;
1756 /* shows up with "void (*foo)();" structure members */
1757 return builtin_type_void
;
1760 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1763 /* Shows up in DGUX, I think. Not sure where. */
1764 return builtin_type_void
; /* shouldn't show up here */
1770 /* Intel 960 COFF has this symbol and meaning. */
1771 return builtin_type_void
;
1775 return builtin_type_char
;
1778 return builtin_type_short
;
1781 return builtin_type_int
;
1784 return builtin_type_long
;
1787 return builtin_type_float
;
1790 return builtin_type_double
;
1793 if (cs
->c_naux
!= 1)
1795 /* anonymous structure type */
1796 type
= coff_alloc_type (cs
->c_symnum
);
1797 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1798 TYPE_NAME (type
) = concat ("struct ", "<opaque>", NULL
);
1799 TYPE_CPLUS_SPECIFIC (type
)
1800 = (struct cplus_struct_type
*) obstack_alloc (symbol_obstack
, sizeof (struct cplus_struct_type
));
1801 bzero (TYPE_CPLUS_SPECIFIC (type
), sizeof (struct cplus_struct_type
));
1802 TYPE_LENGTH (type
) = 0;
1803 TYPE_FIELDS (type
) = 0;
1804 TYPE_NFIELDS (type
) = 0;
1808 type
= read_struct_type (cs
->c_symnum
,
1809 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1810 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1815 if (cs
->c_naux
!= 1)
1817 /* anonymous union type */
1818 type
= coff_alloc_type (cs
->c_symnum
);
1819 TYPE_NAME (type
) = concat ("union ", "<opaque>", NULL
);
1820 TYPE_LENGTH (type
) = 0;
1821 TYPE_FIELDS (type
) = 0;
1822 TYPE_NFIELDS (type
) = 0;
1826 type
= read_struct_type (cs
->c_symnum
,
1827 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1828 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1830 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1834 return read_enum_type (cs
->c_symnum
,
1835 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1836 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1839 /* shouldn't show up here */
1843 return builtin_type_unsigned_char
;
1846 return builtin_type_unsigned_short
;
1849 return builtin_type_unsigned_int
;
1852 return builtin_type_unsigned_long
;
1854 printf ("unexpected type %d at symnum %d\n", c_type
, cs
->c_symnum
);
1855 return builtin_type_void
;
1858 /* This page contains subroutines of read_type. */
1860 /* Read the description of a structure (or union type)
1861 and return an object describing the type. */
1863 static struct type
*
1864 read_struct_type (index
, length
, lastsym
)
1871 struct nextfield
*next
;
1875 register struct type
*type
;
1876 register struct nextfield
*list
= 0;
1877 struct nextfield
*new;
1881 #ifdef NAMES_HAVE_UNDERSCORE
1886 struct coff_symbol member_sym
;
1887 register struct coff_symbol
*ms
= &member_sym
;
1888 struct internal_syment sub_sym
;
1889 union internal_auxent sub_aux
;
1892 type
= coff_alloc_type (index
);
1893 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1894 TYPE_CPLUS_SPECIFIC (type
)
1895 = (struct cplus_struct_type
*) obstack_alloc (symbol_obstack
, sizeof (struct cplus_struct_type
));
1896 bzero (TYPE_CPLUS_SPECIFIC (type
), sizeof (struct cplus_struct_type
));
1897 TYPE_LENGTH (type
) = length
;
1899 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1901 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1903 name
= (name
[0] == '_' ? name
+ offset
: name
);
1905 switch (ms
->c_sclass
)
1910 /* Get space to record the next field's data. */
1911 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1915 /* Save the data. */
1916 list
->field
.name
= savestring (name
, strlen (name
));
1917 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1918 list
->field
.bitpos
= 8 * ms
->c_value
;
1919 list
->field
.bitsize
= 0;
1925 /* Get space to record the next field's data. */
1926 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1930 /* Save the data. */
1931 list
->field
.name
= savestring (name
, strlen (name
));
1932 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1933 list
->field
.bitpos
= ms
->c_value
;
1934 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1943 /* Now create the vector of fields, and record how big it is. */
1945 TYPE_NFIELDS (type
) = nfields
;
1946 TYPE_FIELDS (type
) = (struct field
*)
1947 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1949 /* Copy the saved-up fields into the field vector. */
1951 for (n
= nfields
; list
; list
= list
->next
)
1952 TYPE_FIELD (type
, --n
) = list
->field
;
1957 /* Read a definition of an enumeration type,
1958 and create and return a suitable type object.
1959 Also defines the symbols that represent the values of the type. */
1960 /* Currently assumes it's sizeof (int) and doesn't use length. */
1963 static struct type
*
1964 read_enum_type (index
, length
, lastsym
)
1969 register struct symbol
*sym
;
1970 register struct type
*type
;
1973 struct pending
**symlist
;
1974 struct coff_symbol member_sym
;
1975 register struct coff_symbol
*ms
= &member_sym
;
1976 struct internal_syment sub_sym
;
1977 union internal_auxent sub_aux
;
1978 struct pending
*osyms
, *syms
;
1981 #ifdef NAMES_HAVE_UNDERSCORE
1987 type
= coff_alloc_type (index
);
1988 if (within_function
)
1989 symlist
= &local_symbols
;
1991 symlist
= &file_symbols
;
1994 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1996 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1998 name
= (name
[0] == '_' ? name
+ offset
: name
);
2000 switch (ms
->c_sclass
)
2003 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
2004 bzero (sym
, sizeof (struct symbol
));
2006 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
2007 SYMBOL_CLASS (sym
) = LOC_CONST
;
2008 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2009 SYMBOL_VALUE (sym
) = ms
->c_value
;
2010 add_symbol_to_list (sym
, symlist
);
2015 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2016 up the count of how many symbols to read. So stop
2023 /* Now fill in the fields of the type-structure. */
2025 /* FIXME: Should be sizeof (int) on target, not host. */
2026 TYPE_LENGTH (type
) = sizeof (int);
2027 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2028 TYPE_NFIELDS (type
) = nsyms
;
2029 TYPE_FIELDS (type
) = (struct field
*)
2030 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nsyms
);
2032 /* Find the symbols for the values and put them into the type.
2033 The symbols can be found in the symlist that we put them on
2034 to cause them to be defined. osyms contains the old value
2035 of that symlist; everything up to there was defined by us. */
2037 for (syms
= *symlist
, n
= nsyms
; syms
!= osyms
; syms
= syms
->next
)
2039 SYMBOL_TYPE (syms
->symbol
) = type
;
2040 TYPE_FIELD_NAME (type
, --n
) = SYMBOL_NAME (syms
->symbol
);
2041 TYPE_FIELD_VALUE (type
, n
) = 0;
2042 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (syms
->symbol
);
2043 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2045 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2046 if(TYPE_NFIELDS(type
) == 2 &&
2047 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2048 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2049 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2050 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2051 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2055 /* Register our ability to parse symbols for coff BFD files */
2057 static struct sym_fns coff_sym_fns
=
2060 coff_new_init
, coff_symfile_init
, coff_symfile_read
,
2064 _initialize_coffread ()
2066 add_symtab_fns(&coff_sym_fns
);