1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Design and support routines derived from dbxread.c, and UMAX COFF
3 specific routines written 9/1/87 by David D. Johnson, Brown University.
4 Revised 11/27/87 ddj@cs.brown.edu
5 Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
7 This file is part of GDB.
9 GDB is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 1, or (at your option)
14 GDB is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GDB; see the file COPYING. If not, write to
21 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include <sys/types.h>
36 #include <sys/param.h>
39 static void add_symbol_to_list ();
40 static void read_coff_symtab ();
41 static void patch_opaque_types ();
42 static struct type
*decode_function_type ();
43 static struct type
*decode_type ();
44 static struct type
*decode_base_type ();
45 static struct type
*read_enum_type ();
46 static struct type
*read_struct_type ();
47 static void finish_block ();
48 static struct blockvector
*make_blockvector ();
49 static struct symbol
*process_coff_symbol ();
50 static int init_stringtab ();
51 static void free_stringtab ();
52 static char *getfilename ();
53 static char *getsymname ();
54 static int init_lineno ();
55 static void enter_linenos ();
58 extern void free_all_symtabs ();
59 extern void free_all_psymtabs ();
62 /* Name of source file whose symbol data we are now processing.
63 This comes from a symbol named ".file". */
65 static char *last_source_file
;
67 /* Core address of start and end of text of current source file.
68 This comes from a ".text" symbol where x_nlinno > 0. */
70 static CORE_ADDR cur_src_start_addr
;
71 static CORE_ADDR cur_src_end_addr
;
73 /* Core address of the end of the first object file. */
74 static CORE_ADDR first_object_file_end
;
76 /* End of the text segment of the executable file,
77 as found in the symbol _etext. */
79 static CORE_ADDR end_of_text_addr
;
81 /* The addresses of the symbol table stream and number of symbols
82 of the object file we are reading (as copied into core). */
84 static FILE *nlist_stream_global
;
85 static int nlist_nsyms_global
;
87 /* The file, a.out and text section headers of the symbol file */
89 static FILHDR file_hdr
;
90 static SCNHDR text_hdr
;
91 static AOUTHDR aout_hdr
;
93 /* The index in the symbol table of the last coff symbol that was processed. */
97 /* Vector of types defined so far, indexed by their coff symnum. */
99 static struct typevector
*type_vector
;
101 /* Number of elements allocated for type_vector currently. */
103 static int type_vector_length
;
105 /* Vector of line number information. */
107 static struct linetable
*line_vector
;
109 /* Index of next entry to go in line_vector_index. */
111 static int line_vector_index
;
113 /* Last line number recorded in the line vector. */
115 static int prev_line_number
;
117 /* Number of elements allocated for line_vector currently. */
119 static int line_vector_length
;
121 /* Chain of typedefs of pointers to empty struct/union types.
122 They are chained thru the SYMBOL_VALUE. */
125 static struct symbol
*opaque_type_chain
[HASHSIZE
];
127 /* Record the symbols defined for each context in a list.
128 We don't create a struct block for the context until we
129 know how long to make it. */
133 struct pending
*next
;
134 struct symbol
*symbol
;
137 /* Here are the three lists that symbols are put on. */
139 struct pending
*file_symbols
; /* static at top level, and types */
141 struct pending
*global_symbols
; /* global functions and variables */
143 struct pending
*local_symbols
; /* everything local to lexical context */
145 /* List of unclosed lexical contexts
146 (that will become blocks, eventually). */
150 struct context_stack
*next
;
151 struct pending
*locals
;
152 struct pending_block
*old_blocks
;
154 CORE_ADDR start_addr
;
158 struct context_stack
*context_stack
;
160 /* Nonzero if within a function (so symbols should be local,
161 if nothing says specifically). */
165 /* List of blocks already made (lexical contexts already closed).
166 This is used at the end to make the blockvector. */
170 struct pending_block
*next
;
174 struct pending_block
*pending_blocks
;
176 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
177 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
179 /* File name symbols were loaded from. */
181 static char *symfile
;
183 /* Look up a coff type-number index. Return the address of the slot
184 where the type for that index is stored.
185 The type-number is in INDEX.
187 This can be used for finding the type associated with that index
188 or for associating a new type with the index. */
190 static struct type
**
191 coff_lookup_type (index
)
194 if (index
>= type_vector_length
)
196 int old_vector_length
= type_vector_length
;
198 type_vector_length
*= 2;
199 if (type_vector_length
< index
) {
200 type_vector_length
= index
* 2;
202 type_vector
= (struct typevector
*)
203 xrealloc (type_vector
, sizeof (struct typevector
)
204 + type_vector_length
* sizeof (struct type
*));
205 bzero (&type_vector
->type
[ old_vector_length
],
206 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
208 return &type_vector
->type
[index
];
211 /* Make sure there is a type allocated for type number index
212 and return the type object.
213 This can create an empty (zeroed) type object. */
216 coff_alloc_type (index
)
219 register struct type
**type_addr
= coff_lookup_type (index
);
220 register struct type
*type
= *type_addr
;
222 /* If we are referring to a type not known at all yet,
223 allocate an empty type for it.
224 We will fill it in later if we find out how. */
227 type
= (struct type
*) obstack_alloc (symbol_obstack
,
228 sizeof (struct type
));
229 bzero (type
, sizeof (struct type
));
235 /* maintain the lists of symbols and blocks */
237 /* Add a symbol to one of the lists of symbols. */
239 add_symbol_to_list (symbol
, listhead
)
240 struct symbol
*symbol
;
241 struct pending
**listhead
;
243 register struct pending
*link
244 = (struct pending
*) xmalloc (sizeof (struct pending
));
246 link
->next
= *listhead
;
247 link
->symbol
= symbol
;
251 /* Take one of the lists of symbols and make a block from it.
252 Put the block on the list of pending blocks. */
255 finish_block (symbol
, listhead
, old_blocks
, start
, end
)
256 struct symbol
*symbol
;
257 struct pending
**listhead
;
258 struct pending_block
*old_blocks
;
259 CORE_ADDR start
, end
;
261 register struct pending
*next
, *next1
;
262 register struct block
*block
;
263 register struct pending_block
*pblock
;
264 struct pending_block
*opblock
;
267 /* Count the length of the list of symbols. */
269 for (next
= *listhead
, i
= 0; next
; next
= next
->next
, i
++);
271 block
= (struct block
*)
272 obstack_alloc (symbol_obstack
, sizeof (struct block
) + (i
- 1) * sizeof (struct symbol
*));
274 /* Copy the symbols into the block. */
276 BLOCK_NSYMS (block
) = i
;
277 for (next
= *listhead
; next
; next
= next
->next
)
278 BLOCK_SYM (block
, --i
) = next
->symbol
;
280 BLOCK_START (block
) = start
;
281 BLOCK_END (block
) = end
;
282 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
284 /* Put the block in as the value of the symbol that names it. */
288 SYMBOL_BLOCK_VALUE (symbol
) = block
;
289 BLOCK_FUNCTION (block
) = symbol
;
292 BLOCK_FUNCTION (block
) = 0;
294 /* Now free the links of the list, and empty the list. */
296 for (next
= *listhead
; next
; next
= next1
)
303 /* Install this block as the superblock
304 of all blocks made since the start of this scope
305 that don't have superblocks yet. */
308 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
310 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0)
311 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
315 /* Record this block on the list of all blocks in the file.
316 Put it after opblock, or at the beginning if opblock is 0.
317 This puts the block in the list after all its subblocks. */
319 pblock
= (struct pending_block
*) xmalloc (sizeof (struct pending_block
));
320 pblock
->block
= block
;
323 pblock
->next
= opblock
->next
;
324 opblock
->next
= pblock
;
328 pblock
->next
= pending_blocks
;
329 pending_blocks
= pblock
;
333 static struct blockvector
*
336 register struct pending_block
*next
, *next1
;
337 register struct blockvector
*blockvector
;
340 /* Count the length of the list of blocks. */
342 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
344 blockvector
= (struct blockvector
*)
345 obstack_alloc (symbol_obstack
, sizeof (struct blockvector
) + (i
- 1) * sizeof (struct block
*));
347 /* Copy the blocks into the blockvector.
348 This is done in reverse order, which happens to put
349 the blocks into the proper order (ascending starting address).
350 finish_block has hair to insert each block into the list
351 after its subblocks in order to make sure this is true. */
353 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
354 for (next
= pending_blocks
; next
; next
= next
->next
)
355 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
357 /* Now free the links of the list, and empty the list. */
359 for (next
= pending_blocks
; next
; next
= next1
)
369 /* Manage the vector of line numbers. */
372 record_line (line
, pc
)
376 struct linetable_entry
*e
;
377 /* Make sure line vector is big enough. */
379 if (line_vector_index
+ 2 >= line_vector_length
)
381 line_vector_length
*= 2;
382 line_vector
= (struct linetable
*)
383 xrealloc (line_vector
, sizeof (struct linetable
)
384 + (line_vector_length
385 * sizeof (struct linetable_entry
)));
388 e
= line_vector
->item
+ line_vector_index
++;
389 e
->line
= line
; e
->pc
= pc
;
392 /* Start a new symtab for a new source file.
393 This is called when a COFF ".file" symbol is seen;
394 it indicates the start of data for one original source file. */
403 last_source_file
= 0;
405 /* Initialize the source file information for this file. */
407 line_vector_index
= 0;
408 line_vector_length
= 1000;
409 prev_line_number
= -2; /* Force first line number to be explicit */
410 line_vector
= (struct linetable
*)
411 xmalloc (sizeof (struct linetable
)
412 + line_vector_length
* sizeof (struct linetable_entry
));
415 /* Save the vital information for use when closing off the current file.
416 NAME is the file name the symbols came from, START_ADDR is the first
417 text address for the file, and SIZE is the number of bytes of text. */
420 complete_symtab (name
, start_addr
, size
)
422 CORE_ADDR start_addr
;
425 last_source_file
= savestring (name
, strlen (name
));
426 cur_src_start_addr
= start_addr
;
427 cur_src_end_addr
= start_addr
+ size
;
429 if (aout_hdr
.entry
< cur_src_end_addr
430 && aout_hdr
.entry
>= cur_src_start_addr
)
432 startup_file_start
= cur_src_start_addr
;
433 startup_file_end
= cur_src_end_addr
;
437 /* Finish the symbol definitions for one main source file,
438 close off all the lexical contexts for that file
439 (creating struct block's for them), then make the
440 struct symtab for that file and put it in the list of all such. */
445 register struct symtab
*symtab
;
446 register struct context_stack
*cstk
;
447 register struct blockvector
*blockvector
;
448 register struct linetable
*lv
;
450 /* Finish the lexical context of the last function in the file. */
454 cstk
= context_stack
;
456 /* Make a block for the local symbols within. */
457 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
458 cstk
->start_addr
, cur_src_end_addr
);
462 /* Ignore a file that has no functions with real debugging info. */
463 if (pending_blocks
== 0 && file_symbols
== 0 && global_symbols
== 0)
467 line_vector_length
= -1;
468 last_source_file
= 0;
472 /* Create the two top-level blocks for this file. */
473 finish_block (0, &file_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
);
474 finish_block (0, &global_symbols
, 0, cur_src_start_addr
, cur_src_end_addr
);
476 /* Create the blockvector that points to all the file's blocks. */
477 blockvector
= make_blockvector ();
479 /* Now create the symtab object for this source file. */
480 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
481 symtab
->free_ptr
= 0;
483 /* Fill in its components. */
484 symtab
->blockvector
= blockvector
;
485 symtab
->free_code
= free_linetable
;
486 symtab
->filename
= last_source_file
;
488 lv
->nitems
= line_vector_index
;
489 symtab
->linetable
= (struct linetable
*)
490 xrealloc (lv
, (sizeof (struct linetable
)
491 + lv
->nitems
* sizeof (struct linetable_entry
)));
493 symtab
->line_charpos
= 0;
495 /* Link the new symtab into the list of such. */
496 symtab
->next
= symtab_list
;
497 symtab_list
= symtab
;
499 /* Reinitialize for beginning of new file. */
501 line_vector_length
= -1;
502 last_source_file
= 0;
505 /* Accumulate the misc functions in bunches of 127.
506 At the end, copy them all into one newly allocated structure. */
508 #define MISC_BUNCH_SIZE 127
512 struct misc_bunch
*next
;
513 struct misc_function contents
[MISC_BUNCH_SIZE
];
516 /* Bunch currently being filled up.
517 The next field points to chain of filled bunches. */
519 static struct misc_bunch
*misc_bunch
;
521 /* Number of slots filled in current bunch. */
523 static int misc_bunch_index
;
525 /* Total number of misc functions recorded so far. */
527 static int misc_count
;
530 init_misc_functions ()
534 misc_bunch_index
= MISC_BUNCH_SIZE
;
538 record_misc_function (name
, address
)
542 register struct misc_bunch
*new;
544 if (misc_bunch_index
== MISC_BUNCH_SIZE
)
546 new = (struct misc_bunch
*) xmalloc (sizeof (struct misc_bunch
));
547 misc_bunch_index
= 0;
548 new->next
= misc_bunch
;
551 misc_bunch
->contents
[misc_bunch_index
].name
= savestring (name
, strlen (name
));
552 misc_bunch
->contents
[misc_bunch_index
].address
= address
;
553 misc_bunch
->contents
[misc_bunch_index
].type
= mf_unknown
;
558 /* if we see a function symbol, we do record_misc_function.
559 * however, if it turns out the next symbol is '.bf', then
560 * we call here to undo the misc definition
563 unrecord_misc_function ()
565 if (misc_bunch_index
== 0)
566 error ("Internal error processing symbol table, at symbol %d.",
574 compare_misc_functions (fn1
, fn2
)
575 struct misc_function
*fn1
, *fn2
;
577 /* Return a signed result based on unsigned comparisons
578 so that we sort into unsigned numeric order. */
579 if (fn1
->address
< fn2
->address
)
581 if (fn1
->address
> fn2
->address
)
587 discard_misc_bunches ()
589 register struct misc_bunch
*next
;
593 next
= misc_bunch
->next
;
600 condense_misc_bunches ()
603 register struct misc_bunch
*bunch
;
604 #ifdef NAMES_HAVE_UNDERSCORE
611 = (struct misc_function
*)
612 xmalloc (misc_count
* sizeof (struct misc_function
));
618 for (i
= 0; i
< misc_bunch_index
; i
++)
622 misc_function_vector
[j
] = bunch
->contents
[i
];
623 tmp
= misc_function_vector
[j
].name
;
624 misc_function_vector
[j
].name
= (tmp
[0] == '_' ? tmp
+ offset
: tmp
);
628 misc_bunch_index
= MISC_BUNCH_SIZE
;
631 misc_function_count
= j
;
633 /* Sort the misc functions by address. */
635 qsort (misc_function_vector
, j
, sizeof (struct misc_function
),
636 compare_misc_functions
);
639 /* Call sort_syms to sort alphabetically
640 the symbols of each block of each symtab. */
643 compare_symbols (s1
, s2
)
644 struct symbol
**s1
, **s2
;
646 /* Names that are less should come first. */
647 register int namediff
= strcmp (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
648 if (namediff
!= 0) return namediff
;
649 /* For symbols of the same name, registers should come first. */
650 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
651 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
657 register struct symtab
*s
;
659 register struct blockvector
*bv
;
660 register struct block
*b
;
662 for (s
= symtab_list
; s
; s
= s
->next
)
664 bv
= BLOCKVECTOR (s
);
665 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
666 for (i
= 0; i
< nbl
; i
++)
668 b
= BLOCKVECTOR_BLOCK (bv
, i
);
669 if (BLOCK_SHOULD_SORT (b
))
670 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
671 sizeof (struct symbol
*), compare_symbols
);
676 /* This is the symbol-file command. Read the file, analyze its symbols,
677 and add a struct symtab to symtab_list. */
680 symbol_file_command (name
)
687 extern void close ();
689 struct cleanup
*old_chain
;
695 if (symtab_list
&& !query ("Discard symbol table? ", 0))
696 error ("Not confirmed.");
704 name
= tilde_expand (name
);
705 make_cleanup (free
, name
);
707 if (symtab_list
&& !query ("Load new symbol table from \"%s\"? ", name
))
708 error ("Not confirmed.");
717 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
719 perror_with_name (name
);
721 name
= absolute_name
;
724 old_chain
= make_cleanup (close
, desc
);
725 make_cleanup (free_current_contents
, &name
);
727 if ((num_symbols
= read_file_hdr (desc
, &file_hdr
)) < 0)
728 error ("File \"%s\" not in executable format.", name
);
730 /* If an a.out header is present, read it in. If not (e.g. a .o file)
731 deal with its absence. */
732 if (file_hdr
.f_opthdr
== 0
733 || read_aout_hdr (desc
, &aout_hdr
, file_hdr
.f_opthdr
) < 0)
735 /* We will not actually be able to run code, since backtraces would
736 fly off the bottom of the stack (there is no way to reliably
737 detect bottom of stack), but that's fine since the kernel won't
738 run something without an a.out header anyway. Passive examination
739 of .o files is one place this might make sense. */
740 /* ~0 will not be in any file. */
742 /* set the startup file to be an empty range. */
743 startup_file_start
= 0;
744 startup_file_end
= 0;
747 if (num_symbols
== 0)
750 error ("%s does not have a symbol-table.\n", name
);
753 printf ("Reading symbol data from %s...", name
);
756 /* Throw away the old symbol table. */
759 free_all_psymtabs (); /* Make sure that partial_symtab_list */
762 num_sections
= file_hdr
.f_nscns
;
763 symtab_offset
= file_hdr
.f_symptr
;
765 if (read_section_hdr (desc
, _TEXT
, &text_hdr
, num_sections
) < 0)
766 error ("\"%s\": can't read text section header", name
);
768 /* Read the line number table, all at once. */
770 val
= init_lineno (desc
, text_hdr
.s_lnnoptr
, text_hdr
.s_nlnno
);
772 error ("\"%s\": error reading line numbers\n", name
);
774 /* Now read the string table, all at once. */
776 val
= init_stringtab (desc
, symtab_offset
+ num_symbols
* SYMESZ
);
780 printf ("\"%s\": can't get string table", name
);
784 make_cleanup (free_stringtab
, 0);
786 /* Position to read the symbol table. Do not read it all at once. */
787 val
= lseek (desc
, (long)symtab_offset
, 0);
789 perror_with_name (name
);
791 init_misc_functions ();
792 make_cleanup (discard_misc_bunches
, 0);
794 /* Now that the executable file is positioned at symbol table,
795 process it and define symbols accordingly. */
797 read_coff_symtab (desc
, num_symbols
);
799 patch_opaque_types ();
801 /* Sort symbols alphabetically within each block. */
805 /* Go over the misc functions and install them in vector. */
807 condense_misc_bunches ();
809 /* Don't allow char * to have a typename (else would get caddr_t.) */
811 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
813 /* Make a default for file to list. */
815 select_source_symtab (0);
817 symfile
= savestring (name
, strlen (name
));
819 do_cleanups (old_chain
);
825 /* Return name of file symbols were loaded from, or 0 if none.. */
833 /* Simplified internal version of coff symbol table information */
837 int c_symnum
; /* symbol number of this entry */
838 int c_nsyms
; /* 1 if syment only, 2 if syment + auxent */
845 /* Given pointers to a symbol table in coff style exec file,
846 analyze them and create struct symtab's describing the symbols.
847 NSYMS is the number of symbols in the symbol table.
848 We read them one at a time using read_one_sym (). */
851 read_coff_symtab (desc
, nsyms
)
855 int newfd
; /* Avoid multiple closes on same desc */
857 register struct context_stack
*new;
858 struct coff_symbol coff_symbol
;
859 register struct coff_symbol
*cs
= &coff_symbol
;
860 static SYMENT main_sym
;
861 static AUXENT main_aux
;
862 struct coff_symbol fcn_cs_saved
;
863 static SYMENT fcn_sym_saved
;
864 static AUXENT fcn_aux_saved
;
866 int num_object_files
= 0;
867 int next_file_symnum
= -1;
874 struct cleanup
*old_chain
;
879 fatal ("Too many open files");
880 stream
= fdopen (newfd
, "r");
882 old_chain
= make_cleanup (free_all_symtabs
, 0);
883 make_cleanup (fclose
, stream
);
884 nlist_stream_global
= stream
;
885 nlist_nsyms_global
= nsyms
;
886 last_source_file
= 0;
887 bzero (opaque_type_chain
, sizeof opaque_type_chain
);
889 type_vector_length
= 160;
890 type_vector
= (struct typevector
*)
891 xmalloc (sizeof (struct typevector
)
892 + type_vector_length
* sizeof (struct type
*));
893 bzero (type_vector
->type
, type_vector_length
* sizeof (struct type
*));
898 while (symnum
< nsyms
)
900 QUIT
; /* Make this command interruptable. */
901 read_one_sym (cs
, &main_sym
, &main_aux
);
903 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
905 CORE_ADDR last_file_end
= cur_src_end_addr
;
907 if (last_source_file
)
911 complete_symtab ("_globals_", 0, first_object_file_end
);
912 /* done with all files, everything from here on out is globals */
915 /* Special case for file with type declarations only, no text. */
916 if (!last_source_file
&& cs
->c_type
!= T_NULL
&& cs
->c_secnum
== N_DEBUG
)
917 complete_symtab (filestring
, 0, 0);
919 /* Typedefs should not be treated as symbol definitions. */
920 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
922 /* record as misc function. if we get '.bf' next,
923 * then we undo this step
925 record_misc_function (cs
->c_name
, cs
->c_value
);
927 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
928 fcn_start_addr
= cs
->c_value
;
930 fcn_sym_saved
= main_sym
;
931 fcn_aux_saved
= main_aux
;
935 switch (cs
->c_sclass
)
944 printf ("Bad n_sclass = %d\n", cs
->c_sclass
);
949 * c_value field contains symnum of next .file entry in table
950 * or symnum of first global after last .file.
952 next_file_symnum
= cs
->c_value
;
953 filestring
= getfilename (&main_aux
);
955 * Complete symbol table for last object file
956 * containing debugging information.
958 if (last_source_file
)
967 if (cs
->c_name
[0] == '.') {
968 if (strcmp (cs
->c_name
, _TEXT
) == 0) {
969 if (num_object_files
== 1) {
970 /* last address of startup file */
971 first_object_file_end
= cs
->c_value
+
972 main_aux
.x_scn
.x_scnlen
;
974 /* for some reason the old code didn't do
975 * this if this section entry had
976 * main_aux.x_scn.x_nlinno equal to 0
978 complete_symtab (filestring
, cs
->c_value
,
979 main_aux
.x_scn
.x_scnlen
);
981 /* flush rest of '.' symbols */
984 /* fall in for static symbols that don't start with '.' */
986 if (cs
->c_sclass
== C_EXT
&&
987 cs
->c_secnum
== N_ABS
&&
988 strcmp (cs
->c_name
, _ETEXT
) == 0)
989 end_of_text_addr
= cs
->c_value
;
990 if (cs
->c_type
== T_NULL
) {
991 if (cs
->c_secnum
<= 1) { /* text or abs */
992 record_misc_function (cs
->c_name
, cs
->c_value
);
998 (void) process_coff_symbol (cs
, &main_aux
);
1002 if (strcmp (cs
->c_name
, ".bf") == 0)
1005 /* Don't do this; we want all functions to be on the
1007 unrecord_misc_function ();
1010 within_function
= 1;
1012 /* value contains address of first non-init type code */
1013 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1014 contains line number of '{' } */
1015 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1017 new = (struct context_stack
*)
1018 xmalloc (sizeof (struct context_stack
));
1019 new->depth
= depth
= 0;
1021 context_stack
= new;
1023 new->old_blocks
= pending_blocks
;
1024 new->start_addr
= fcn_start_addr
;
1025 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1026 new->name
= process_coff_symbol (&fcn_cs_saved
,
1029 else if (strcmp (cs
->c_name
, ".ef") == 0)
1031 /* the value of .ef is the address of epilogue code;
1032 * not useful for gdb
1034 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1035 contains number of lines to '}' */
1036 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1037 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
1038 new = context_stack
;
1041 error ("Invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1044 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1046 fcn_cs_saved
.c_value
+
1047 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
);
1049 within_function
= 0;
1055 if (strcmp (cs
->c_name
, ".bb") == 0)
1057 new = (struct context_stack
*)
1058 xmalloc (sizeof (struct context_stack
));
1061 new->next
= context_stack
;
1062 context_stack
= new;
1063 new->locals
= local_symbols
;
1064 new->old_blocks
= pending_blocks
;
1065 new->start_addr
= cs
->c_value
;
1069 else if (strcmp (cs
->c_name
, ".eb") == 0)
1071 new = context_stack
;
1072 if (new == 0 || depth
!= new->depth
)
1073 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1075 if (local_symbols
&& context_stack
->next
)
1077 /* Make a block for the local symbols within. */
1078 finish_block (0, &local_symbols
, new->old_blocks
,
1079 new->start_addr
, cs
->c_value
);
1082 local_symbols
= new->locals
;
1083 context_stack
= new->next
;
1089 (void) process_coff_symbol (cs
, &main_aux
);
1094 if (last_source_file
)
1097 discard_cleanups (old_chain
);
1100 /* Routines for reading headers and symbols from executable. */
1102 /* Read COFF file header, check magic number,
1103 and return number of symbols. */
1104 read_file_hdr (chan
, file_hdr
)
1108 lseek (chan
, 0L, 0);
1109 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1112 switch (file_hdr
->f_magic
)
1127 return file_hdr
->f_nsyms
;
1131 if (BADMAG(file_hdr
))
1134 return file_hdr
->f_nsyms
;
1141 read_aout_hdr (chan
, aout_hdr
, size
)
1146 lseek (chan
, (long)FILHSZ
, 0);
1147 if (size
!= sizeof (AOUTHDR
))
1149 if (myread (chan
, (char *)aout_hdr
, size
) != size
)
1154 read_section_hdr (chan
, section_name
, section_hdr
, nsects
)
1156 register char *section_name
;
1157 SCNHDR
*section_hdr
;
1158 register int nsects
;
1162 if (lseek (chan
, FILHSZ
+ sizeof (AOUTHDR
), 0) < 0)
1165 for (i
= 0; i
< nsects
; i
++)
1167 if (myread (chan
, (char *)section_hdr
, SCNHSZ
) < 0)
1169 if (strncmp (section_hdr
->s_name
, section_name
, 8) == 0)
1175 read_one_sym (cs
, sym
, aux
)
1176 register struct coff_symbol
*cs
;
1177 register SYMENT
*sym
;
1178 register AUXENT
*aux
;
1180 cs
->c_symnum
= symnum
;
1181 fread ((char *)sym
, SYMESZ
, 1, nlist_stream_global
);
1182 cs
->c_nsyms
= (sym
->n_numaux
& 0xff) + 1;
1183 if (cs
->c_nsyms
== 2)
1185 /* doc for coff says there is either no aux entry or just one */
1186 fread ((char *)aux
, AUXESZ
, 1, nlist_stream_global
);
1188 else if (cs
->c_nsyms
> 2)
1189 error ("more than one aux symbol table entry at symnum=%d\n", symnum
);
1191 cs
->c_name
= getsymname (sym
);
1192 cs
->c_value
= sym
->n_value
;
1193 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1194 cs
->c_secnum
= sym
->n_scnum
;
1195 cs
->c_type
= (unsigned) sym
->n_type
;
1197 symnum
+= cs
->c_nsyms
;
1200 /* Support for string table handling */
1202 static char *stringtab
= NULL
;
1205 init_stringtab (chan
, offset
)
1218 if (lseek (chan
, offset
, 0) < 0)
1221 val
= myread (chan
, (char *)&buffer
, sizeof buffer
);
1223 /* If no string table is needed, then the file may end immediately
1224 after the symbols. Just return with `stringtab' set to null. */
1225 if (val
!= sizeof buffer
|| buffer
== 0)
1228 stringtab
= (char *) xmalloc (buffer
);
1229 if (stringtab
== NULL
)
1232 bcopy (&buffer
, stringtab
, sizeof buffer
);
1234 val
= myread (chan
, stringtab
+ sizeof buffer
, buffer
- sizeof buffer
);
1235 if (val
!= buffer
- sizeof buffer
|| stringtab
[buffer
- 1] != '\0')
1250 getsymname (symbol_entry
)
1251 SYMENT
*symbol_entry
;
1253 static char buffer
[SYMNMLEN
+1];
1256 if (symbol_entry
->n_zeroes
== 0)
1258 result
= stringtab
+ symbol_entry
->n_offset
;
1262 strncpy (buffer
, symbol_entry
->n_name
, SYMNMLEN
);
1263 buffer
[SYMNMLEN
] = '\0';
1270 getfilename (aux_entry
)
1273 static char buffer
[BUFSIZ
];
1274 register char *temp
;
1276 extern char *rindex ();
1278 #ifndef COFF_NO_LONG_FILE_NAMES
1279 if (aux_entry
->x_file
.x_foff
!= 0)
1280 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_foff
);
1284 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1285 buffer
[FILNMLEN
] = '\0';
1288 if ((temp
= rindex (result
, '/')) != NULL
)
1293 /* Support for line number handling */
1294 static char *linetab
= NULL
;
1295 static long linetab_offset
;
1296 static int linetab_count
;
1299 init_lineno (chan
, offset
, count
)
1306 if (lseek (chan
, offset
, 0) < 0)
1311 linetab
= (char *) xmalloc (count
* LINESZ
);
1313 val
= myread (chan
, linetab
, count
* LINESZ
);
1314 if (val
!= count
* LINESZ
)
1317 linetab_offset
= offset
;
1318 linetab_count
= count
;
1323 enter_linenos (file_offset
, first_line
, last_line
)
1325 register int first_line
;
1326 register int last_line
;
1328 register char *rawptr
= &linetab
[file_offset
- linetab_offset
];
1331 /* skip first line entry for each function */
1333 /* line numbers start at one for the first line of the function */
1336 /* Bcopy since occaisionally rawptr isn't pointing at long
1338 for (bcopy (rawptr
, &lptr
, LINESZ
);
1339 lptr
.l_lnno
&& lptr
.l_lnno
<= last_line
;
1340 rawptr
+= LINESZ
, bcopy (rawptr
, &lptr
, LINESZ
))
1342 record_line (first_line
+ lptr
.l_lnno
, lptr
.l_addr
.l_paddr
);
1350 register char *p
= name
;
1351 register int total
= p
[0];
1364 return total
% HASHSIZE
;
1368 patch_type (type
, real_type
)
1370 struct type
*real_type
;
1372 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1373 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1374 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1376 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1377 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1378 TYPE_FIELDS (target
) = (struct field
*)
1379 obstack_alloc (symbol_obstack
, field_size
);
1381 bcopy (TYPE_FIELDS (real_target
), TYPE_FIELDS (target
), field_size
);
1383 if (TYPE_NAME (real_target
))
1385 if (TYPE_NAME (target
))
1386 free (TYPE_NAME (target
));
1387 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), "", "");
1391 /* Patch up all appropriate typdef symbols in the opaque_type_chains
1392 so that they can be used to print out opaque data structures properly */
1395 patch_opaque_types ()
1399 /* Look at each symbol in the per-file block of each symtab. */
1400 for (s
= symtab_list
; s
; s
= s
->next
)
1402 register struct block
*b
;
1405 /* Go through the per-file symbols only */
1406 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), 1);
1407 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1409 register struct symbol
*real_sym
;
1411 /* Find completed typedefs to use to fix opaque ones.
1412 Remove syms from the chain when their types are stored,
1413 but search the whole chain, as there may be several syms
1414 from different files with the same name. */
1415 real_sym
= BLOCK_SYM (b
, i
);
1416 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1417 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1418 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1419 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1421 register char *name
= SYMBOL_NAME (real_sym
);
1422 register int hash
= hashname (name
);
1423 register struct symbol
*sym
, *prev
;
1426 for (sym
= opaque_type_chain
[hash
]; sym
;)
1428 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1429 !strcmp (name
+ 1, SYMBOL_NAME (sym
) + 1))
1432 SYMBOL_VALUE (prev
) = SYMBOL_VALUE (sym
);
1434 opaque_type_chain
[hash
]
1435 = (struct symbol
*) SYMBOL_VALUE (sym
);
1437 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1440 sym
= (struct symbol
*) SYMBOL_VALUE (prev
);
1442 sym
= opaque_type_chain
[hash
];
1447 sym
= (struct symbol
*) SYMBOL_VALUE (sym
);
1455 static struct symbol
*
1456 process_coff_symbol (cs
, aux
)
1457 register struct coff_symbol
*cs
;
1458 register AUXENT
*aux
;
1460 register struct symbol
*sym
1461 = (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
1464 #ifdef NAMES_HAVE_UNDERSCORE
1470 bzero (sym
, sizeof (struct symbol
));
1472 name
= (name
[0] == '_' ? name
+ offset
: name
);
1473 SYMBOL_NAME (sym
) = obstack_copy0 (symbol_obstack
, name
, strlen (name
));
1475 /* default assumptions */
1476 SYMBOL_VALUE (sym
) = cs
->c_value
;
1477 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1479 if (ISFCN (cs
->c_type
))
1482 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1483 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1484 if (cs
->c_sclass
== C_STAT
)
1485 add_symbol_to_list (sym
, &file_symbols
);
1486 else if (cs
->c_sclass
== C_EXT
)
1487 add_symbol_to_list (sym
, &global_symbols
);
1491 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1492 switch (cs
->c_sclass
)
1498 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1499 add_symbol_to_list (sym
, &local_symbols
);
1503 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1504 add_symbol_to_list (sym
, &global_symbols
);
1508 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1509 if (within_function
) {
1510 /* Static symbol of local scope */
1511 add_symbol_to_list (sym
, &local_symbols
);
1514 /* Static symbol at top level of file */
1515 add_symbol_to_list (sym
, &file_symbols
);
1520 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1521 add_symbol_to_list (sym
, &local_symbols
);
1528 SYMBOL_CLASS (sym
) = LOC_ARG
;
1529 add_symbol_to_list (sym
, &local_symbols
);
1531 /* If PCC says a parameter is a short or a char,
1532 it is really an int. */
1533 if (SYMBOL_TYPE (sym
) == builtin_type_char
1534 || SYMBOL_TYPE (sym
) == builtin_type_short
)
1535 SYMBOL_TYPE (sym
) = builtin_type_int
;
1536 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
1537 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
1538 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
1543 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1544 add_symbol_to_list (sym
, &local_symbols
);
1546 /* If PCC says a parameter is a short or a char,
1547 it is really an int. */
1548 if (SYMBOL_TYPE (sym
) == builtin_type_char
1549 || SYMBOL_TYPE (sym
) == builtin_type_short
)
1550 SYMBOL_TYPE (sym
) = builtin_type_int
;
1551 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
1552 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
1553 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
1558 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1559 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1561 /* If type has no name, give it one */
1562 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
1563 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
1564 TYPE_NAME (SYMBOL_TYPE (sym
))
1565 = concat (SYMBOL_NAME (sym
), "", "");
1567 /* Keep track of any type which points to empty structured type,
1568 so it can be filled from a definition from another file */
1569 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1570 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0)
1572 register int i
= hashname (SYMBOL_NAME (sym
));
1574 SYMBOL_VALUE (sym
) = (int) opaque_type_chain
[i
];
1575 opaque_type_chain
[i
] = sym
;
1577 add_symbol_to_list (sym
, &file_symbols
);
1583 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1584 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1585 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
1586 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
1587 TYPE_NAME (SYMBOL_TYPE (sym
))
1589 (cs
->c_sclass
== C_ENTAG
1591 : (cs
->c_sclass
== C_STRTAG
1592 ? "struct " : "union ")),
1594 add_symbol_to_list (sym
, &file_symbols
);
1604 /* Decode a coff type specifier;
1605 return the type that is meant. */
1609 decode_type (cs
, c_type
, aux
)
1610 register struct coff_symbol
*cs
;
1611 unsigned int c_type
;
1612 register AUXENT
*aux
;
1614 register struct type
*type
= 0;
1616 unsigned int new_c_type
;
1618 if (c_type
& ~N_BTMASK
)
1620 new_c_type
= DECREF (c_type
);
1623 type
= decode_type (cs
, new_c_type
, aux
);
1624 type
= lookup_pointer_type (type
);
1626 else if (ISFCN (c_type
))
1628 type
= decode_type (cs
, new_c_type
, aux
);
1629 type
= lookup_function_type (type
);
1631 else if (ISARY (c_type
))
1634 register unsigned short *dim
;
1635 struct type
*base_type
;
1637 /* Define an array type. */
1638 /* auxent refers to array, not base type */
1639 if (aux
->x_sym
.x_tagndx
== 0)
1642 /* shift the indices down */
1643 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1646 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1650 type
= (struct type
*)
1651 obstack_alloc (symbol_obstack
, sizeof (struct type
));
1652 bzero (type
, sizeof (struct type
));
1654 base_type
= decode_type (cs
, new_c_type
, aux
);
1656 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1657 TYPE_TARGET_TYPE (type
) = base_type
;
1658 TYPE_LENGTH (type
) = n
* TYPE_LENGTH (base_type
);
1663 /* Reference to existing type */
1664 if (cs
->c_nsyms
> 1 && aux
->x_sym
.x_tagndx
!= 0)
1666 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
);
1670 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1673 /* Decode a coff type specifier for function definition;
1674 return the type that the function returns. */
1678 decode_function_type (cs
, c_type
, aux
)
1679 register struct coff_symbol
*cs
;
1680 unsigned int c_type
;
1681 register AUXENT
*aux
;
1683 if (aux
->x_sym
.x_tagndx
== 0)
1684 cs
->c_nsyms
= 1; /* auxent refers to function, not base type */
1686 return decode_type (cs
, DECREF (cs
->c_type
), aux
);
1693 decode_base_type (cs
, c_type
, aux
)
1694 register struct coff_symbol
*cs
;
1695 unsigned int c_type
;
1696 register AUXENT
*aux
;
1703 /* shows up with "void (*foo)();" structure members */
1704 return builtin_type_void
;
1707 /* shouldn't show up here */
1711 return builtin_type_char
;
1714 return builtin_type_short
;
1717 return builtin_type_int
;
1720 return builtin_type_long
;
1723 return builtin_type_float
;
1726 return builtin_type_double
;
1729 if (cs
->c_nsyms
!= 2)
1731 /* anonymous structure type */
1732 type
= coff_alloc_type (cs
->c_symnum
);
1733 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1734 TYPE_NAME (type
) = concat ("struct ", "<opaque>", "");
1735 TYPE_LENGTH (type
) = 0;
1736 TYPE_FIELDS (type
) = 0;
1737 TYPE_NFIELDS (type
) = 0;
1741 type
= read_struct_type (cs
->c_symnum
,
1742 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1743 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1748 if (cs
->c_nsyms
!= 2)
1750 /* anonymous union type */
1751 type
= coff_alloc_type (cs
->c_symnum
);
1752 TYPE_NAME (type
) = concat ("union ", "<opaque>", "");
1753 TYPE_LENGTH (type
) = 0;
1754 TYPE_FIELDS (type
) = 0;
1755 TYPE_NFIELDS (type
) = 0;
1759 type
= read_struct_type (cs
->c_symnum
,
1760 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1761 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1763 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1767 return read_enum_type (cs
->c_symnum
,
1768 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1769 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
);
1772 /* shouldn't show up here */
1776 return builtin_type_unsigned_char
;
1779 return builtin_type_unsigned_short
;
1782 return builtin_type_unsigned_int
;
1785 return builtin_type_unsigned_long
;
1787 printf ("unexpected type %d at symnum %d\n", c_type
, cs
->c_symnum
);
1788 return builtin_type_void
;
1791 /* This page contains subroutines of read_type. */
1793 /* Read the description of a structure (or union type)
1794 and return an object describing the type. */
1796 static struct type
*
1797 read_struct_type (index
, length
, lastsym
)
1804 struct nextfield
*next
;
1808 register struct type
*type
;
1809 register struct nextfield
*list
= 0;
1810 struct nextfield
*new;
1814 #ifdef NAMES_HAVE_UNDERSCORE
1819 struct coff_symbol member_sym
;
1820 register struct coff_symbol
*ms
= &member_sym
;
1825 type
= coff_alloc_type (index
);
1826 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1827 TYPE_LENGTH (type
) = length
;
1829 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1831 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1833 name
= (name
[0] == '_' ? name
+ offset
: name
);
1835 switch (ms
->c_sclass
)
1840 /* Get space to record the next field's data. */
1841 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1845 /* Save the data. */
1846 list
->field
.name
= savestring (name
, strlen (name
));
1847 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1848 list
->field
.bitpos
= 8 * ms
->c_value
;
1849 list
->field
.bitsize
= 0;
1855 /* Get space to record the next field's data. */
1856 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1860 /* Save the data. */
1861 list
->field
.name
= savestring (name
, strlen (name
));
1862 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1863 list
->field
.bitpos
= ms
->c_value
;
1864 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1873 /* Now create the vector of fields, and record how big it is. */
1875 TYPE_NFIELDS (type
) = nfields
;
1876 TYPE_FIELDS (type
) = (struct field
*)
1877 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nfields
);
1879 /* Copy the saved-up fields into the field vector. */
1881 for (n
= nfields
; list
; list
= list
->next
)
1882 TYPE_FIELD (type
, --n
) = list
->field
;
1887 /* Read a definition of an enumeration type,
1888 and create and return a suitable type object.
1889 Also defines the symbols that represent the values of the type. */
1891 static struct type
*
1892 read_enum_type (index
, length
, lastsym
)
1897 register struct symbol
*sym
;
1898 register struct type
*type
;
1900 struct pending
**symlist
;
1901 struct coff_symbol member_sym
;
1902 register struct coff_symbol
*ms
= &member_sym
;
1905 struct pending
*osyms
, *syms
;
1908 #ifdef NAMES_HAVE_UNDERSCORE
1914 type
= coff_alloc_type (index
);
1915 if (within_function
)
1916 symlist
= &local_symbols
;
1918 symlist
= &file_symbols
;
1921 while (symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1923 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1925 name
= (name
[0] == '_' ? name
+ offset
: name
);
1927 switch (ms
->c_sclass
)
1930 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1931 bzero (sym
, sizeof (struct symbol
));
1933 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1934 SYMBOL_CLASS (sym
) = LOC_CONST
;
1935 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1936 SYMBOL_VALUE (sym
) = ms
->c_value
;
1937 add_symbol_to_list (sym
, symlist
);
1946 /* Now fill in the fields of the type-structure. */
1948 TYPE_LENGTH (type
) = sizeof (int);
1949 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1950 TYPE_NFIELDS (type
) = nsyms
;
1951 TYPE_FIELDS (type
) = (struct field
*)
1952 obstack_alloc (symbol_obstack
, sizeof (struct field
) * nsyms
);
1954 /* Find the symbols for the values and put them into the type.
1955 The symbols can be found in the symlist that we put them on
1956 to cause them to be defined. osyms contains the old value
1957 of that symlist; everything up to there was defined by us. */
1959 for (syms
= *symlist
, n
= nsyms
; syms
!= osyms
; syms
= syms
->next
)
1961 SYMBOL_TYPE (syms
->symbol
) = type
;
1962 TYPE_FIELD_NAME (type
, --n
) = SYMBOL_NAME (syms
->symbol
);
1963 TYPE_FIELD_VALUE (type
, n
) = 0;
1964 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (syms
->symbol
);
1965 TYPE_FIELD_BITSIZE (type
, n
) = 0;
1970 /* This function is really horrible, but to avoid it, there would need
1971 to be more filling in of forward references. THIS SHOULD BE MOVED
1972 OUT OF COFFREAD.C AND DBXREAD.C TO SOME PLACE WHERE IT CAN BE SHARED. */
1974 fill_in_vptr_fieldno (type
)
1977 if (TYPE_VPTR_FIELDNO (type
) < 0)
1978 TYPE_VPTR_FIELDNO (type
) =
1979 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, 1));
1980 return TYPE_VPTR_FIELDNO (type
);
1983 /* partial symbol tables are not implemented in coff, therefore
1984 block_for_pc() (and others) will never decide to call this. */
1986 extern struct symtab
*
1987 psymtab_to_symtab ()
1989 fatal ("error: Someone called psymtab_to_symtab\n");
1992 /* These will stay zero all the time */
1993 struct psymbol_allocation_list global_psymbols
, static_psymbols
;
1999 bzero (&global_psymbols
, sizeof (global_psymbols
));
2000 bzero (&static_psymbols
, sizeof (static_psymbols
));
2002 add_com ("symbol-file", class_files
, symbol_file_command
,
2003 "Load symbol table (in coff format) from executable file FILE.");
2007 #endif /* COFF_FORMAT */