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"
32 #include <time.h> /* For time_t in libbfd.h. */
33 #include <sys/types.h> /* For time_t, if not in time.h. */
34 #include "libbfd.h" /* FIXME secret internal data from BFD */
35 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
36 #include "libcoff.h" /* FIXME secret internal data from BFD */
41 #include "gdb-stabs.h"
42 #include "stabsread.h"
43 #include "complaints.h"
45 struct coff_symfile_info
{
46 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
47 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
49 asection
*stabsect
; /* Section pointer for .stab section */
50 asection
*stabstrsect
; /* Section pointer for .stab section */
51 asection
*stabindexsect
; /* Section pointer for .stab.index section */
55 /* Translate an external name string into a user-visible name. */
56 #define EXTERNAL_NAME(string, abfd) \
57 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
59 /* To be an sdb debug type, type must have at least a basic or primary
60 derived type. Using this rather than checking against T_NULL is
61 said to prevent core dumps if we try to operate on Michael Bloom
64 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
67 * Convert from an sdb register number to an internal gdb register number.
68 * This should be defined in tm.h, if REGISTER_NAMES is not set up
69 * to map one to one onto the sdb register numbers.
71 #ifndef SDB_REG_TO_REGNUM
72 # define SDB_REG_TO_REGNUM(value) (value)
75 /* Core address of start and end of text of current source file.
76 This comes from a ".text" symbol where x_nlinno > 0. */
78 static CORE_ADDR cur_src_start_addr
;
79 static CORE_ADDR cur_src_end_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 GDB_FILE
*nlist_stream_global
;
85 static int nlist_nsyms_global
;
87 /* Vector of line number information. */
89 static struct linetable
*line_vector
;
91 /* Index of next entry to go in line_vector_index. */
93 static int line_vector_index
;
95 /* Last line number recorded in the line vector. */
97 static int prev_line_number
;
99 /* Number of elements allocated for line_vector currently. */
101 static int line_vector_length
;
103 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
105 static char *temp_sym
;
106 static char *temp_aux
;
108 /* Local variables that hold the shift and mask values for the
109 COFF file that we are currently reading. These come back to us
110 from BFD, and are referenced by their macro names, as well as
111 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
112 macros from ../internalcoff.h . */
114 static unsigned local_n_btmask
;
115 static unsigned local_n_btshft
;
116 static unsigned local_n_tmask
;
117 static unsigned local_n_tshift
;
119 #define N_BTMASK local_n_btmask
120 #define N_BTSHFT local_n_btshft
121 #define N_TMASK local_n_tmask
122 #define N_TSHIFT local_n_tshift
124 /* Local variables that hold the sizes in the file of various COFF structures.
125 (We only need to know this to read them from the file -- BFD will then
126 translate the data in them, into `internal_xxx' structs in the right
127 byte order, alignment, etc.) */
129 static unsigned local_linesz
;
130 static unsigned local_symesz
;
131 static unsigned local_auxesz
;
134 /* Chain of typedefs of pointers to empty struct/union types.
135 They are chained thru the SYMBOL_VALUE_CHAIN. */
137 static struct symbol
*opaque_type_chain
[HASHSIZE
];
140 /* The type of the function we are currently reading in. This is
141 used by define_symbol to record the type of arguments to a function. */
143 struct type
*in_function_type
;
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 it in the minimal symbols regardless of SDB_TYPE.
902 This parallels what we do for other debug formats, and
903 probably is needed to make print_address_symbolic work right
904 without the "set fast-symbolic-addr off" kludge. */
906 /* FIXME: This bogusly assumes the sections are in a certain
907 order, text (SEC_CODE) sections are before data sections,
909 if (cs
->c_secnum
<= text_bfd_scnum
+1)
911 /* text or absolute. (FIXME, should use mst_abs if
913 record_minimal_symbol
914 (cs
->c_name
, cs
->c_value
,
915 cs
->c_sclass
== C_STAT
? mst_file_text
: mst_text
,
920 record_minimal_symbol
921 (cs
->c_name
, cs
->c_value
,
922 cs
->c_sclass
== C_STAT
? mst_file_data
: mst_data
,
925 if (SDB_TYPE (cs
->c_type
))
926 process_coff_symbol (cs
, &main_aux
, objfile
);
930 if (STREQ (cs
->c_name
, ".bf"))
934 /* value contains address of first non-init type code */
935 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
936 contains line number of '{' } */
938 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
939 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
941 /* Might want to check that locals are 0 and
942 context_stack_depth is zero, and complain if not. */
945 new = push_context (depth
, fcn_start_addr
);
946 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
947 new->name
= process_coff_symbol (&fcn_cs_saved
,
948 &fcn_aux_saved
, objfile
);
950 else if (STREQ (cs
->c_name
, ".ef"))
952 /* the value of .ef is the address of epilogue code;
953 not useful for gdb. */
954 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
955 contains number of lines to '}' */
956 new = pop_context ();
957 /* Stack must be empty now. */
958 if (context_stack_depth
> 0 || new == NULL
)
960 complain (&ef_complaint
, cs
->c_symnum
);
966 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
967 fcn_last_line
= 0x7FFFFFFF;
971 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
973 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
);
975 finish_block (new->name
, &local_symbols
, new->old_blocks
,
977 #if defined (FUNCTION_EPILOGUE_SIZE)
978 /* This macro should be defined only on
980 fcn_aux_saved.x_sym.x_misc.x_fsize
981 field is always zero.
982 So use the .bf record information that
983 points to the epilogue and add the size
985 cs
->c_value
+ FUNCTION_EPILOGUE_SIZE
,
987 fcn_cs_saved
.c_value
+
988 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
,
997 if (STREQ (cs
->c_name
, ".bb"))
999 push_context (++depth
, cs
->c_value
);
1001 else if (STREQ (cs
->c_name
, ".eb"))
1003 new = pop_context ();
1004 if (depth
-- != new->depth
)
1006 complain (&eb_complaint
, symnum
);
1009 if (local_symbols
&& context_stack_depth
> 0)
1011 /* Make a block for the local symbols within. */
1012 finish_block (0, &local_symbols
, new->old_blocks
,
1013 new->start_addr
, cs
->c_value
, objfile
);
1015 /* Now pop locals of block just finished. */
1016 local_symbols
= new->locals
;
1021 process_coff_symbol (cs
, &main_aux
, objfile
);
1026 if (last_source_file
)
1027 coff_end_symtab (objfile
);
1029 /* Patch up any opaque types (references to types that are not defined
1030 in the file where they are referenced, e.g. "struct foo *bar"). */
1031 ALL_OBJFILE_SYMTABS (objfile
, s
)
1032 patch_opaque_types (s
);
1034 current_objfile
= NULL
;
1037 /* Routines for reading headers and symbols from executable. */
1040 /* Move these XXXMAGIC symbol defns into BFD! */
1042 /* Read COFF file header, check magic number,
1043 and return number of symbols. */
1044 read_file_hdr (chan
, file_hdr
)
1048 lseek (chan
, 0L, 0);
1049 if (myread (chan
, (char *)file_hdr
, FILHSZ
) < 0)
1052 switch (file_hdr
->f_magic
)
1067 #if defined (MC68KWRMAGIC) \
1068 && (!defined (MC68MAGIC) || MC68KWRMAGIC != MC68MAGIC)
1082 case I960ROMAGIC
: /* Intel 960 */
1085 case I960RWMAGIC
: /* Intel 960 */
1087 return file_hdr
->f_nsyms
;
1091 if (BADMAG(file_hdr
))
1094 return file_hdr
->f_nsyms
;
1102 /* Read the next symbol, swap it, and return it in both internal_syment
1103 form, and coff_symbol form. Also return its first auxent, if any,
1104 in internal_auxent form, and skip any other auxents. */
1107 read_one_sym (cs
, sym
, aux
)
1108 register struct coff_symbol
*cs
;
1109 register struct internal_syment
*sym
;
1110 register union internal_auxent
*aux
;
1114 cs
->c_symnum
= symnum
;
1115 fread (temp_sym
, local_symesz
, 1, nlist_stream_global
);
1116 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *)sym
);
1117 cs
->c_naux
= sym
->n_numaux
& 0xff;
1118 if (cs
->c_naux
>= 1)
1120 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1121 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1122 0, cs
->c_naux
, (char *)aux
);
1123 /* If more than one aux entry, read past it (only the first aux
1125 for (i
= 1; i
< cs
->c_naux
; i
++)
1126 fread (temp_aux
, local_auxesz
, 1, nlist_stream_global
);
1128 cs
->c_name
= getsymname (sym
);
1129 cs
->c_value
= sym
->n_value
;
1130 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1131 cs
->c_secnum
= sym
->n_scnum
;
1132 cs
->c_type
= (unsigned) sym
->n_type
;
1133 if (!SDB_TYPE (cs
->c_type
))
1136 symnum
+= 1 + cs
->c_naux
;
1139 /* Support for string table handling */
1141 static char *stringtab
= NULL
;
1144 init_stringtab (chan
, offset
)
1150 unsigned char lengthbuf
[4];
1154 if (lseek (chan
, offset
, 0) < 0)
1157 val
= myread (chan
, (char *)lengthbuf
, sizeof lengthbuf
);
1158 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1160 /* If no string table is needed, then the file may end immediately
1161 after the symbols. Just return with `stringtab' set to null. */
1162 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1165 stringtab
= (char *) xmalloc (length
);
1166 memcpy (stringtab
, &length
, sizeof length
);
1167 if (length
== sizeof length
) /* Empty table -- just the count */
1170 val
= myread (chan
, stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
);
1171 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1186 getsymname (symbol_entry
)
1187 struct internal_syment
*symbol_entry
;
1189 static char buffer
[SYMNMLEN
+1];
1192 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1194 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1198 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1199 buffer
[SYMNMLEN
] = '\0';
1205 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1206 only the last component of the name. Result is in static storage and
1207 is only good for temporary use. */
1210 coff_getfilename (aux_entry
)
1211 union internal_auxent
*aux_entry
;
1213 static char buffer
[BUFSIZ
];
1214 register char *temp
;
1217 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1218 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1221 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1222 buffer
[FILNMLEN
] = '\0';
1225 if ((temp
= strrchr (result
, '/')) != NULL
)
1230 /* Support for line number handling */
1231 static char *linetab
= NULL
;
1232 static long linetab_offset
;
1233 static unsigned long linetab_size
;
1235 /* Read in all the line numbers for fast lookups later. Leave them in
1236 external (unswapped) format in memory; we'll swap them as we enter
1237 them into GDB's data structures. */
1240 init_lineno (chan
, offset
, size
)
1247 linetab_offset
= offset
;
1248 linetab_size
= size
;
1255 if (lseek (chan
, offset
, 0) < 0)
1258 /* Allocate the desired table, plus a sentinel */
1259 linetab
= (char *) xmalloc (size
+ local_linesz
);
1261 val
= myread (chan
, linetab
, size
);
1265 /* Terminate it with an all-zero sentinel record */
1266 memset (linetab
+ size
, 0, local_linesz
);
1279 #if !defined (L_LNNO32)
1280 #define L_LNNO32(lp) ((lp)->l_lnno)
1284 enter_linenos (file_offset
, first_line
, last_line
)
1286 register int first_line
;
1287 register int last_line
;
1289 register char *rawptr
;
1290 struct internal_lineno lptr
;
1292 if (file_offset
< linetab_offset
)
1294 complain (&lineno_complaint
, file_offset
);
1295 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1297 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1300 rawptr
= &linetab
[file_offset
- linetab_offset
];
1302 /* skip first line entry for each function */
1303 rawptr
+= local_linesz
;
1304 /* line numbers start at one for the first line of the function */
1308 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1309 rawptr
+= local_linesz
;
1310 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1311 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1312 coff_record_line (first_line
+ L_LNNO32 (&lptr
), lptr
.l_addr
.l_paddr
);
1319 patch_type (type
, real_type
)
1321 struct type
*real_type
;
1323 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1324 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1325 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1327 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1328 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1329 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1331 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1333 if (TYPE_NAME (real_target
))
1335 if (TYPE_NAME (target
))
1336 free (TYPE_NAME (target
));
1337 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1341 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1342 so that they can be used to print out opaque data structures properly. */
1345 patch_opaque_types (s
)
1348 register struct block
*b
;
1350 register struct symbol
*real_sym
;
1352 /* Go through the per-file symbols only */
1353 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1354 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1356 /* Find completed typedefs to use to fix opaque ones.
1357 Remove syms from the chain when their types are stored,
1358 but search the whole chain, as there may be several syms
1359 from different files with the same name. */
1360 real_sym
= BLOCK_SYM (b
, i
);
1361 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1362 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1363 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1364 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1366 register char *name
= SYMBOL_NAME (real_sym
);
1367 register int hash
= hashname (name
);
1368 register struct symbol
*sym
, *prev
;
1371 for (sym
= opaque_type_chain
[hash
]; sym
;)
1373 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1374 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1378 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1382 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1385 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1389 sym
= SYMBOL_VALUE_CHAIN (prev
);
1393 sym
= opaque_type_chain
[hash
];
1399 sym
= SYMBOL_VALUE_CHAIN (sym
);
1406 static struct symbol
*
1407 process_coff_symbol (cs
, aux
, objfile
)
1408 register struct coff_symbol
*cs
;
1409 register union internal_auxent
*aux
;
1410 struct objfile
*objfile
;
1412 register struct symbol
*sym
1413 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1414 sizeof (struct symbol
));
1417 memset (sym
, 0, sizeof (struct symbol
));
1419 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1420 SYMBOL_NAME (sym
) = obstack_copy0 (&objfile
->symbol_obstack
, name
,
1423 /* default assumptions */
1424 SYMBOL_VALUE (sym
) = cs
->c_value
;
1425 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1427 if (ISFCN (cs
->c_type
))
1430 /* FIXME: This has NOT been tested. The DBX version has.. */
1431 /* Generate a template for the type of this function. The
1432 types of the arguments will be added as we read the symbol
1434 struct type
*new = (struct type
*)
1435 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct type
));
1437 memcpy (new, lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
)),
1438 sizeof(struct type
));
1439 SYMBOL_TYPE (sym
) = new;
1440 in_function_type
= SYMBOL_TYPE(sym
);
1443 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1446 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1447 if (cs
->c_sclass
== C_STAT
)
1448 add_symbol_to_list (sym
, &file_symbols
);
1449 else if (cs
->c_sclass
== C_EXT
)
1450 add_symbol_to_list (sym
, &global_symbols
);
1454 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1455 switch (cs
->c_sclass
)
1461 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1462 add_symbol_to_list (sym
, &local_symbols
);
1466 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1467 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1468 add_symbol_to_list (sym
, &global_symbols
);
1472 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1473 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1474 if (within_function
) {
1475 /* Static symbol of local scope */
1476 add_symbol_to_list (sym
, &local_symbols
);
1479 /* Static symbol at top level of file */
1480 add_symbol_to_list (sym
, &file_symbols
);
1484 #ifdef C_GLBLREG /* AMD coff */
1488 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1489 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1490 add_symbol_to_list (sym
, &local_symbols
);
1497 SYMBOL_CLASS (sym
) = LOC_ARG
;
1499 /* FIXME: This has not been tested. */
1500 /* Add parameter to function. */
1501 add_param_to_type(&in_function_type
,sym
);
1503 add_symbol_to_list (sym
, &local_symbols
);
1504 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
1506 /* If PCC says a parameter is a short or a char,
1507 aligned on an int boundary, realign it to the "little end"
1509 struct type
*temptype
;
1510 temptype
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1511 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1512 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1513 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1515 SYMBOL_VALUE (sym
) +=
1516 TYPE_LENGTH (temptype
)
1517 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1523 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1524 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM(cs
->c_value
);
1525 add_symbol_to_list (sym
, &local_symbols
);
1526 #if !defined (BELIEVE_PCC_PROMOTION)
1527 /* FIXME: This should retain the current type, since it's just
1528 a register value. gnu@adobe, 26Feb93 */
1530 /* If PCC says a parameter is a short or a char,
1531 it is really an int. */
1532 struct type
*temptype
;
1534 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1535 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1536 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1539 (TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1540 ? lookup_fundamental_type (current_objfile
,
1541 FT_UNSIGNED_INTEGER
)
1548 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1549 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1551 /* If type has no name, give it one */
1552 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1554 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1555 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1557 /* If we are giving a name to a type such as "pointer to
1558 foo" or "function returning foo", we better not set
1559 the TYPE_NAME. If the program contains "typedef char
1560 *caddr_t;", we don't want all variables of type char
1561 * to print as caddr_t. This is not just a
1562 consequence of GDB's type management; CC and GCC (at
1563 least through version 2.4) both output variables of
1564 either type char * or caddr_t with the type
1565 refering to the C_TPDEF symbol for caddr_t. If a future
1566 compiler cleans this up it GDB is not ready for it
1567 yet, but if it becomes ready we somehow need to
1568 disable this check (without breaking the PCC/GCC2.4
1573 Fortunately, this check seems not to be necessary
1574 for anything except pointers or functions. */
1578 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1579 concat (SYMBOL_NAME (sym
), NULL
);
1582 /* Keep track of any type which points to empty structured type,
1583 so it can be filled from a definition from another file. A
1584 simple forward reference (TYPE_CODE_UNDEF) is not an
1585 empty structured type, though; the forward references
1586 work themselves out via the magic of coff_lookup_type. */
1587 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1588 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1589 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1592 register int i
= hashname (SYMBOL_NAME (sym
));
1594 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1595 opaque_type_chain
[i
] = sym
;
1597 add_symbol_to_list (sym
, &file_symbols
);
1603 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1604 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1606 /* Some compilers try to be helpful by inventing "fake"
1607 names for anonymous enums, structures, and unions, like
1608 "~0fake" or ".0fake". Thanks, but no thanks... */
1609 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1610 if (SYMBOL_NAME(sym
) != NULL
1611 && *SYMBOL_NAME(sym
) != '~'
1612 && *SYMBOL_NAME(sym
) != '.')
1613 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1614 concat (SYMBOL_NAME (sym
), NULL
);
1616 add_symbol_to_list (sym
, &file_symbols
);
1626 /* Decode a coff type specifier;
1627 return the type that is meant. */
1631 decode_type (cs
, c_type
, aux
)
1632 register struct coff_symbol
*cs
;
1633 unsigned int c_type
;
1634 register union internal_auxent
*aux
;
1636 register struct type
*type
= 0;
1637 unsigned int new_c_type
;
1639 if (c_type
& ~N_BTMASK
)
1641 new_c_type
= DECREF (c_type
);
1644 type
= decode_type (cs
, new_c_type
, aux
);
1645 type
= lookup_pointer_type (type
);
1647 else if (ISFCN (c_type
))
1649 type
= decode_type (cs
, new_c_type
, aux
);
1650 type
= lookup_function_type (type
);
1652 else if (ISARY (c_type
))
1655 register unsigned short *dim
;
1656 struct type
*base_type
, *index_type
, *range_type
;
1658 /* Define an array type. */
1659 /* auxent refers to array, not base type */
1660 if (aux
->x_sym
.x_tagndx
.l
== 0)
1663 /* shift the indices down */
1664 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1667 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1671 base_type
= decode_type (cs
, new_c_type
, aux
);
1672 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1674 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1676 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1681 /* Reference to existing type. This only occurs with the
1682 struct, union, and enum types. EPI a29k coff
1683 fakes us out by producing aux entries with a nonzero
1684 x_tagndx for definitions of structs, unions, and enums, so we
1685 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1686 with pointers to pointers to defined structs, and generates
1687 negative x_tagndx fields. */
1688 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1690 if (cs
->c_sclass
!= C_STRTAG
1691 && cs
->c_sclass
!= C_UNTAG
1692 && cs
->c_sclass
!= C_ENTAG
1693 && aux
->x_sym
.x_tagndx
.l
>= 0)
1695 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1698 complain (&tagndx_bad_complaint
, cs
->c_name
);
1699 /* And fall through to decode_base_type... */
1703 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1706 /* Decode a coff type specifier for function definition;
1707 return the type that the function returns. */
1711 decode_function_type (cs
, c_type
, aux
)
1712 register struct coff_symbol
*cs
;
1713 unsigned int c_type
;
1714 register union internal_auxent
*aux
;
1716 if (aux
->x_sym
.x_tagndx
.l
== 0)
1717 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1719 return decode_type (cs
, DECREF (c_type
), aux
);
1726 decode_base_type (cs
, c_type
, aux
)
1727 register struct coff_symbol
*cs
;
1728 unsigned int c_type
;
1729 register union internal_auxent
*aux
;
1736 /* shows up with "void (*foo)();" structure members */
1737 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1740 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1743 /* Shows up in DGUX, I think. Not sure where. */
1744 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1750 /* Intel 960 COFF has this symbol and meaning. */
1751 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1755 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1758 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1761 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1764 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1767 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1770 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1773 if (cs
->c_naux
!= 1)
1775 /* anonymous structure type */
1776 type
= coff_alloc_type (cs
->c_symnum
);
1777 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1778 TYPE_NAME (type
) = NULL
;
1779 /* This used to set the tag to "<opaque>". But I think setting it
1780 to NULL is right, and the printing code can print it as
1782 TYPE_TAG_NAME (type
) = NULL
;
1783 INIT_CPLUS_SPECIFIC(type
);
1784 TYPE_LENGTH (type
) = 0;
1785 TYPE_FIELDS (type
) = 0;
1786 TYPE_NFIELDS (type
) = 0;
1790 type
= coff_read_struct_type (cs
->c_symnum
,
1791 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1792 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1797 if (cs
->c_naux
!= 1)
1799 /* anonymous union type */
1800 type
= coff_alloc_type (cs
->c_symnum
);
1801 TYPE_NAME (type
) = NULL
;
1802 /* This used to set the tag to "<opaque>". But I think setting it
1803 to NULL is right, and the printing code can print it as
1805 TYPE_TAG_NAME (type
) = NULL
;
1806 INIT_CPLUS_SPECIFIC(type
);
1807 TYPE_LENGTH (type
) = 0;
1808 TYPE_FIELDS (type
) = 0;
1809 TYPE_NFIELDS (type
) = 0;
1813 type
= coff_read_struct_type (cs
->c_symnum
,
1814 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1815 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1817 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1821 if (cs
->c_naux
!= 1)
1823 /* anonymous enum type */
1824 type
= coff_alloc_type (cs
->c_symnum
);
1825 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1826 TYPE_NAME (type
) = NULL
;
1827 /* This used to set the tag to "<opaque>". But I think setting it
1828 to NULL is right, and the printing code can print it as
1830 TYPE_TAG_NAME (type
) = NULL
;
1831 TYPE_LENGTH (type
) = 0;
1832 TYPE_FIELDS (type
) = 0;
1833 TYPE_NFIELDS(type
) = 0;
1837 type
= coff_read_enum_type (cs
->c_symnum
,
1838 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1839 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1844 /* shouldn't show up here */
1848 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1851 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1854 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1857 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
1859 complain (&unexpected_type_complaint
, cs
->c_name
);
1860 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1863 /* This page contains subroutines of read_type. */
1865 /* Read the description of a structure (or union type)
1866 and return an object describing the type. */
1868 static struct type
*
1869 coff_read_struct_type (index
, length
, lastsym
)
1876 struct nextfield
*next
;
1880 register struct type
*type
;
1881 register struct nextfield
*list
= 0;
1882 struct nextfield
*new;
1886 struct coff_symbol member_sym
;
1887 register struct coff_symbol
*ms
= &member_sym
;
1888 struct internal_syment sub_sym
;
1889 union internal_auxent sub_aux
;
1892 type
= coff_alloc_type (index
);
1893 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1894 INIT_CPLUS_SPECIFIC(type
);
1895 TYPE_LENGTH (type
) = length
;
1897 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1899 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1901 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1903 switch (ms
->c_sclass
)
1908 /* Get space to record the next field's data. */
1909 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1913 /* Save the data. */
1914 list
->field
.name
= savestring (name
, strlen (name
));
1915 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1916 list
->field
.bitpos
= 8 * ms
->c_value
;
1917 list
->field
.bitsize
= 0;
1923 /* Get space to record the next field's data. */
1924 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1928 /* Save the data. */
1929 list
->field
.name
= savestring (name
, strlen (name
));
1930 list
->field
.type
= decode_type (ms
, ms
->c_type
, &sub_aux
);
1931 list
->field
.bitpos
= ms
->c_value
;
1932 list
->field
.bitsize
= sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
1941 /* Now create the vector of fields, and record how big it is. */
1943 TYPE_NFIELDS (type
) = nfields
;
1944 TYPE_FIELDS (type
) = (struct field
*)
1945 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1947 /* Copy the saved-up fields into the field vector. */
1949 for (n
= nfields
; list
; list
= list
->next
)
1950 TYPE_FIELD (type
, --n
) = list
->field
;
1955 /* Read a definition of an enumeration type,
1956 and create and return a suitable type object.
1957 Also defines the symbols that represent the values of the type. */
1960 static struct type
*
1961 coff_read_enum_type (index
, length
, lastsym
)
1966 register struct symbol
*sym
;
1967 register struct type
*type
;
1970 struct pending
**symlist
;
1971 struct coff_symbol member_sym
;
1972 register struct coff_symbol
*ms
= &member_sym
;
1973 struct internal_syment sub_sym
;
1974 union internal_auxent sub_aux
;
1975 struct pending
*osyms
, *syms
;
1980 type
= coff_alloc_type (index
);
1981 if (within_function
)
1982 symlist
= &local_symbols
;
1984 symlist
= &file_symbols
;
1986 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1988 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
1990 read_one_sym (ms
, &sub_sym
, &sub_aux
);
1992 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
1994 switch (ms
->c_sclass
)
1997 sym
= (struct symbol
*) xmalloc (sizeof (struct symbol
));
1998 memset (sym
, 0, sizeof (struct symbol
));
2000 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
2001 SYMBOL_CLASS (sym
) = LOC_CONST
;
2002 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2003 SYMBOL_VALUE (sym
) = ms
->c_value
;
2004 add_symbol_to_list (sym
, symlist
);
2009 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2010 up the count of how many symbols to read. So stop
2017 /* Now fill in the fields of the type-structure. */
2020 TYPE_LENGTH (type
) = length
;
2022 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
2023 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2024 TYPE_NFIELDS (type
) = nsyms
;
2025 TYPE_FIELDS (type
) = (struct field
*)
2026 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2028 /* Find the symbols for the values and put them into the type.
2029 The symbols can be found in the symlist that we put them on
2030 to cause them to be defined. osyms contains the old value
2031 of that symlist; everything up to there was defined by us. */
2032 /* Note that we preserve the order of the enum constants, so
2033 that in something like "enum {FOO, LAST_THING=FOO}" we print
2034 FOO, not LAST_THING. */
2036 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2041 for (; j
< syms
->nsyms
; j
++,n
++)
2043 struct symbol
*xsym
= syms
->symbol
[j
];
2044 SYMBOL_TYPE (xsym
) = type
;
2045 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2046 TYPE_FIELD_VALUE (type
, n
) = 0;
2047 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2048 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2057 struct section_offsets
*
2058 coff_symfile_offsets (objfile
, addr
)
2059 struct objfile
*objfile
;
2062 struct section_offsets
*section_offsets
;
2065 objfile
->num_sections
= SECT_OFF_MAX
;
2066 section_offsets
= (struct section_offsets
*)
2067 obstack_alloc (&objfile
-> psymbol_obstack
,
2068 sizeof (struct section_offsets
)
2069 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2071 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2072 ANOFFSET (section_offsets
, i
) = addr
;
2074 return section_offsets
;
2077 /* Register our ability to parse symbols for coff BFD files */
2079 static struct sym_fns coff_sym_fns
=
2081 bfd_target_coff_flavour
,
2082 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2083 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2084 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2085 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2086 coff_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2087 NULL
/* next: pointer to next struct sym_fns */
2091 _initialize_coffread ()
2093 add_symtab_fns(&coff_sym_fns
);