1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
3 Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 #include "breakpoint.h"
30 #include "gdb-stabs.h"
31 #include "stabsread.h"
32 #include "complaints.h"
37 #include <time.h> /* For time_t in libbfd.h. */
38 #include <sys/types.h> /* For time_t, if not in time.h. */
39 #include "libbfd.h" /* FIXME secret internal data from BFD */
40 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
41 #include "libcoff.h" /* FIXME secret internal data from BFD */
43 struct coff_symfile_info
{
44 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
45 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
47 asection
*stabsect
; /* Section pointer for .stab section */
48 asection
*stabstrsect
; /* Section pointer for .stab section */
49 asection
*stabindexsect
; /* Section pointer for .stab.index section */
53 /* Translate an external name string into a user-visible name. */
54 #define EXTERNAL_NAME(string, abfd) \
55 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
57 /* To be an sdb debug type, type must have at least a basic or primary
58 derived type. Using this rather than checking against T_NULL is
59 said to prevent core dumps if we try to operate on Michael Bloom
62 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
65 * Convert from an sdb register number to an internal gdb register number.
66 * This should be defined in tm.h, if REGISTER_NAMES is not set up
67 * to map one to one onto the sdb register numbers.
69 #ifndef SDB_REG_TO_REGNUM
70 # define SDB_REG_TO_REGNUM(value) (value)
73 /* Core address of start and end of text of current source file.
74 This comes from a ".text" symbol where x_nlinno > 0. */
76 static CORE_ADDR cur_src_start_addr
;
77 static CORE_ADDR cur_src_end_addr
;
79 /* The addresses of the symbol table stream and number of symbols
80 of the object file we are reading (as copied into core). */
82 static GDB_FILE
*nlist_stream_global
;
83 static int nlist_nsyms_global
;
85 /* Vector of line number information. */
87 static struct linetable
*line_vector
;
89 /* Index of next entry to go in line_vector_index. */
91 static int line_vector_index
;
93 /* Last line number recorded in the line vector. */
95 static int prev_line_number
;
97 /* Number of elements allocated for line_vector currently. */
99 static int line_vector_length
;
101 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
103 static char *temp_sym
;
104 static char *temp_aux
;
106 /* Local variables that hold the shift and mask values for the
107 COFF file that we are currently reading. These come back to us
108 from BFD, and are referenced by their macro names, as well as
109 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
110 macros from ../internalcoff.h . */
112 static unsigned local_n_btmask
;
113 static unsigned local_n_btshft
;
114 static unsigned local_n_tmask
;
115 static unsigned local_n_tshift
;
117 #define N_BTMASK local_n_btmask
118 #define N_BTSHFT local_n_btshft
119 #define N_TMASK local_n_tmask
120 #define N_TSHIFT local_n_tshift
122 /* Local variables that hold the sizes in the file of various COFF structures.
123 (We only need to know this to read them from the file -- BFD will then
124 translate the data in them, into `internal_xxx' structs in the right
125 byte order, alignment, etc.) */
127 static unsigned local_linesz
;
128 static unsigned local_symesz
;
129 static unsigned local_auxesz
;
132 /* Chain of typedefs of pointers to empty struct/union types.
133 They are chained thru the SYMBOL_VALUE_CHAIN. */
135 static struct symbol
*opaque_type_chain
[HASHSIZE
];
138 /* The type of the function we are currently reading in. This is
139 used by define_symbol to record the type of arguments to a function. */
141 struct type
*in_function_type
;
144 struct pending_block
*pending_blocks
;
146 /* Complaints about various problems in the file being read */
148 struct complaint ef_complaint
=
149 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
151 struct complaint bf_no_aux_complaint
=
152 {"`.bf' symbol %d has no aux entry", 0, 0};
154 struct complaint ef_no_aux_complaint
=
155 {"`.ef' symbol %d has no aux entry", 0, 0};
157 struct complaint lineno_complaint
=
158 {"Line number pointer %d lower than start of line numbers", 0, 0};
160 struct complaint unexpected_type_complaint
=
161 {"Unexpected type for symbol %s", 0, 0};
163 struct complaint bad_sclass_complaint
=
164 {"Bad n_sclass for symbol %s", 0, 0};
166 struct complaint misordered_blocks_complaint
=
167 {"Blocks out of order at address %x", 0, 0};
169 struct complaint tagndx_bad_complaint
=
170 {"Symbol table entry for %s has bad tagndx value", 0, 0};
172 struct complaint eb_complaint
=
173 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
175 /* Simplified internal version of coff symbol table information */
179 int c_symnum
; /* symbol number of this entry */
180 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
188 coff_read_struct_type
PARAMS ((int, int, int));
191 decode_base_type
PARAMS ((struct coff_symbol
*, unsigned int,
192 union internal_auxent
*));
195 decode_type
PARAMS ((struct coff_symbol
*, unsigned int,
196 union internal_auxent
*));
199 decode_function_type
PARAMS ((struct coff_symbol
*, unsigned int,
200 union internal_auxent
*));
203 coff_read_enum_type
PARAMS ((int, int, int));
205 static struct symbol
*
206 process_coff_symbol
PARAMS ((struct coff_symbol
*, union internal_auxent
*,
210 patch_opaque_types
PARAMS ((struct symtab
*));
213 patch_type
PARAMS ((struct type
*, struct type
*));
216 enter_linenos
PARAMS ((long, int, int));
219 free_linetab
PARAMS ((void));
222 init_lineno
PARAMS ((int, long, int));
225 getsymname
PARAMS ((struct internal_syment
*));
228 free_stringtab
PARAMS ((void));
231 init_stringtab
PARAMS ((int, long));
234 read_one_sym
PARAMS ((struct coff_symbol
*, struct internal_syment
*,
235 union internal_auxent
*));
238 read_coff_symtab
PARAMS ((long, int, struct objfile
*));
241 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
244 coff_symfile_init
PARAMS ((struct objfile
*));
247 coff_new_init
PARAMS ((struct objfile
*));
250 coff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
253 coff_symfile_finish
PARAMS ((struct objfile
*));
255 static void record_minimal_symbol
256 PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
, struct objfile
*));
259 coff_end_symtab
PARAMS ((struct objfile
*));
262 complete_symtab
PARAMS ((char *, CORE_ADDR
, unsigned int));
265 coff_start_symtab
PARAMS ((void));
268 coff_record_line
PARAMS ((int, CORE_ADDR
));
271 coff_alloc_type
PARAMS ((int));
273 static struct type
**
274 coff_lookup_type
PARAMS ((int));
278 coff_locate_sections
PARAMS ((bfd
*, asection
*, PTR
));
280 /* We are called once per section from coff_symfile_read. We
281 need to examine each section we are passed, check to see
282 if it is something we are interested in processing, and
283 if so, stash away some access information for the section.
285 FIXME: The section names should not be hardwired strings (what
286 should they be? I don't think most object file formats have enough
287 section flags to specify what kind of debug section it is
291 coff_locate_sections (ignore_abfd
, sectp
, csip
)
296 register struct coff_symfile_info
*csi
;
298 csi
= (struct coff_symfile_info
*) csip
;
299 if (STREQ (sectp
->name
, ".stab"))
301 csi
->stabsect
= sectp
;
303 else if (STREQ (sectp
->name
, ".stabstr"))
305 csi
->stabstrsect
= sectp
;
307 else if (STREQ (sectp
->name
, ".stab.index"))
309 csi
->stabindexsect
= sectp
;
313 /* Look up a coff type-number index. Return the address of the slot
314 where the type for that index is stored.
315 The type-number is in INDEX.
317 This can be used for finding the type associated with that index
318 or for associating a new type with the index. */
320 static struct type
**
321 coff_lookup_type (index
)
324 if (index
>= type_vector_length
)
326 int old_vector_length
= type_vector_length
;
328 type_vector_length
*= 2;
329 if (index
/* is still */ >= type_vector_length
) {
330 type_vector_length
= index
* 2;
332 type_vector
= (struct type
**)
333 xrealloc ((char *) type_vector
,
334 type_vector_length
* sizeof (struct type
*));
335 memset (&type_vector
[old_vector_length
], 0,
336 (type_vector_length
- old_vector_length
) * sizeof(struct type
*));
338 return &type_vector
[index
];
341 /* Make sure there is a type allocated for type number index
342 and return the type object.
343 This can create an empty (zeroed) type object. */
346 coff_alloc_type (index
)
349 register struct type
**type_addr
= coff_lookup_type (index
);
350 register struct type
*type
= *type_addr
;
352 /* If we are referring to a type not known at all yet,
353 allocate an empty type for it.
354 We will fill it in later if we find out how. */
357 type
= alloc_type (current_objfile
);
363 /* Record a line number entry for line LINE at address PC.
364 FIXME: Use record_line instead. */
367 coff_record_line (line
, pc
)
371 struct linetable_entry
*e
;
372 /* Make sure line vector is big enough. */
374 if (line_vector_index
+ 2 >= line_vector_length
)
376 line_vector_length
*= 2;
377 line_vector
= (struct linetable
*)
378 xrealloc ((char *) line_vector
, sizeof (struct linetable
)
379 + (line_vector_length
380 * sizeof (struct linetable_entry
)));
383 e
= line_vector
->item
+ line_vector_index
++;
384 e
->line
= line
; e
->pc
= pc
;
387 /* Start a new symtab for a new source file.
388 This is called when a COFF ".file" symbol is seen;
389 it indicates the start of data for one original source file. */
395 /* We fill in the filename later. start_symtab
396 puts this pointer into last_source file and in
397 coff_end_symtab we assume we can free() it.
398 FIXME: leaks memory. */
400 /* We never know the directory name for COFF. */
402 /* The start address is irrelevant, since we set
403 last_source_start_addr in coff_end_symtab. */
406 /* Initialize the source file line number information for this file. */
408 if (line_vector
) /* Unlikely, but maybe possible? */
409 free ((PTR
)line_vector
);
410 line_vector_index
= 0;
411 line_vector_length
= 1000;
412 prev_line_number
= -2; /* Force first line number to be explicit */
413 line_vector
= (struct linetable
*)
414 xmalloc (sizeof (struct linetable
)
415 + line_vector_length
* sizeof (struct linetable_entry
));
418 /* Save the vital information from when starting to read a file,
419 for use when closing off the current file.
420 NAME is the file name the symbols came from, START_ADDR is the first
421 text address for the file, and SIZE is the number of bytes of text. */
424 complete_symtab (name
, start_addr
, size
)
426 CORE_ADDR start_addr
;
429 last_source_file
= savestring (name
, strlen (name
));
430 cur_src_start_addr
= start_addr
;
431 cur_src_end_addr
= start_addr
+ size
;
433 if (current_objfile
-> ei
.entry_point
>= cur_src_start_addr
&&
434 current_objfile
-> ei
.entry_point
< cur_src_end_addr
)
436 current_objfile
-> ei
.entry_file_lowpc
= cur_src_start_addr
;
437 current_objfile
-> ei
.entry_file_highpc
= cur_src_end_addr
;
441 /* Finish the symbol definitions for one main source file,
442 close off all the lexical contexts for that file
443 (creating struct block's for them), then make the
444 struct symtab for that file and put it in the list of all such. */
447 coff_end_symtab (objfile
)
448 struct objfile
*objfile
;
450 struct symtab
*symtab
;
452 last_source_start_addr
= cur_src_start_addr
;
454 /* For no good reason, this file stores the number of entries in a
455 separate variable instead of in line_vector->nitems. Fix it. */
457 line_vector
->nitems
= line_vector_index
;
459 /* For COFF, we only have one subfile, so we can just look at
460 subfiles and not worry about there being other elements in the
461 chain. We fill in various fields now because we didn't know them
462 before (or because doing it now is simply an artifact of how this
463 file used to be written). */
464 subfiles
->line_vector
= line_vector
;
465 subfiles
->name
= last_source_file
;
467 /* sort_pending is needed for amdcoff, at least.
468 sort_linevec is needed for the SCO compiler. */
469 symtab
= end_symtab (cur_src_end_addr
, 1, 1, objfile
, 0);
472 free_named_symtabs (symtab
->filename
);
474 /* Reinitialize for beginning of new file. */
476 line_vector_length
= -1;
477 last_source_file
= NULL
;
481 record_minimal_symbol (name
, address
, type
, objfile
)
484 enum minimal_symbol_type type
;
485 struct objfile
*objfile
;
487 /* We don't want TDESC entry points in the minimal symbol table */
488 if (name
[0] == '@') return;
490 prim_record_minimal_symbol (savestring (name
, strlen (name
)), address
, type
,
494 /* coff_symfile_init ()
495 is the coff-specific initialization routine for reading symbols.
496 It is passed a struct objfile which contains, among other things,
497 the BFD for the file whose symbols are being read, and a slot for
498 a pointer to "private data" which we fill with cookies and other
499 treats for coff_symfile_read ().
501 We will only be called if this is a COFF or COFF-like file.
502 BFD handles figuring out the format of the file, and code in symtab.c
503 uses BFD's determination to vector to us.
505 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
507 static int text_bfd_scnum
;
510 coff_symfile_init (objfile
)
511 struct objfile
*objfile
;
514 bfd
*abfd
= objfile
->obfd
;
516 /* Allocate struct to keep track of stab reading. */
517 objfile
->sym_stab_info
= (PTR
)
518 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
520 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
522 /* Allocate struct to keep track of the symfile */
523 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
524 sizeof (struct coff_symfile_info
));
526 memset (objfile
->sym_private
, 0, sizeof (struct coff_symfile_info
));
528 init_entry_point_info (objfile
);
530 /* Save the section number for the text section */
531 section
= bfd_get_section_by_name (abfd
, ".text");
533 text_bfd_scnum
= section
->index
;
538 /* This function is called for every section; it finds the outer limits
539 of the line table (minimum and maximum file offset) so that the
540 mainline code can read the whole thing for efficiency. */
544 find_linenos (abfd
, asect
, vpinfo
)
549 struct coff_symfile_info
*info
;
551 file_ptr offset
, maxoff
;
553 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
554 count
= asect
->lineno_count
;
559 size
= count
* local_linesz
;
561 info
= (struct coff_symfile_info
*)vpinfo
;
562 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
563 offset
= asect
->line_filepos
;
566 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
567 info
->min_lineno_offset
= offset
;
569 maxoff
= offset
+ size
;
570 if (maxoff
> info
->max_lineno_offset
)
571 info
->max_lineno_offset
= maxoff
;
575 /* The BFD for this file -- only good while we're actively reading
576 symbols into a psymtab or a symtab. */
578 static bfd
*symfile_bfd
;
580 /* Read a symbol file, after initialization by coff_symfile_init. */
581 /* FIXME! Addr and Mainline are not used yet -- this will not work for
582 shared libraries or add_file! */
586 coff_symfile_read (objfile
, section_offsets
, mainline
)
587 struct objfile
*objfile
;
588 struct section_offsets
*section_offsets
;
591 struct coff_symfile_info
*info
;
592 struct dbx_symfile_info
*dbxinfo
;
593 bfd
*abfd
= objfile
->obfd
;
594 coff_data_type
*cdata
= coff_data (abfd
);
595 char *name
= bfd_get_filename (abfd
);
600 int stringtab_offset
;
601 struct cleanup
*back_to
;
602 int stabsize
, stabstrsize
;
604 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
605 dbxinfo
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
606 symfile_bfd
= abfd
; /* Kludge for swap routines */
608 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
609 desc
= fileno ((GDB_FILE
*)(abfd
->iostream
)); /* File descriptor */
610 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
611 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
612 stringtab_offset
= symtab_offset
+ /* String table file offset */
613 num_symbols
* cdata
->local_symesz
;
615 /* Set a few file-statics that give us specific information about
616 the particular COFF file format we're reading. */
617 local_linesz
= cdata
->local_linesz
;
618 local_n_btmask
= cdata
->local_n_btmask
;
619 local_n_btshft
= cdata
->local_n_btshft
;
620 local_n_tmask
= cdata
->local_n_tmask
;
621 local_n_tshift
= cdata
->local_n_tshift
;
622 local_linesz
= cdata
->local_linesz
;
623 local_symesz
= cdata
->local_symesz
;
624 local_auxesz
= cdata
->local_auxesz
;
626 /* Allocate space for raw symbol and aux entries, based on their
627 space requirements as reported by BFD. */
628 temp_sym
= (char *) xmalloc
629 (cdata
->local_symesz
+ cdata
->local_auxesz
);
630 temp_aux
= temp_sym
+ cdata
->local_symesz
;
631 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
634 /* Read the line number table, all at once. */
635 info
->min_lineno_offset
= 0;
636 info
->max_lineno_offset
= 0;
637 bfd_map_over_sections (abfd
, find_linenos
, (PTR
) info
);
639 make_cleanup (free_linetab
, 0);
640 val
= init_lineno (desc
, info
->min_lineno_offset
,
641 info
->max_lineno_offset
- info
->min_lineno_offset
);
643 error ("\"%s\": error reading line numbers\n", name
);
645 /* Now read the string table, all at once. */
647 make_cleanup (free_stringtab
, 0);
648 val
= init_stringtab (desc
, stringtab_offset
);
650 error ("\"%s\": can't get string table", name
);
652 init_minimal_symbol_collection ();
653 make_cleanup (discard_minimal_symbols
, 0);
655 /* Now that the executable file is positioned at symbol table,
656 process it and define symbols accordingly. */
658 read_coff_symtab ((long)symtab_offset
, num_symbols
, objfile
);
660 /* Sort symbols alphabetically within each block. */
664 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
666 sort_symtab_syms (s
);
670 /* Install any minimal symbols that have been collected as the current
671 minimal symbols for this objfile. */
673 install_minimal_symbols (objfile
);
675 bfd_map_over_sections (abfd
, coff_locate_sections
, (PTR
) info
);
679 /* FIXME: dubious. Why can't we use something normal like
680 bfd_get_section_contents? */
681 fseek ((GDB_FILE
*) abfd
->iostream
, abfd
->where
, 0);
683 stabsize
= bfd_section_size (abfd
, info
->stabsect
);
684 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
686 coffstab_build_psymtabs (objfile
,
689 info
->stabsect
->filepos
, stabsize
,
690 info
->stabstrsect
->filepos
, stabstrsize
);
693 do_cleanups (back_to
);
697 coff_new_init (ignore
)
698 struct objfile
*ignore
;
702 /* Perform any local cleanups required when we are done with a particular
703 objfile. I.E, we are in the process of discarding all symbol information
704 for an objfile, freeing up all memory held for it, and unlinking the
705 objfile struct from the global list of known objfiles. */
708 coff_symfile_finish (objfile
)
709 struct objfile
*objfile
;
711 if (objfile
-> sym_private
!= NULL
)
713 mfree (objfile
-> md
, objfile
-> sym_private
);
718 /* Given pointers to a symbol table in coff style exec file,
719 analyze them and create struct symtab's describing the symbols.
720 NSYMS is the number of symbols in the symbol table.
721 We read them one at a time using read_one_sym (). */
724 read_coff_symtab (symtab_offset
, nsyms
, objfile
)
727 struct objfile
*objfile
;
730 register struct context_stack
*new;
731 struct coff_symbol coff_symbol
;
732 register struct coff_symbol
*cs
= &coff_symbol
;
733 static struct internal_syment main_sym
;
734 static union internal_auxent main_aux
;
735 struct coff_symbol fcn_cs_saved
;
736 static struct internal_syment fcn_sym_saved
;
737 static union internal_auxent fcn_aux_saved
;
740 /* A .file is open. */
741 int in_source_file
= 0;
742 int next_file_symnum
= -1;
744 /* Name of the current file. */
745 char *filestring
= "";
747 int fcn_first_line
= 0;
748 int fcn_last_line
= 0;
749 int fcn_start_addr
= 0;
750 long fcn_line_ptr
= 0;
753 stream
= bfd_cache_lookup(objfile
->obfd
);
755 perror_with_name(objfile
->name
);
757 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
758 it's hard to know I've really worked around it. The fix should be
759 harmless, anyway). The symptom of the bug is that the first
760 fread (in read_one_sym), will (in my example) actually get data
761 from file offset 268, when the fseek was to 264 (and ftell shows
762 264). This causes all hell to break loose. I was unable to
763 reproduce this on a short test program which operated on the same
764 file, performing (I think) the same sequence of operations.
766 It stopped happening when I put in this rewind().
768 FIXME: Find out if this has been reported to Sun, whether it has
769 been fixed in a later release, etc. */
773 /* Position to read the symbol table. */
774 val
= fseek (stream
, (long)symtab_offset
, 0);
776 perror_with_name (objfile
->name
);
778 current_objfile
= objfile
;
779 nlist_stream_global
= stream
;
780 nlist_nsyms_global
= nsyms
;
781 last_source_file
= NULL
;
782 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
784 if (type_vector
) /* Get rid of previous one */
785 free ((PTR
)type_vector
);
786 type_vector_length
= 160;
787 type_vector
= (struct type
**)
788 xmalloc (type_vector_length
* sizeof (struct type
*));
789 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
791 coff_start_symtab ();
794 while (symnum
< nsyms
)
796 QUIT
; /* Make this command interruptable. */
797 read_one_sym (cs
, &main_sym
, &main_aux
);
800 temp_sem_val
= cs
->c_name
[0] << 24 | cs
->c_name
[1] << 16 |
801 cs
->c_name
[2] << 8 | cs
->c_name
[3];
802 if (int_sem_val
== temp_sem_val
)
803 last_coffsem
= (int) strtol (cs
->c_name
+4, (char **) NULL
, 10);
806 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
808 if (last_source_file
)
809 coff_end_symtab (objfile
);
811 coff_start_symtab ();
812 complete_symtab ("_globals_", 0, 0);
813 /* done with all files, everything from here on out is globals */
816 /* Special case for file with type declarations only, no text. */
817 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
818 && cs
->c_secnum
== N_DEBUG
)
819 complete_symtab (filestring
, 0, 0);
821 /* Typedefs should not be treated as symbol definitions. */
822 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
824 /* Record all functions -- external and static -- in minsyms. */
825 record_minimal_symbol (cs
->c_name
, cs
->c_value
, mst_text
, objfile
);
827 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
828 fcn_start_addr
= cs
->c_value
;
830 fcn_sym_saved
= main_sym
;
831 fcn_aux_saved
= main_aux
;
835 switch (cs
->c_sclass
)
844 complain (&bad_sclass_complaint
, cs
->c_name
);
849 * c_value field contains symnum of next .file entry in table
850 * or symnum of first global after last .file.
852 next_file_symnum
= cs
->c_value
;
854 filestring
= coff_getfilename (&main_aux
);
859 * Complete symbol table for last object file
860 * containing debugging information.
862 if (last_source_file
)
864 coff_end_symtab (objfile
);
865 coff_start_symtab ();
871 if (cs
->c_name
[0] == '.') {
872 if (STREQ (cs
->c_name
, ".text")) {
873 /* FIXME: don't wire in ".text" as section name
875 /* Check for in_source_file deals with case of
876 a file with debugging symbols
877 followed by a later file with no symbols. */
879 complete_symtab (filestring
, cs
->c_value
,
880 main_aux
.x_scn
.x_scnlen
);
883 /* flush rest of '.' symbols */
886 else if (!SDB_TYPE (cs
->c_type
)
887 && cs
->c_name
[0] == 'L'
888 && (strncmp (cs
->c_name
, "LI%", 3) == 0
889 || strncmp (cs
->c_name
, "LF%", 3) == 0
890 || strncmp (cs
->c_name
,"LC%",3) == 0
891 || strncmp (cs
->c_name
,"LP%",3) == 0
892 || strncmp (cs
->c_name
,"LPB%",4) == 0
893 || strncmp (cs
->c_name
,"LBB%",4) == 0
894 || strncmp (cs
->c_name
,"LBE%",4) == 0
895 || strncmp (cs
->c_name
,"LPBX%",5) == 0))
896 /* At least on a 3b1, gcc generates swbeg and string labels
897 that look like this. Ignore them. */
899 /* fall in for static symbols that don't start with '.' */
901 /* Record external symbols in minsyms if we don't have debug
902 info for them. FIXME, this is probably the wrong thing
903 to do. Why don't we record them even if we do have
904 debug symbol info? What really belongs in the minsyms
906 if (!SDB_TYPE (cs
->c_type
)) {
907 /* FIXME: This is BOGUS Will Robinson!
908 Coff should provide the SEC_CODE flag for executable sections,
909 then if we could look up sections by section number we
910 could see if the flags indicate SEC_CODE. If so, then
911 record this symbol as a function in the minimal symbol table.
912 But why are absolute syms recorded as functions, anyway? */
913 if (cs
->c_secnum
<= text_bfd_scnum
+1) {/* text or abs */
914 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
918 record_minimal_symbol (cs
->c_name
, cs
->c_value
,
923 process_coff_symbol (cs
, &main_aux
, objfile
);
927 if (STREQ (cs
->c_name
, ".bf"))
931 /* value contains address of first non-init type code */
932 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
933 contains line number of '{' } */
935 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
936 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
938 /* Might want to check that locals are 0 and
939 context_stack_depth is zero, and complain if not. */
942 new = push_context (depth
, fcn_start_addr
);
943 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
944 new->name
= process_coff_symbol (&fcn_cs_saved
,
945 &fcn_aux_saved
, objfile
);
947 else if (STREQ (cs
->c_name
, ".ef"))
949 /* the value of .ef is the address of epilogue code;
950 not useful for gdb. */
951 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
952 contains number of lines to '}' */
953 new = pop_context ();
954 /* Stack must be empty now. */
955 if (context_stack_depth
> 0 || new == NULL
)
957 complain (&ef_complaint
, cs
->c_symnum
);
963 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
964 fcn_last_line
= 0x7FFFFFFF;
968 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
970 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
972 finish_block (new->name
, &local_symbols
, new->old_blocks
,
974 #if defined (FUNCTION_EPILOGUE_SIZE)
975 /* This macro should be defined only on
977 fcn_aux_saved.x_sym.x_misc.x_fsize
978 field is always zero.
979 So use the .bf record information that
980 points to the epilogue and add the size
982 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
984 fcn_cs_saved
.c_value
+
985 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
994 if (STREQ (cs
->c_name
, ".bb"))
996 push_context (++depth
, cs
->c_value
);
998 else if (STREQ (cs
->c_name
, ".eb"))
1000 new = pop_context ();
1001 if (depth
-- != new->depth
)
1003 complain (&eb_complaint
, symnum
);
1006 if (local_symbols
&& context_stack_depth
> 0)
1008 /* Make a block for the local symbols within. */
1009 finish_block (0, &local_symbols
, new->old_blocks
,
1010 new->start_addr
, cs
->c_value
, objfile
);
1012 /* Now pop locals of block just finished. */
1013 local_symbols
= new->locals
;
1018 process_coff_symbol (cs
, &main_aux
, objfile
);
1023 if (last_source_file
)
1024 coff_end_symtab (objfile
);
1026 /* Patch up any opaque types (references to types that are not defined
1027 in the file where they are referenced, e.g. "struct foo *bar"). */
1028 ALL_OBJFILE_SYMTABS (objfile
, s
)
1029 patch_opaque_types (s
);
1031 current_objfile
= NULL
;
1034 /* Routines for reading headers and symbols from executable. */
1037 /* Move these XXXMAGIC symbol defns into BFD! */
1039 /* Read COFF file header, check magic number,
1040 and return number of symbols. */
1041 read_file_hdr (chan
, file_hdr
)
1045 lseek (chan
, 0L, 0);
1046 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1049 switch (file_hdr
->f_magic
)
1064 #if defined (MC68KWRMAGIC) \
1065 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1079 case I960ROMAGIC
: /* Intel 960 */
1082 case I960RWMAGIC
: /* Intel 960 */
1084 return file_hdr
->f_nsyms
;
1088 if (BADMAG(file_hdr
))
1091 return file_hdr
->f_nsyms
;
1099 /* Read the next symbol, swap it, and return it in both internal_syment
1100 form, and coff_symbol form. Also return its first auxent, if any,
1101 in internal_auxent form, and skip any other auxents. */
1104 read_one_sym (cs
, sym
, aux
)
1105 register struct coff_symbol
*cs
;
1106 register struct internal_syment
*sym
;
1107 register union internal_auxent
*aux
;
1111 cs
->c_symnum
= symnum
;
1112 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1113 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1114 cs
->c_naux
= sym
->n_numaux
& 0xff;
1115 if (cs
->c_naux
>= 1)
1117 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1118 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1120 /* If more than one aux entry, read past it (only the first aux
1122 for (i
= 1; i
< cs
->c_naux
; i
++)
1123 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1125 cs
->c_name
= getsymname (sym
);
1126 cs
->c_value
= sym
->n_value
;
1127 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1128 cs
->c_secnum
= sym
->n_scnum
;
1129 cs
->c_type
= (unsigned) sym
->n_type
;
1130 if (!SDB_TYPE (cs
->c_type
))
1133 symnum
+= 1 + cs
->c_naux
;
1136 /* Support for string table handling */
1138 static char *stringtab
= NULL
;
1141 init_stringtab (chan
, offset
)
1147 unsigned char lengthbuf
[4];
1151 if (lseek (chan
, offset
, 0) < 0)
1154 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1155 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1157 /* If no string table is needed, then the file may end immediately
1158 after the symbols. Just return with `stringtab' set to null. */
1159 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1162 stringtab
= (char *) xmalloc (length
);
1163 memcpy (stringtab
, &length
, sizeof length
);
1164 if (length
== sizeof length
) /* Empty table -- just the count */
1167 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1168 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1183 getsymname (symbol_entry
)
1184 struct internal_syment
*symbol_entry
;
1186 static char buffer
[SYMNMLEN
+1];
1189 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1191 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1195 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1196 buffer
[SYMNMLEN
] = '\0';
1202 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1203 only the last component of the name. Result is in static storage and
1204 is only good for temporary use. */
1207 coff_getfilename (aux_entry
)
1208 union internal_auxent
*aux_entry
;
1210 static char buffer
[BUFSIZ
];
1211 register char *temp
;
1214 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1215 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1218 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1219 buffer
[FILNMLEN
] = '\0';
1222 if ((temp
= strrchr (result
, '/')) != NULL
)
1227 /* Support for line number handling */
1228 static char *linetab
= NULL
;
1229 static long linetab_offset
;
1230 static unsigned long linetab_size
;
1232 /* Read in all the line numbers for fast lookups later. Leave them in
1233 external (unswapped) format in memory; we'll swap them as we enter
1234 them into GDB's data structures. */
1237 init_lineno (chan
, offset
, size
)
1244 linetab_offset
= offset
;
1245 linetab_size
= size
;
1252 if (lseek (chan
, offset
, 0) < 0)
1255 /* Allocate the desired table, plus a sentinel */
1256 linetab
= (char *) xmalloc (size
+ local_linesz
);
1258 val
= myread (chan
, linetab
, size
);
1262 /* Terminate it with an all-zero sentinel record */
1263 memset (linetab
+ size
, 0, local_linesz
);
1276 #if !defined (L_LNNO32)
1277 #define L_LNNO32(lp) ((lp)->l_lnno)
1281 enter_linenos (file_offset
, first_line
, last_line
)
1283 register int first_line
;
1284 register int last_line
;
1286 register char *rawptr
;
1287 struct internal_lineno lptr
;
1289 if (file_offset
< linetab_offset
)
1291 complain (&lineno_complaint
, file_offset
);
1292 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1294 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1297 rawptr
= &linetab
[file_offset
- linetab_offset
];
1299 /* skip first line entry for each function */
1300 rawptr
+= local_linesz
;
1301 /* line numbers start at one for the first line of the function */
1305 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1306 rawptr
+= local_linesz
;
1307 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1308 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1309 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1316 patch_type (type
, real_type
)
1318 struct type
*real_type
;
1320 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1321 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1322 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1324 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1325 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1326 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1328 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1330 if (TYPE_NAME (real_target
))
1332 if (TYPE_NAME (target
))
1333 free (TYPE_NAME (target
));
1334 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1338 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1339 so that they can be used to print out opaque data structures properly. */
1342 patch_opaque_types (s
)
1345 register struct block
*b
;
1347 register struct symbol
*real_sym
;
1349 /* Go through the per-file symbols only */
1350 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1351 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1353 /* Find completed typedefs to use to fix opaque ones.
1354 Remove syms from the chain when their types are stored,
1355 but search the whole chain, as there may be several syms
1356 from different files with the same name. */
1357 real_sym
= BLOCK_SYM (b
, i
);
1358 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1359 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1360 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1361 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1363 register char *name
= SYMBOL_NAME (real_sym
);
1364 register int hash
= hashname (name
);
1365 register struct symbol
*sym
, *prev
;
1368 for (sym
= opaque_type_chain
[hash
]; sym
;)
1370 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1371 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1375 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1379 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1382 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1386 sym
= SYMBOL_VALUE_CHAIN (prev
);
1390 sym
= opaque_type_chain
[hash
];
1396 sym
= SYMBOL_VALUE_CHAIN (sym
);
1403 static struct symbol
*
1404 process_coff_symbol (cs
, aux
, objfile
)
1405 register struct coff_symbol
*cs
;
1406 register union internal_auxent
*aux
;
1407 struct objfile
*objfile
;
1409 register struct symbol
*sym
1410 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1411 sizeof (struct symbol
));
1413 struct type
*temptype
;
1415 memset (sym
, 0, sizeof (struct symbol
));
1417 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1418 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1421 /* default assumptions */
1422 SYMBOL_VALUE (sym
) = cs
->c_value
;
1423 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1425 if (ISFCN (cs
->c_type
))
1428 /* FIXME: This has NOT been tested. The DBX version has.. */
1429 /* Generate a template for the type of this function. The
1430 types of the arguments will be added as we read the symbol
1432 struct type
*new = (struct type
*)
1433 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1435 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1436 sizeof(struct type
));
1437 SYMBOL_TYPE (sym
) = new;
1438 in_function_type
= SYMBOL_TYPE(sym
);
1441 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1444 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1445 if (cs
->c_sclass
== C_STAT
)
1446 add_symbol_to_list (sym
, &file_symbols
);
1447 else if (cs
->c_sclass
== C_EXT
)
1448 add_symbol_to_list (sym
, &global_symbols
);
1452 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1453 switch (cs
->c_sclass
)
1459 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1460 add_symbol_to_list (sym
, &local_symbols
);
1464 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1465 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1466 add_symbol_to_list (sym
, &global_symbols
);
1470 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1471 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1472 if (within_function
) {
1473 /* Static symbol of local scope */
1474 add_symbol_to_list (sym
, &local_symbols
);
1477 /* Static symbol at top level of file */
1478 add_symbol_to_list (sym
, &file_symbols
);
1482 #ifdef C_GLBLREG /* AMD coff */
1486 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1487 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1488 add_symbol_to_list (sym
, &local_symbols
);
1495 SYMBOL_CLASS (sym
) = LOC_ARG
;
1497 /* FIXME: This has not been tested. */
1498 /* Add parameter to function. */
1499 add_param_to_type(&in_function_type
,sym
);
1501 add_symbol_to_list (sym
, &local_symbols
);
1502 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1503 /* If PCC says a parameter is a short or a char,
1504 aligned on an int boundary, realign it to the "little end"
1506 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1507 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1508 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1509 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1511 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1512 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1518 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1519 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1520 add_symbol_to_list (sym
, &local_symbols
);
1521 #if !defined (BELIEVE_PCC_PROMOTION)
1522 /* FIXME: This should retain the current type, since it's just
1523 a register value. gnu@adobe, 26Feb93 */
1524 /* If PCC says a parameter is a short or a char,
1525 it is really an int. */
1526 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1527 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1528 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1530 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1531 ? lookup_fundamental_type (current_objfile
,
1532 FT_UNSIGNED_INTEGER
)
1539 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1540 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1542 /* If type has no name, give it one */
1543 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1544 TYPE_NAME (SYMBOL_TYPE (sym
)) = concat (SYMBOL_NAME (sym
), NULL
);
1546 /* Keep track of any type which points to empty structured type,
1547 so it can be filled from a definition from another file. A
1548 simple forward reference (TYPE_CODE_UNDEF) is not an
1549 empty structured type, though; the forward references
1550 work themselves out via the magic of coff_lookup_type. */
1551 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1552 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1553 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1556 register int i
= hashname (SYMBOL_NAME (sym
));
1558 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1559 opaque_type_chain
[i
] = sym
;
1561 add_symbol_to_list (sym
, &file_symbols
);
1567 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1568 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1570 /* Some compilers try to be helpful by inventing "fake"
1571 names for anonymous enums, structures, and unions, like
1572 "~0fake" or ".0fake". Thanks, but no thanks... */
1573 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1574 if (SYMBOL_NAME(sym
) != NULL
1575 && *SYMBOL_NAME(sym
) != '~'
1576 && *SYMBOL_NAME(sym
) != '.')
1577 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1578 concat (SYMBOL_NAME (sym
), NULL
);
1580 add_symbol_to_list (sym
, &file_symbols
);
1590 /* Decode a coff type specifier;
1591 return the type that is meant. */
1595 decode_type (cs
, c_type
, aux
)
1596 register struct coff_symbol
*cs
;
1597 unsigned int c_type
;
1598 register union internal_auxent
*aux
;
1600 register struct type
*type
= 0;
1601 unsigned int new_c_type
;
1603 if (c_type
& ~N_BTMASK
)
1605 new_c_type
= DECREF (c_type
);
1608 type
= decode_type (cs
, new_c_type
, aux
);
1609 type
= lookup_pointer_type (type
);
1611 else if (ISFCN (c_type
))
1613 type
= decode_type (cs
, new_c_type
, aux
);
1614 type
= lookup_function_type (type
);
1616 else if (ISARY (c_type
))
1619 register unsigned short *dim
;
1620 struct type
*base_type
, *index_type
, *range_type
;
1622 /* Define an array type. */
1623 /* auxent refers to array, not base type */
1624 if (aux
->x_sym
.x_tagndx
.l
== 0)
1627 /* shift the indices down */
1628 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1631 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1635 base_type
= decode_type (cs
, new_c_type
, aux
);
1636 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1638 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1640 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1645 /* Reference to existing type. This only occurs with the
1646 struct, union, and enum types. EPI a29k coff
1647 fakes us out by producing aux entries with a nonzero
1648 x_tagndx for definitions of structs, unions, and enums, so we
1649 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1650 with pointers to pointers to defined structs, and generates
1651 negative x_tagndx fields. */
1652 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1654 if (cs
->c_sclass
!= C_STRTAG
1655 && cs
->c_sclass
!= C_UNTAG
1656 && cs
->c_sclass
!= C_ENTAG
1657 && aux
->x_sym
.x_tagndx
.l
>= 0)
1659 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1662 complain (&tagndx_bad_complaint
, cs
->c_name
);
1663 /* And fall through to decode_base_type... */
1667 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1670 /* Decode a coff type specifier for function definition;
1671 return the type that the function returns. */
1675 decode_function_type (cs
, c_type
, aux
)
1676 register struct coff_symbol
*cs
;
1677 unsigned int c_type
;
1678 register union internal_auxent
*aux
;
1680 if (aux
->x_sym
.x_tagndx
.l
== 0)
1681 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1683 return decode_type (cs
, DECREF (c_type
), aux
);
1690 decode_base_type (cs
, c_type
, aux
)
1691 register struct coff_symbol
*cs
;
1692 unsigned int c_type
;
1693 register union internal_auxent
*aux
;
1700 /* shows up with "void (*foo)();" structure members */
1701 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1704 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1707 /* Shows up in DGUX, I think. Not sure where. */
1708 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1714 /* Intel 960 COFF has this symbol and meaning. */
1715 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1719 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1722 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1725 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1728 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1731 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1734 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1737 if (cs
->c_naux
!= 1)
1739 /* anonymous structure type */
1740 type
= coff_alloc_type (cs
->c_symnum
);
1741 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1742 TYPE_NAME (type
) = NULL
;
1743 /* This used to set the tag to "<opaque>". But I think setting it
1744 to NULL is right, and the printing code can print it as
1746 TYPE_TAG_NAME (type
) = NULL
;
1747 INIT_CPLUS_SPECIFIC(type
);
1748 TYPE_LENGTH (type
) = 0;
1749 TYPE_FIELDS (type
) = 0;
1750 TYPE_NFIELDS (type
) = 0;
1754 type
= coff_read_struct_type (cs
->c_symnum
,
1755 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1756 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1761 if (cs
->c_naux
!= 1)
1763 /* anonymous union type */
1764 type
= coff_alloc_type (cs
->c_symnum
);
1765 TYPE_NAME (type
) = NULL
;
1766 /* This used to set the tag to "<opaque>". But I think setting it
1767 to NULL is right, and the printing code can print it as
1769 TYPE_TAG_NAME (type
) = NULL
;
1770 INIT_CPLUS_SPECIFIC(type
);
1771 TYPE_LENGTH (type
) = 0;
1772 TYPE_FIELDS (type
) = 0;
1773 TYPE_NFIELDS (type
) = 0;
1777 type
= coff_read_struct_type (cs
->c_symnum
,
1778 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1779 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1781 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1785 if (cs
->c_naux
!= 1)
1787 /* anonymous enum type */
1788 type
= coff_alloc_type (cs
->c_symnum
);
1789 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1790 TYPE_NAME (type
) = NULL
;
1791 /* This used to set the tag to "<opaque>". But I think setting it
1792 to NULL is right, and the printing code can print it as
1794 TYPE_TAG_NAME (type
) = NULL
;
1795 TYPE_LENGTH (type
) = 0;
1796 TYPE_FIELDS (type
) = 0;
1797 TYPE_NFIELDS(type
) = 0;
1801 type
= coff_read_enum_type (cs
->c_symnum
,
1802 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1803 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1808 /* shouldn't show up here */
1812 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1815 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1818 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1821 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
1823 complain (&unexpected_type_complaint
, cs
->c_name
);
1824 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1827 /* This page contains subroutines of read_type. */
1829 /* Read the description of a structure (or union type)
1830 and return an object describing the type. */
1832 static struct type
*
1833 coff_read_struct_type (index
, length
, lastsym
)
1840 struct nextfield
*next
;
1844 register struct type
*type
;
1845 register struct nextfield
*list
= 0;
1846 struct nextfield
*new;
1850 struct coff_symbol member_sym
;
1851 register struct coff_symbol
*ms
= &member_sym
;
1852 struct internal_syment sub_sym
;
1853 union internal_auxent sub_aux
;
1856 type
= coff_alloc_type (index
);
1857 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1858 INIT_CPLUS_SPECIFIC(type
);
1859 TYPE_LENGTH (type
) = length
;
1861 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1863 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1865 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1867 switch (ms
->c_sclass
)
1872 /* Get space to record the next field's data. */
1873 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1877 /* Save the data. */
1878 list
->field
.name
= savestring (name
, strlen (name
));
1879 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1880 list
->field
.bitpos
= 8 * ms
->c_value
;
1881 list
->field
.bitsize
= 0;
1887 /* Get space to record the next field's data. */
1888 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1892 /* Save the data. */
1893 list
->field
.name
= savestring (name
, strlen (name
));
1894 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1895 list
->field
.bitpos
= ms
->c_value
;
1896 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1905 /* Now create the vector of fields, and record how big it is. */
1907 TYPE_NFIELDS (type
) = nfields
;
1908 TYPE_FIELDS (type
) = (struct field
*)
1909 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1911 /* Copy the saved-up fields into the field vector. */
1913 for (n
= nfields
; list
; list
= list
->next
)
1914 TYPE_FIELD (type
, --n
) = list
->field
;
1919 /* Read a definition of an enumeration type,
1920 and create and return a suitable type object.
1921 Also defines the symbols that represent the values of the type. */
1924 static struct type
*
1925 coff_read_enum_type (index
, length
, lastsym
)
1930 register struct symbol
*sym
;
1931 register struct type
*type
;
1934 struct pending
**symlist
;
1935 struct coff_symbol member_sym
;
1936 register struct coff_symbol
*ms
= &member_sym
;
1937 struct internal_syment sub_sym
;
1938 union internal_auxent sub_aux
;
1939 struct pending
*osyms
, *syms
;
1944 type
= coff_alloc_type (index
);
1945 if (within_function
)
1946 symlist
= &local_symbols
;
1948 symlist
= &file_symbols
;
1950 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1952 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1954 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1956 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1958 switch (ms
->c_sclass
)
1961 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1962 memset (sym
, 0, sizeof (struct symbol
));
1964 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1965 SYMBOL_CLASS (sym
) = LOC_CONST
;
1966 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1967 SYMBOL_VALUE (sym
) = ms
->c_value
;
1968 add_symbol_to_list (sym
, symlist
);
1973 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
1974 up the count of how many symbols to read. So stop
1981 /* Now fill in the fields of the type-structure. */
1984 TYPE_LENGTH (type
) = length
;
1986 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
1987 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1988 TYPE_NFIELDS (type
) = nsyms
;
1989 TYPE_FIELDS (type
) = (struct field
*)
1990 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
1992 /* Find the symbols for the values and put them into the type.
1993 The symbols can be found in the symlist that we put them on
1994 to cause them to be defined. osyms contains the old value
1995 of that symlist; everything up to there was defined by us. */
1996 /* Note that we preserve the order of the enum constants, so
1997 that in something like "enum {FOO, LAST_THING=FOO}" we print
1998 FOO, not LAST_THING. */
2000 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2005 for (; j
< syms
->nsyms
; j
++,n
++)
2007 struct symbol
*xsym
= syms
->symbol
[j
];
2008 SYMBOL_TYPE (xsym
) = type
;
2009 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2010 TYPE_FIELD_VALUE (type
, n
) = 0;
2011 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2012 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2019 /* This screws up perfectly good C programs with enums. FIXME. */
2020 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2021 if(TYPE_NFIELDS(type
) == 2 &&
2022 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2023 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2024 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2025 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2026 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2031 struct section_offsets
*
2032 coff_symfile_offsets (objfile
, addr
)
2033 struct objfile
*objfile
;
2036 struct section_offsets
*section_offsets
;
2039 objfile
->num_sections
= SECT_OFF_MAX
;
2040 section_offsets
= (struct section_offsets
*)
2041 obstack_alloc (&objfile
-> psymbol_obstack
,
2042 sizeof (struct section_offsets
)
2043 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2045 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2046 ANOFFSET (section_offsets
, i
) = addr
;
2048 return section_offsets
;
2051 /* Register our ability to parse symbols for coff BFD files */
2053 static struct sym_fns coff_sym_fns
=
2055 bfd_target_coff_flavour
,
2056 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2057 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2058 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2059 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2060 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2061 NULL
/* next: pointer to next struct sym_fns */
2065 _initialize_coffread ()
2067 add_symtab_fns(&coff_sym_fns
);