1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "breakpoint.h"
32 #include "gdb_string.h"
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"
46 extern void _initialize_coffread (void);
48 struct coff_symfile_info
50 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
51 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
53 CORE_ADDR textaddr
; /* Addr of .text section. */
54 unsigned int textsize
; /* Size of .text section. */
55 struct stab_section_list
*stabsects
; /* .stab sections. */
56 asection
*stabstrsect
; /* Section pointer for .stab section */
60 /* Translate an external name string into a user-visible name. */
61 #define EXTERNAL_NAME(string, abfd) \
62 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
64 /* To be an sdb debug type, type must have at least a basic or primary
65 derived type. Using this rather than checking against T_NULL is
66 said to prevent core dumps if we try to operate on Michael Bloom
69 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
71 /* Convert from an sdb register number to an internal gdb register number.
72 This should be defined in tm.h, if REGISTER_NAMES is not set up
73 to map one to one onto the sdb register numbers. */
75 #ifndef SDB_REG_TO_REGNUM
76 #define SDB_REG_TO_REGNUM(value) (value)
79 /* Core address of start and end of text of current source file.
80 This comes from a ".text" symbol where x_nlinno > 0. */
82 static CORE_ADDR current_source_start_addr
;
83 static CORE_ADDR current_source_end_addr
;
85 /* The addresses of the symbol table stream and number of symbols
86 of the object file we are reading (as copied into core). */
88 static bfd
*nlist_bfd_global
;
89 static int nlist_nsyms_global
;
92 /* Pointers to scratch storage, used for reading raw symbols and auxents. */
94 static char *temp_sym
;
95 static char *temp_aux
;
97 /* Local variables that hold the shift and mask values for the
98 COFF file that we are currently reading. These come back to us
99 from BFD, and are referenced by their macro names, as well as
100 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
101 macros from include/coff/internal.h . */
103 static unsigned local_n_btmask
;
104 static unsigned local_n_btshft
;
105 static unsigned local_n_tmask
;
106 static unsigned local_n_tshift
;
108 #define N_BTMASK local_n_btmask
109 #define N_BTSHFT local_n_btshft
110 #define N_TMASK local_n_tmask
111 #define N_TSHIFT local_n_tshift
113 /* Local variables that hold the sizes in the file of various COFF structures.
114 (We only need to know this to read them from the file -- BFD will then
115 translate the data in them, into `internal_xxx' structs in the right
116 byte order, alignment, etc.) */
118 static unsigned local_linesz
;
119 static unsigned local_symesz
;
120 static unsigned local_auxesz
;
122 /* This is set if this is a PE format file. */
126 /* Chain of typedefs of pointers to empty struct/union types.
127 They are chained thru the SYMBOL_VALUE_CHAIN. */
129 static struct symbol
*opaque_type_chain
[HASHSIZE
];
131 /* Complaints about various problems in the file being read */
133 struct complaint ef_complaint
=
134 {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
136 struct complaint ef_stack_complaint
=
137 {"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0};
139 struct complaint eb_stack_complaint
=
140 {"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0};
142 struct complaint bf_no_aux_complaint
=
143 {"`.bf' symbol %d has no aux entry", 0, 0};
145 struct complaint ef_no_aux_complaint
=
146 {"`.ef' symbol %d has no aux entry", 0, 0};
148 struct complaint lineno_complaint
=
149 {"Line number pointer %d lower than start of line numbers", 0, 0};
151 struct complaint unexpected_type_complaint
=
152 {"Unexpected type for symbol %s", 0, 0};
154 struct complaint bad_sclass_complaint
=
155 {"Bad n_sclass for symbol %s", 0, 0};
157 struct complaint misordered_blocks_complaint
=
158 {"Blocks out of order at address %x", 0, 0};
160 struct complaint tagndx_bad_complaint
=
161 {"Symbol table entry for %s has bad tagndx value", 0, 0};
163 struct complaint eb_complaint
=
164 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
166 /* Simplified internal version of coff symbol table information */
171 int c_symnum
; /* symbol number of this entry */
172 int c_naux
; /* 0 if syment only, 1 if syment + auxent, etc */
179 extern void stabsread_clear_cache (void);
181 static struct type
*coff_read_struct_type (int, int, int);
183 static struct type
*decode_base_type (struct coff_symbol
*,
184 unsigned int, union internal_auxent
*);
186 static struct type
*decode_type (struct coff_symbol
*, unsigned int,
187 union internal_auxent
*);
189 static struct type
*decode_function_type (struct coff_symbol
*,
191 union internal_auxent
*);
193 static struct type
*coff_read_enum_type (int, int, int);
195 static struct symbol
*process_coff_symbol (struct coff_symbol
*,
196 union internal_auxent
*,
199 static void patch_opaque_types (struct symtab
*);
201 static void patch_type (struct type
*, struct type
*);
203 static void enter_linenos (long, int, int, struct objfile
*);
205 static void free_linetab (void);
207 static void free_linetab_cleanup (void *ignore
);
209 static int init_lineno (bfd
*, long, int);
211 static char *getsymname (struct internal_syment
*);
213 static char *coff_getfilename (union internal_auxent
*);
215 static void free_stringtab (void);
217 static void free_stringtab_cleanup (void *ignore
);
219 static int init_stringtab (bfd
*, long);
221 static void read_one_sym (struct coff_symbol
*,
222 struct internal_syment
*, union internal_auxent
*);
224 static void coff_symtab_read (long, unsigned int, struct objfile
*);
226 static void find_linenos (bfd
*, sec_ptr
, PTR
);
228 static void coff_symfile_init (struct objfile
*);
230 static void coff_new_init (struct objfile
*);
232 static void coff_symfile_read (struct objfile
*, int);
234 static void coff_symfile_finish (struct objfile
*);
236 static void record_minimal_symbol (char *, CORE_ADDR
,
237 enum minimal_symbol_type
,
240 static void coff_end_symtab (struct objfile
*);
242 static void complete_symtab (char *, CORE_ADDR
, unsigned int);
244 static void coff_start_symtab (char *);
246 static struct type
*coff_alloc_type (int);
248 static struct type
**coff_lookup_type (int);
250 static void coff_locate_sections (bfd
*, asection
*, PTR
);
252 /* We are called once per section from coff_symfile_read. We
253 need to examine each section we are passed, check to see
254 if it is something we are interested in processing, and
255 if so, stash away some access information for the section.
257 FIXME: The section names should not be hardwired strings (what
258 should they be? I don't think most object file formats have enough
259 section flags to specify what kind of debug section it is
263 coff_locate_sections (abfd
, sectp
, csip
)
268 register struct coff_symfile_info
*csi
;
271 csi
= (struct coff_symfile_info
*) csip
;
272 name
= bfd_get_section_name (abfd
, sectp
);
273 if (STREQ (name
, ".text"))
275 csi
->textaddr
= bfd_section_vma (abfd
, sectp
);
276 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
278 else if (strncmp (name
, ".text", sizeof ".text" - 1) == 0)
280 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
282 else if (STREQ (name
, ".stabstr"))
284 csi
->stabstrsect
= sectp
;
286 else if (strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
290 /* We can have multiple .stab sections if linked with
292 for (s
= name
+ sizeof ".stab" - 1; *s
!= '\0'; s
++)
297 struct stab_section_list
*n
, **pn
;
299 n
= ((struct stab_section_list
*)
300 xmalloc (sizeof (struct stab_section_list
)));
303 for (pn
= &csi
->stabsects
; *pn
!= NULL
; pn
= &(*pn
)->next
)
307 /* This will be run after coffstab_build_psymtabs is called
308 in coff_symfile_read, at which point we no longer need
310 make_cleanup (free
, n
);
315 /* Return the section_offsets* that CS points to. */
316 static int cs_to_section (struct coff_symbol
*, struct objfile
*);
318 struct find_targ_sec_arg
324 static void find_targ_sec (bfd
*, asection
*, void *);
327 find_targ_sec (abfd
, sect
, obj
)
332 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
333 if (sect
->target_index
== args
->targ_index
)
334 *args
->resultp
= sect
;
337 /* Return the section number (SECT_OFF_*) that CS points to. */
339 cs_to_section (cs
, objfile
)
340 struct coff_symbol
*cs
;
341 struct objfile
*objfile
;
343 asection
*sect
= NULL
;
344 struct find_targ_sec_arg args
;
345 int off
= SECT_OFF_TEXT (objfile
);
347 args
.targ_index
= cs
->c_secnum
;
348 args
.resultp
= §
;
349 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
352 /* This is the section. Figure out what SECT_OFF_* code it is. */
353 if (bfd_get_section_flags (abfd
, sect
) & SEC_CODE
)
354 off
= SECT_OFF_TEXT (objfile
);
355 else if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
356 off
= SECT_OFF_DATA (objfile
);
358 off
= SECT_OFF_BSS (objfile
);
363 /* Return the address of the section of a COFF symbol. */
365 static CORE_ADDR
cs_section_address (struct coff_symbol
*, bfd
*);
368 cs_section_address (cs
, abfd
)
369 struct coff_symbol
*cs
;
372 asection
*sect
= NULL
;
373 struct find_targ_sec_arg args
;
376 args
.targ_index
= cs
->c_secnum
;
377 args
.resultp
= §
;
378 bfd_map_over_sections (abfd
, find_targ_sec
, &args
);
380 addr
= bfd_get_section_vma (objfile
->obfd
, sect
);
384 /* Look up a coff type-number index. Return the address of the slot
385 where the type for that index is stored.
386 The type-number is in INDEX.
388 This can be used for finding the type associated with that index
389 or for associating a new type with the index. */
391 static struct type
**
392 coff_lookup_type (index
)
395 if (index
>= type_vector_length
)
397 int old_vector_length
= type_vector_length
;
399 type_vector_length
*= 2;
400 if (index
/* is still */ >= type_vector_length
)
401 type_vector_length
= index
* 2;
403 type_vector
= (struct type
**)
404 xrealloc ((char *) type_vector
,
405 type_vector_length
* sizeof (struct type
*));
406 memset (&type_vector
[old_vector_length
], 0,
407 (type_vector_length
- old_vector_length
) * sizeof (struct type
*));
409 return &type_vector
[index
];
412 /* Make sure there is a type allocated for type number index
413 and return the type object.
414 This can create an empty (zeroed) type object. */
417 coff_alloc_type (index
)
420 register struct type
**type_addr
= coff_lookup_type (index
);
421 register struct type
*type
= *type_addr
;
423 /* If we are referring to a type not known at all yet,
424 allocate an empty type for it.
425 We will fill it in later if we find out how. */
428 type
= alloc_type (current_objfile
);
434 /* Start a new symtab for a new source file.
435 This is called when a COFF ".file" symbol is seen;
436 it indicates the start of data for one original source file. */
439 coff_start_symtab (name
)
443 /* We fill in the filename later. start_symtab puts
444 this pointer into last_source_file and we put it in
445 subfiles->name, which end_symtab frees; that's why
446 it must be malloc'd. */
447 savestring (name
, strlen (name
)),
448 /* We never know the directory name for COFF. */
450 /* The start address is irrelevant, since we set
451 last_source_start_addr in coff_end_symtab. */
453 record_debugformat ("COFF");
456 /* Save the vital information from when starting to read a file,
457 for use when closing off the current file.
458 NAME is the file name the symbols came from, START_ADDR is the first
459 text address for the file, and SIZE is the number of bytes of text. */
462 complete_symtab (name
, start_addr
, size
)
464 CORE_ADDR start_addr
;
467 if (last_source_file
!= NULL
)
468 free (last_source_file
);
469 last_source_file
= savestring (name
, strlen (name
));
470 current_source_start_addr
= start_addr
;
471 current_source_end_addr
= start_addr
+ size
;
473 if (current_objfile
->ei
.entry_point
>= current_source_start_addr
&&
474 current_objfile
->ei
.entry_point
< current_source_end_addr
)
476 current_objfile
->ei
.entry_file_lowpc
= current_source_start_addr
;
477 current_objfile
->ei
.entry_file_highpc
= current_source_end_addr
;
481 /* Finish the symbol definitions for one main source file,
482 close off all the lexical contexts for that file
483 (creating struct block's for them), then make the
484 struct symtab for that file and put it in the list of all such. */
487 coff_end_symtab (objfile
)
488 struct objfile
*objfile
;
490 struct symtab
*symtab
;
492 last_source_start_addr
= current_source_start_addr
;
494 symtab
= end_symtab (current_source_end_addr
, objfile
, 0);
497 free_named_symtabs (symtab
->filename
);
499 /* Reinitialize for beginning of new file. */
500 last_source_file
= NULL
;
504 record_minimal_symbol (name
, address
, type
, objfile
)
507 enum minimal_symbol_type type
;
508 struct objfile
*objfile
;
510 /* We don't want TDESC entry points in the minimal symbol table */
514 prim_record_minimal_symbol (name
, address
, type
, objfile
);
517 /* coff_symfile_init ()
518 is the coff-specific initialization routine for reading symbols.
519 It is passed a struct objfile which contains, among other things,
520 the BFD for the file whose symbols are being read, and a slot for
521 a pointer to "private data" which we fill with cookies and other
522 treats for coff_symfile_read ().
524 We will only be called if this is a COFF or COFF-like file.
525 BFD handles figuring out the format of the file, and code in symtab.c
526 uses BFD's determination to vector to us.
528 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
531 coff_symfile_init (objfile
)
532 struct objfile
*objfile
;
534 /* Allocate struct to keep track of stab reading. */
535 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
536 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
538 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
540 /* Allocate struct to keep track of the symfile */
541 objfile
->sym_private
= xmmalloc (objfile
->md
,
542 sizeof (struct coff_symfile_info
));
544 memset (objfile
->sym_private
, 0, sizeof (struct coff_symfile_info
));
546 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
547 find this causes a significant slowdown in gdb then we could
548 set it in the debug symbol readers only when necessary. */
549 objfile
->flags
|= OBJF_REORDERED
;
551 init_entry_point_info (objfile
);
554 /* This function is called for every section; it finds the outer limits
555 of the line table (minimum and maximum file offset) so that the
556 mainline code can read the whole thing for efficiency. */
560 find_linenos (abfd
, asect
, vpinfo
)
565 struct coff_symfile_info
*info
;
567 file_ptr offset
, maxoff
;
569 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
570 count
= asect
->lineno_count
;
575 size
= count
* local_linesz
;
577 info
= (struct coff_symfile_info
*) vpinfo
;
578 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
579 offset
= asect
->line_filepos
;
582 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
583 info
->min_lineno_offset
= offset
;
585 maxoff
= offset
+ size
;
586 if (maxoff
> info
->max_lineno_offset
)
587 info
->max_lineno_offset
= maxoff
;
591 /* The BFD for this file -- only good while we're actively reading
592 symbols into a psymtab or a symtab. */
594 static bfd
*symfile_bfd
;
596 /* Read a symbol file, after initialization by coff_symfile_init. */
600 coff_symfile_read (objfile
, mainline
)
601 struct objfile
*objfile
;
604 struct coff_symfile_info
*info
;
605 struct dbx_symfile_info
*dbxinfo
;
606 bfd
*abfd
= objfile
->obfd
;
607 coff_data_type
*cdata
= coff_data (abfd
);
608 char *name
= bfd_get_filename (abfd
);
610 unsigned int num_symbols
;
612 int stringtab_offset
;
613 struct cleanup
*back_to
;
618 info
= (struct coff_symfile_info
*) objfile
->sym_private
;
619 dbxinfo
= objfile
->sym_stab_info
;
620 symfile_bfd
= abfd
; /* Kludge for swap routines */
622 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
623 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
624 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
625 stringtab_offset
= symtab_offset
+ /* String table file offset */
626 num_symbols
* cdata
->local_symesz
;
628 /* Set a few file-statics that give us specific information about
629 the particular COFF file format we're reading. */
630 local_n_btmask
= cdata
->local_n_btmask
;
631 local_n_btshft
= cdata
->local_n_btshft
;
632 local_n_tmask
= cdata
->local_n_tmask
;
633 local_n_tshift
= cdata
->local_n_tshift
;
634 local_linesz
= cdata
->local_linesz
;
635 local_symesz
= cdata
->local_symesz
;
636 local_auxesz
= cdata
->local_auxesz
;
638 /* Allocate space for raw symbol and aux entries, based on their
639 space requirements as reported by BFD. */
640 temp_sym
= (char *) xmalloc
641 (cdata
->local_symesz
+ cdata
->local_auxesz
);
642 temp_aux
= temp_sym
+ cdata
->local_symesz
;
643 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
645 /* We need to know whether this is a PE file, because in PE files,
646 unlike standard COFF files, symbol values are stored as offsets
647 from the section address, rather than as absolute addresses.
648 FIXME: We should use BFD to read the symbol table, and thus avoid
651 strncmp (bfd_get_target (objfile
->obfd
), "pe", 2) == 0
652 || strncmp (bfd_get_target (objfile
->obfd
), "epoc-pe", 7) == 0;
656 /* Read the line number table, all at once. */
657 info
->min_lineno_offset
= 0;
658 info
->max_lineno_offset
= 0;
659 bfd_map_over_sections (abfd
, find_linenos
, (PTR
) info
);
661 make_cleanup (free_linetab_cleanup
, 0 /*ignore*/);
662 val
= init_lineno (abfd
, info
->min_lineno_offset
,
663 info
->max_lineno_offset
- info
->min_lineno_offset
);
665 error ("\"%s\": error reading line numbers\n", name
);
667 /* Now read the string table, all at once. */
669 make_cleanup (free_stringtab_cleanup
, 0 /*ignore*/);
670 val
= init_stringtab (abfd
, stringtab_offset
);
672 error ("\"%s\": can't get string table", name
);
674 init_minimal_symbol_collection ();
675 make_cleanup_discard_minimal_symbols ();
677 /* Now that the executable file is positioned at symbol table,
678 process it and define symbols accordingly. */
680 coff_symtab_read ((long) symtab_offset
, num_symbols
, objfile
);
682 /* Sort symbols alphabetically within each block. */
687 for (s
= objfile
->symtabs
; s
!= NULL
; s
= s
->next
)
688 sort_symtab_syms (s
);
691 /* Install any minimal symbols that have been collected as the current
692 minimal symbols for this objfile. */
694 install_minimal_symbols (objfile
);
696 bfd_map_over_sections (abfd
, coff_locate_sections
, (PTR
) info
);
700 if (!info
->stabstrsect
)
705 ("The debugging information in `%s' is corrupted.\n"
706 "The file has a `.stabs' section, but no `.stabstr' section.\n"),
708 return_to_top_level (RETURN_ERROR
);
711 /* FIXME: dubious. Why can't we use something normal like
712 bfd_get_section_contents? */
713 bfd_seek (abfd
, abfd
->where
, 0);
715 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
717 coffstab_build_psymtabs (objfile
,
719 info
->textaddr
, info
->textsize
,
721 info
->stabstrsect
->filepos
, stabstrsize
);
724 do_cleanups (back_to
);
728 coff_new_init (ignore
)
729 struct objfile
*ignore
;
733 /* Perform any local cleanups required when we are done with a particular
734 objfile. I.E, we are in the process of discarding all symbol information
735 for an objfile, freeing up all memory held for it, and unlinking the
736 objfile struct from the global list of known objfiles. */
739 coff_symfile_finish (objfile
)
740 struct objfile
*objfile
;
742 if (objfile
->sym_private
!= NULL
)
744 mfree (objfile
->md
, objfile
->sym_private
);
747 /* Let stabs reader clean up */
748 stabsread_clear_cache ();
752 /* Given pointers to a symbol table in coff style exec file,
753 analyze them and create struct symtab's describing the symbols.
754 NSYMS is the number of symbols in the symbol table.
755 We read them one at a time using read_one_sym (). */
758 coff_symtab_read (symtab_offset
, nsyms
, objfile
)
761 struct objfile
*objfile
;
763 register struct context_stack
*new;
764 struct coff_symbol coff_symbol
;
765 register struct coff_symbol
*cs
= &coff_symbol
;
766 static struct internal_syment main_sym
;
767 static union internal_auxent main_aux
;
768 struct coff_symbol fcn_cs_saved
;
769 static struct internal_syment fcn_sym_saved
;
770 static union internal_auxent fcn_aux_saved
;
772 /* A .file is open. */
773 int in_source_file
= 0;
774 int next_file_symnum
= -1;
775 /* Name of the current file. */
776 char *filestring
= "";
778 int fcn_first_line
= 0;
779 CORE_ADDR fcn_first_line_addr
;
780 int fcn_last_line
= 0;
781 int fcn_start_addr
= 0;
782 long fcn_line_ptr
= 0;
786 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
787 it's hard to know I've really worked around it. The fix should be
788 harmless, anyway). The symptom of the bug is that the first
789 fread (in read_one_sym), will (in my example) actually get data
790 from file offset 268, when the fseek was to 264 (and ftell shows
791 264). This causes all hell to break loose. I was unable to
792 reproduce this on a short test program which operated on the same
793 file, performing (I think) the same sequence of operations.
795 It stopped happening when I put in this (former) rewind().
797 FIXME: Find out if this has been reported to Sun, whether it has
798 been fixed in a later release, etc. */
800 bfd_seek (objfile
->obfd
, 0, 0);
802 /* Position to read the symbol table. */
803 val
= bfd_seek (objfile
->obfd
, (long) symtab_offset
, 0);
805 perror_with_name (objfile
->name
);
807 current_objfile
= objfile
;
808 nlist_bfd_global
= objfile
->obfd
;
809 nlist_nsyms_global
= nsyms
;
810 last_source_file
= NULL
;
811 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
813 if (type_vector
) /* Get rid of previous one */
814 free ((PTR
) type_vector
);
815 type_vector_length
= 160;
816 type_vector
= (struct type
**)
817 xmalloc (type_vector_length
* sizeof (struct type
*));
818 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
820 coff_start_symtab ("");
823 while (symnum
< nsyms
)
825 QUIT
; /* Make this command interruptable. */
827 read_one_sym (cs
, &main_sym
, &main_aux
);
829 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
831 if (last_source_file
)
832 coff_end_symtab (objfile
);
834 coff_start_symtab ("_globals_");
835 complete_symtab ("_globals_", 0, 0);
836 /* done with all files, everything from here on out is globals */
839 /* Special case for file with type declarations only, no text. */
840 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
841 && cs
->c_secnum
== N_DEBUG
)
842 complete_symtab (filestring
, 0, 0);
844 /* Typedefs should not be treated as symbol definitions. */
845 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
847 /* Record all functions -- external and static -- in minsyms. */
848 tmpaddr
= cs
->c_value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
849 record_minimal_symbol (cs
->c_name
, tmpaddr
, mst_text
, objfile
);
851 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
852 fcn_start_addr
= tmpaddr
;
854 fcn_sym_saved
= main_sym
;
855 fcn_aux_saved
= main_aux
;
859 switch (cs
->c_sclass
)
868 complain (&bad_sclass_complaint
, cs
->c_name
);
872 /* c_value field contains symnum of next .file entry in table
873 or symnum of first global after last .file. */
874 next_file_symnum
= cs
->c_value
;
876 filestring
= coff_getfilename (&main_aux
);
880 /* Complete symbol table for last object file
881 containing debugging information. */
882 if (last_source_file
)
884 coff_end_symtab (objfile
);
885 coff_start_symtab (filestring
);
890 /* C_LABEL is used for labels and static functions. Including
891 it here allows gdb to see static functions when no debug
892 info is available. */
894 /* However, labels within a function can make weird backtraces,
895 so filter them out (from phdm@macqel.be). */
901 case C_THUMBSTATFUNC
:
902 if (cs
->c_name
[0] == '.')
904 if (STREQ (cs
->c_name
, ".text"))
906 /* FIXME: don't wire in ".text" as section name
908 /* Check for in_source_file deals with case of
909 a file with debugging symbols
910 followed by a later file with no symbols. */
912 complete_symtab (filestring
,
913 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)),
914 main_aux
.x_scn
.x_scnlen
);
917 /* flush rest of '.' symbols */
920 else if (!SDB_TYPE (cs
->c_type
)
921 && cs
->c_name
[0] == 'L'
922 && (strncmp (cs
->c_name
, "LI%", 3) == 0
923 || strncmp (cs
->c_name
, "LF%", 3) == 0
924 || strncmp (cs
->c_name
, "LC%", 3) == 0
925 || strncmp (cs
->c_name
, "LP%", 3) == 0
926 || strncmp (cs
->c_name
, "LPB%", 4) == 0
927 || strncmp (cs
->c_name
, "LBB%", 4) == 0
928 || strncmp (cs
->c_name
, "LBE%", 4) == 0
929 || strncmp (cs
->c_name
, "LPBX%", 5) == 0))
930 /* At least on a 3b1, gcc generates swbeg and string labels
931 that look like this. Ignore them. */
933 /* fall in for static symbols that don't start with '.' */
938 /* Record it in the minimal symbols regardless of
939 SDB_TYPE. This parallels what we do for other debug
940 formats, and probably is needed to make
941 print_address_symbolic work right without the (now
942 gone) "set fast-symbolic-addr off" kludge. */
944 /* FIXME: should use mst_abs, and not relocate, if absolute. */
945 enum minimal_symbol_type ms_type
;
948 if (cs
->c_secnum
== N_UNDEF
)
950 /* This is a common symbol. See if the target
951 environment knows where it has been relocated to. */
953 if (target_lookup_symbol (cs
->c_name
, &reladdr
))
955 /* Error in lookup; ignore symbol. */
959 /* The address has already been relocated; make sure that
960 objfile_relocate doesn't relocate it again. */
962 ms_type
= cs
->c_sclass
== C_EXT
963 || cs
->c_sclass
== C_THUMBEXT
?
964 mst_bss
: mst_file_bss
;
968 sec
= cs_to_section (cs
, objfile
);
969 tmpaddr
= cs
->c_value
;
970 if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
971 || cs
->c_sclass
== C_THUMBEXT
)
972 tmpaddr
+= ANOFFSET (objfile
->section_offsets
, sec
);
974 if (sec
== SECT_OFF_TEXT (objfile
))
977 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
978 || cs
->c_sclass
== C_THUMBEXT
?
979 mst_text
: mst_file_text
;
980 #ifdef SMASH_TEXT_ADDRESS
981 if (tmpaddr
& 1) /* FIXME: delete this line */
982 SMASH_TEXT_ADDRESS (tmpaddr
);
985 else if (sec
== SECT_OFF_DATA (objfile
))
988 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
?
989 mst_data
: mst_file_data
;
991 else if (sec
== SECT_OFF_BSS (objfile
))
994 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
?
995 mst_data
: mst_file_data
;
998 ms_type
= mst_unknown
;
1001 if (cs
->c_name
[0] != '@' /* Skip tdesc symbols */ )
1003 struct minimal_symbol
*msym
;
1005 msym
= prim_record_minimal_symbol_and_info
1006 (cs
->c_name
, tmpaddr
, ms_type
, (char *) cs
->c_sclass
, sec
,
1008 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1010 COFF_MAKE_MSYMBOL_SPECIAL (cs
->c_sclass
, msym
);
1013 if (SDB_TYPE (cs
->c_type
))
1016 sym
= process_coff_symbol
1017 (cs
, &main_aux
, objfile
);
1018 SYMBOL_VALUE (sym
) = tmpaddr
;
1019 SYMBOL_SECTION (sym
) = sec
;
1025 if (STREQ (cs
->c_name
, ".bf"))
1027 within_function
= 1;
1029 /* value contains address of first non-init type code */
1030 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1031 contains line number of '{' } */
1032 if (cs
->c_naux
!= 1)
1033 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
1034 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1035 fcn_first_line_addr
= cs
->c_value
;
1037 /* Might want to check that locals are 0 and
1038 context_stack_depth is zero, and complain if not. */
1041 new = push_context (depth
, fcn_start_addr
);
1042 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1044 process_coff_symbol (&fcn_cs_saved
, &fcn_aux_saved
, objfile
);
1046 else if (STREQ (cs
->c_name
, ".ef"))
1048 /* the value of .ef is the address of epilogue code;
1049 not useful for gdb. */
1050 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1051 contains number of lines to '}' */
1053 if (context_stack_depth
<= 0)
1054 { /* We attempted to pop an empty context stack */
1055 complain (&ef_stack_complaint
, cs
->c_symnum
);
1056 within_function
= 0;
1060 new = pop_context ();
1061 /* Stack must be empty now. */
1062 if (context_stack_depth
> 0 || new == NULL
)
1064 complain (&ef_complaint
, cs
->c_symnum
);
1065 within_function
= 0;
1068 if (cs
->c_naux
!= 1)
1070 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
1071 fcn_last_line
= 0x7FFFFFFF;
1075 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1077 /* fcn_first_line is the line number of the opening '{'.
1078 Do not record it - because it would affect gdb's idea
1079 of the line number of the first statement of the function -
1080 except for one-line functions, for which it is also the line
1081 number of all the statements and of the closing '}', and
1082 for which we do not have any other statement-line-number. */
1083 if (fcn_last_line
== 1)
1084 record_line (current_subfile
, fcn_first_line
,
1085 fcn_first_line_addr
);
1087 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
,
1090 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1092 #if defined (FUNCTION_EPILOGUE_SIZE)
1093 /* This macro should be defined only on
1095 fcn_aux_saved.x_sym.x_misc.x_fsize
1096 field is always zero.
1097 So use the .bf record information that
1098 points to the epilogue and add the size
1101 + FUNCTION_EPILOGUE_SIZE
1102 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)),
1104 fcn_cs_saved
.c_value
1105 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1106 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)),
1110 within_function
= 0;
1115 if (STREQ (cs
->c_name
, ".bb"))
1117 tmpaddr
= cs
->c_value
;
1118 tmpaddr
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1119 push_context (++depth
, tmpaddr
);
1121 else if (STREQ (cs
->c_name
, ".eb"))
1123 if (context_stack_depth
<= 0)
1124 { /* We attempted to pop an empty context stack */
1125 complain (&eb_stack_complaint
, cs
->c_symnum
);
1129 new = pop_context ();
1130 if (depth
-- != new->depth
)
1132 complain (&eb_complaint
, symnum
);
1135 if (local_symbols
&& context_stack_depth
> 0)
1138 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1139 /* Make a block for the local symbols within. */
1140 finish_block (0, &local_symbols
, new->old_blocks
,
1141 new->start_addr
, tmpaddr
, objfile
);
1143 /* Now pop locals of block just finished. */
1144 local_symbols
= new->locals
;
1149 process_coff_symbol (cs
, &main_aux
, objfile
);
1154 if (last_source_file
)
1155 coff_end_symtab (objfile
);
1157 /* Patch up any opaque types (references to types that are not defined
1158 in the file where they are referenced, e.g. "struct foo *bar"). */
1159 ALL_OBJFILE_SYMTABS (objfile
, s
)
1160 patch_opaque_types (s
);
1162 current_objfile
= NULL
;
1165 /* Routines for reading headers and symbols from executable. */
1167 /* Read the next symbol, swap it, and return it in both internal_syment
1168 form, and coff_symbol form. Also return its first auxent, if any,
1169 in internal_auxent form, and skip any other auxents. */
1172 read_one_sym (cs
, sym
, aux
)
1173 register struct coff_symbol
*cs
;
1174 register struct internal_syment
*sym
;
1175 register union internal_auxent
*aux
;
1179 cs
->c_symnum
= symnum
;
1180 bfd_read (temp_sym
, local_symesz
, 1, nlist_bfd_global
);
1181 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1182 cs
->c_naux
= sym
->n_numaux
& 0xff;
1183 if (cs
->c_naux
>= 1)
1185 bfd_read (temp_aux
, local_auxesz
, 1, nlist_bfd_global
);
1186 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1187 0, cs
->c_naux
, (char *) aux
);
1188 /* If more than one aux entry, read past it (only the first aux
1190 for (i
= 1; i
< cs
->c_naux
; i
++)
1191 bfd_read (temp_aux
, local_auxesz
, 1, nlist_bfd_global
);
1193 cs
->c_name
= getsymname (sym
);
1194 cs
->c_value
= sym
->n_value
;
1195 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1196 cs
->c_secnum
= sym
->n_scnum
;
1197 cs
->c_type
= (unsigned) sym
->n_type
;
1198 if (!SDB_TYPE (cs
->c_type
))
1202 if (cs
->c_sclass
& 128)
1203 printf ("thumb symbol %s, class 0x%x\n", cs
->c_name
, cs
->c_sclass
);
1206 symnum
+= 1 + cs
->c_naux
;
1208 /* The PE file format stores symbol values as offsets within the
1209 section, rather than as absolute addresses. We correct that
1210 here, if the symbol has an appropriate storage class. FIXME: We
1211 should use BFD to read the symbols, rather than duplicating the
1215 switch (cs
->c_sclass
)
1219 case C_THUMBEXTFUNC
:
1224 case C_THUMBSTATFUNC
:
1230 if (cs
->c_secnum
!= 0)
1231 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1237 /* Support for string table handling */
1239 static char *stringtab
= NULL
;
1242 init_stringtab (abfd
, offset
)
1248 unsigned char lengthbuf
[4];
1252 /* If the file is stripped, the offset might be zero, indicating no
1253 string table. Just return with `stringtab' set to null. */
1257 if (bfd_seek (abfd
, offset
, 0) < 0)
1260 val
= bfd_read ((char *) lengthbuf
, sizeof lengthbuf
, 1, abfd
);
1261 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1263 /* If no string table is needed, then the file may end immediately
1264 after the symbols. Just return with `stringtab' set to null. */
1265 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1268 stringtab
= (char *) xmalloc (length
);
1269 /* This is in target format (probably not very useful, and not currently
1270 used), not host format. */
1271 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1272 if (length
== sizeof length
) /* Empty table -- just the count */
1275 val
= bfd_read (stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
, 1, abfd
);
1276 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1291 free_stringtab_cleanup (void *ignore
)
1297 getsymname (symbol_entry
)
1298 struct internal_syment
*symbol_entry
;
1300 static char buffer
[SYMNMLEN
+ 1];
1303 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1305 /* FIXME: Probably should be detecting corrupt symbol files by
1306 seeing whether offset points to within the stringtab. */
1307 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1311 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1312 buffer
[SYMNMLEN
] = '\0';
1318 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1319 only the last component of the name. Result is in static storage and
1320 is only good for temporary use. */
1323 coff_getfilename (aux_entry
)
1324 union internal_auxent
*aux_entry
;
1326 static char buffer
[BUFSIZ
];
1327 register char *temp
;
1330 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1331 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1334 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1335 buffer
[FILNMLEN
] = '\0';
1339 /* FIXME: We should not be throwing away the information about what
1340 directory. It should go into dirname of the symtab, or some such
1342 if ((temp
= strrchr (result
, '/')) != NULL
)
1347 /* Support for line number handling. */
1349 static char *linetab
= NULL
;
1350 static long linetab_offset
;
1351 static unsigned long linetab_size
;
1353 /* Read in all the line numbers for fast lookups later. Leave them in
1354 external (unswapped) format in memory; we'll swap them as we enter
1355 them into GDB's data structures. */
1358 init_lineno (abfd
, offset
, size
)
1365 linetab_offset
= offset
;
1366 linetab_size
= size
;
1373 if (bfd_seek (abfd
, offset
, 0) < 0)
1376 /* Allocate the desired table, plus a sentinel */
1377 linetab
= (char *) xmalloc (size
+ local_linesz
);
1379 val
= bfd_read (linetab
, size
, 1, abfd
);
1383 /* Terminate it with an all-zero sentinel record */
1384 memset (linetab
+ size
, 0, local_linesz
);
1398 free_linetab_cleanup (void *ignore
)
1403 #if !defined (L_LNNO32)
1404 #define L_LNNO32(lp) ((lp)->l_lnno)
1408 enter_linenos (file_offset
, first_line
, last_line
, objfile
)
1410 register int first_line
;
1411 register int last_line
;
1412 struct objfile
*objfile
;
1414 register char *rawptr
;
1415 struct internal_lineno lptr
;
1419 if (file_offset
< linetab_offset
)
1421 complain (&lineno_complaint
, file_offset
);
1422 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1424 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1427 rawptr
= &linetab
[file_offset
- linetab_offset
];
1429 /* skip first line entry for each function */
1430 rawptr
+= local_linesz
;
1431 /* line numbers start at one for the first line of the function */
1436 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1437 rawptr
+= local_linesz
;
1438 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1439 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1440 record_line (current_subfile
, first_line
+ L_LNNO32 (&lptr
),
1442 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)));
1449 patch_type (type
, real_type
)
1451 struct type
*real_type
;
1453 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1454 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1455 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1457 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1458 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1459 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1461 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1463 if (TYPE_NAME (real_target
))
1465 if (TYPE_NAME (target
))
1466 free (TYPE_NAME (target
));
1467 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1471 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1472 so that they can be used to print out opaque data structures properly. */
1475 patch_opaque_types (s
)
1478 register struct block
*b
;
1480 register struct symbol
*real_sym
;
1482 /* Go through the per-file symbols only */
1483 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1484 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1486 /* Find completed typedefs to use to fix opaque ones.
1487 Remove syms from the chain when their types are stored,
1488 but search the whole chain, as there may be several syms
1489 from different files with the same name. */
1490 real_sym
= BLOCK_SYM (b
, i
);
1491 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1492 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1493 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1494 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1496 register char *name
= SYMBOL_NAME (real_sym
);
1497 register int hash
= hashname (name
);
1498 register struct symbol
*sym
, *prev
;
1501 for (sym
= opaque_type_chain
[hash
]; sym
;)
1503 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1504 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1508 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1512 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1515 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1519 sym
= SYMBOL_VALUE_CHAIN (prev
);
1523 sym
= opaque_type_chain
[hash
];
1529 sym
= SYMBOL_VALUE_CHAIN (sym
);
1536 static struct symbol
*
1537 process_coff_symbol (cs
, aux
, objfile
)
1538 register struct coff_symbol
*cs
;
1539 register union internal_auxent
*aux
;
1540 struct objfile
*objfile
;
1542 register struct symbol
*sym
1543 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1544 sizeof (struct symbol
));
1547 memset (sym
, 0, sizeof (struct symbol
));
1549 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1550 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
1551 &objfile
->symbol_obstack
);
1552 SYMBOL_LANGUAGE (sym
) = language_auto
;
1553 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1555 /* default assumptions */
1556 SYMBOL_VALUE (sym
) = cs
->c_value
;
1557 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1558 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1560 if (ISFCN (cs
->c_type
))
1562 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1564 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1566 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1567 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1568 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1569 add_symbol_to_list (sym
, &file_symbols
);
1570 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1571 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1572 add_symbol_to_list (sym
, &global_symbols
);
1576 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1577 switch (cs
->c_sclass
)
1583 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1584 add_symbol_to_list (sym
, &local_symbols
);
1588 case C_THUMBEXTFUNC
:
1590 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1591 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1592 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1593 add_symbol_to_list (sym
, &global_symbols
);
1597 case C_THUMBSTATFUNC
:
1599 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1600 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1601 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1602 if (within_function
)
1604 /* Static symbol of local scope */
1605 add_symbol_to_list (sym
, &local_symbols
);
1609 /* Static symbol at top level of file */
1610 add_symbol_to_list (sym
, &file_symbols
);
1614 #ifdef C_GLBLREG /* AMD coff */
1618 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1619 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM (cs
->c_value
);
1620 add_symbol_to_list (sym
, &local_symbols
);
1628 SYMBOL_CLASS (sym
) = LOC_ARG
;
1629 add_symbol_to_list (sym
, &local_symbols
);
1630 #if !defined (BELIEVE_PCC_PROMOTION)
1631 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1633 /* If PCC says a parameter is a short or a char,
1634 aligned on an int boundary, realign it to the
1635 "little end" of the int. */
1636 struct type
*temptype
;
1637 temptype
= lookup_fundamental_type (current_objfile
,
1639 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1640 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1641 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1643 SYMBOL_VALUE (sym
) +=
1644 TYPE_LENGTH (temptype
)
1645 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1652 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1653 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM (cs
->c_value
);
1654 add_symbol_to_list (sym
, &local_symbols
);
1655 #if !defined (BELIEVE_PCC_PROMOTION)
1656 /* FIXME: This should retain the current type, since it's just
1657 a register value. gnu@adobe, 26Feb93 */
1659 /* If PCC says a parameter is a short or a char,
1660 it is really an int. */
1661 struct type
*temptype
;
1663 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1664 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1665 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1668 (TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1669 ? lookup_fundamental_type (current_objfile
,
1670 FT_UNSIGNED_INTEGER
)
1678 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1679 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1681 /* If type has no name, give it one */
1682 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1684 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1685 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1687 /* If we are giving a name to a type such as "pointer to
1688 foo" or "function returning foo", we better not set
1689 the TYPE_NAME. If the program contains "typedef char
1690 *caddr_t;", we don't want all variables of type char
1691 * to print as caddr_t. This is not just a
1692 consequence of GDB's type management; CC and GCC (at
1693 least through version 2.4) both output variables of
1694 either type char * or caddr_t with the type
1695 refering to the C_TPDEF symbol for caddr_t. If a future
1696 compiler cleans this up it GDB is not ready for it
1697 yet, but if it becomes ready we somehow need to
1698 disable this check (without breaking the PCC/GCC2.4
1703 Fortunately, this check seems not to be necessary
1704 for anything except pointers or functions. */
1708 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1709 concat (SYMBOL_NAME (sym
), NULL
);
1712 /* Ignore vendor section for Harris CX/UX targets. */
1713 else if (cs
->c_name
[0] == '$')
1715 #endif /* CXUX_TARGET */
1717 /* Keep track of any type which points to empty structured type,
1718 so it can be filled from a definition from another file. A
1719 simple forward reference (TYPE_CODE_UNDEF) is not an
1720 empty structured type, though; the forward references
1721 work themselves out via the magic of coff_lookup_type. */
1722 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1723 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1724 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1727 register int i
= hashname (SYMBOL_NAME (sym
));
1729 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1730 opaque_type_chain
[i
] = sym
;
1732 add_symbol_to_list (sym
, &file_symbols
);
1738 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1739 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1741 /* Some compilers try to be helpful by inventing "fake"
1742 names for anonymous enums, structures, and unions, like
1743 "~0fake" or ".0fake". Thanks, but no thanks... */
1744 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1745 if (SYMBOL_NAME (sym
) != NULL
1746 && *SYMBOL_NAME (sym
) != '~'
1747 && *SYMBOL_NAME (sym
) != '.')
1748 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1749 concat (SYMBOL_NAME (sym
), NULL
);
1751 add_symbol_to_list (sym
, &file_symbols
);
1761 /* Decode a coff type specifier; return the type that is meant. */
1763 static struct type
*
1764 decode_type (cs
, c_type
, aux
)
1765 register struct coff_symbol
*cs
;
1766 unsigned int c_type
;
1767 register union internal_auxent
*aux
;
1769 register struct type
*type
= 0;
1770 unsigned int new_c_type
;
1772 if (c_type
& ~N_BTMASK
)
1774 new_c_type
= DECREF (c_type
);
1777 type
= decode_type (cs
, new_c_type
, aux
);
1778 type
= lookup_pointer_type (type
);
1780 else if (ISFCN (c_type
))
1782 type
= decode_type (cs
, new_c_type
, aux
);
1783 type
= lookup_function_type (type
);
1785 else if (ISARY (c_type
))
1788 register unsigned short *dim
;
1789 struct type
*base_type
, *index_type
, *range_type
;
1791 /* Define an array type. */
1792 /* auxent refers to array, not base type */
1793 if (aux
->x_sym
.x_tagndx
.l
== 0)
1796 /* shift the indices down */
1797 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1800 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1804 base_type
= decode_type (cs
, new_c_type
, aux
);
1805 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1807 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1809 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1814 /* Reference to existing type. This only occurs with the
1815 struct, union, and enum types. EPI a29k coff
1816 fakes us out by producing aux entries with a nonzero
1817 x_tagndx for definitions of structs, unions, and enums, so we
1818 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1819 with pointers to pointers to defined structs, and generates
1820 negative x_tagndx fields. */
1821 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1823 if (cs
->c_sclass
!= C_STRTAG
1824 && cs
->c_sclass
!= C_UNTAG
1825 && cs
->c_sclass
!= C_ENTAG
1826 && aux
->x_sym
.x_tagndx
.l
>= 0)
1828 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1833 complain (&tagndx_bad_complaint
, cs
->c_name
);
1834 /* And fall through to decode_base_type... */
1838 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1841 /* Decode a coff type specifier for function definition;
1842 return the type that the function returns. */
1844 static struct type
*
1845 decode_function_type (cs
, c_type
, aux
)
1846 register struct coff_symbol
*cs
;
1847 unsigned int c_type
;
1848 register union internal_auxent
*aux
;
1850 if (aux
->x_sym
.x_tagndx
.l
== 0)
1851 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1853 return decode_type (cs
, DECREF (c_type
), aux
);
1858 static struct type
*
1859 decode_base_type (cs
, c_type
, aux
)
1860 register struct coff_symbol
*cs
;
1861 unsigned int c_type
;
1862 register union internal_auxent
*aux
;
1869 /* shows up with "void (*foo)();" structure members */
1870 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1873 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1876 /* Shows up in DGUX, I think. Not sure where. */
1877 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1883 /* Intel 960 COFF has this symbol and meaning. */
1884 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1888 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1891 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1894 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1897 if (cs
->c_sclass
== C_FIELD
1898 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
> TARGET_LONG_BIT
)
1899 return lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
1901 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1904 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1907 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1910 return lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
1913 if (cs
->c_naux
!= 1)
1915 /* anonymous structure type */
1916 type
= coff_alloc_type (cs
->c_symnum
);
1917 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1918 TYPE_NAME (type
) = NULL
;
1919 /* This used to set the tag to "<opaque>". But I think setting it
1920 to NULL is right, and the printing code can print it as
1922 TYPE_TAG_NAME (type
) = NULL
;
1923 INIT_CPLUS_SPECIFIC (type
);
1924 TYPE_LENGTH (type
) = 0;
1925 TYPE_FIELDS (type
) = 0;
1926 TYPE_NFIELDS (type
) = 0;
1930 type
= coff_read_struct_type (cs
->c_symnum
,
1931 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1932 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1937 if (cs
->c_naux
!= 1)
1939 /* anonymous union type */
1940 type
= coff_alloc_type (cs
->c_symnum
);
1941 TYPE_NAME (type
) = NULL
;
1942 /* This used to set the tag to "<opaque>". But I think setting it
1943 to NULL is right, and the printing code can print it as
1945 TYPE_TAG_NAME (type
) = NULL
;
1946 INIT_CPLUS_SPECIFIC (type
);
1947 TYPE_LENGTH (type
) = 0;
1948 TYPE_FIELDS (type
) = 0;
1949 TYPE_NFIELDS (type
) = 0;
1953 type
= coff_read_struct_type (cs
->c_symnum
,
1954 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1955 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1957 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1961 if (cs
->c_naux
!= 1)
1963 /* anonymous enum type */
1964 type
= coff_alloc_type (cs
->c_symnum
);
1965 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1966 TYPE_NAME (type
) = NULL
;
1967 /* This used to set the tag to "<opaque>". But I think setting it
1968 to NULL is right, and the printing code can print it as
1970 TYPE_TAG_NAME (type
) = NULL
;
1971 TYPE_LENGTH (type
) = 0;
1972 TYPE_FIELDS (type
) = 0;
1973 TYPE_NFIELDS (type
) = 0;
1977 type
= coff_read_enum_type (cs
->c_symnum
,
1978 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1979 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1984 /* shouldn't show up here */
1988 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1991 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1994 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1997 if (cs
->c_sclass
== C_FIELD
1998 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
> TARGET_LONG_BIT
)
1999 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
2001 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2003 complain (&unexpected_type_complaint
, cs
->c_name
);
2004 return lookup_fundamental_type (current_objfile
, FT_VOID
);
2007 /* This page contains subroutines of read_type. */
2009 /* Read the description of a structure (or union type) and return an
2010 object describing the type. */
2012 static struct type
*
2013 coff_read_struct_type (index
, length
, lastsym
)
2020 struct nextfield
*next
;
2024 register struct type
*type
;
2025 register struct nextfield
*list
= 0;
2026 struct nextfield
*new;
2030 struct coff_symbol member_sym
;
2031 register struct coff_symbol
*ms
= &member_sym
;
2032 struct internal_syment sub_sym
;
2033 union internal_auxent sub_aux
;
2036 type
= coff_alloc_type (index
);
2037 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2038 INIT_CPLUS_SPECIFIC (type
);
2039 TYPE_LENGTH (type
) = length
;
2041 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2043 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2045 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2047 switch (ms
->c_sclass
)
2052 /* Get space to record the next field's data. */
2053 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2057 /* Save the data. */
2061 ¤t_objfile
->symbol_obstack
);
2062 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
, &sub_aux
);
2063 FIELD_BITPOS (list
->field
) = 8 * ms
->c_value
;
2064 FIELD_BITSIZE (list
->field
) = 0;
2070 /* Get space to record the next field's data. */
2071 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2075 /* Save the data. */
2079 ¤t_objfile
->symbol_obstack
);
2080 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
, &sub_aux
);
2081 FIELD_BITPOS (list
->field
) = ms
->c_value
;
2082 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2091 /* Now create the vector of fields, and record how big it is. */
2093 TYPE_NFIELDS (type
) = nfields
;
2094 TYPE_FIELDS (type
) = (struct field
*)
2095 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2097 /* Copy the saved-up fields into the field vector. */
2099 for (n
= nfields
; list
; list
= list
->next
)
2100 TYPE_FIELD (type
, --n
) = list
->field
;
2105 /* Read a definition of an enumeration type,
2106 and create and return a suitable type object.
2107 Also defines the symbols that represent the values of the type. */
2110 static struct type
*
2111 coff_read_enum_type (index
, length
, lastsym
)
2116 register struct symbol
*sym
;
2117 register struct type
*type
;
2120 struct pending
**symlist
;
2121 struct coff_symbol member_sym
;
2122 register struct coff_symbol
*ms
= &member_sym
;
2123 struct internal_syment sub_sym
;
2124 union internal_auxent sub_aux
;
2125 struct pending
*osyms
, *syms
;
2129 int unsigned_enum
= 1;
2131 type
= coff_alloc_type (index
);
2132 if (within_function
)
2133 symlist
= &local_symbols
;
2135 symlist
= &file_symbols
;
2137 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2139 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2141 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2143 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2145 switch (ms
->c_sclass
)
2148 sym
= (struct symbol
*) obstack_alloc
2149 (¤t_objfile
->symbol_obstack
,
2150 sizeof (struct symbol
));
2151 memset (sym
, 0, sizeof (struct symbol
));
2154 obsavestring (name
, strlen (name
),
2155 ¤t_objfile
->symbol_obstack
);
2156 SYMBOL_CLASS (sym
) = LOC_CONST
;
2157 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2158 SYMBOL_VALUE (sym
) = ms
->c_value
;
2159 add_symbol_to_list (sym
, symlist
);
2164 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2165 up the count of how many symbols to read. So stop
2172 /* Now fill in the fields of the type-structure. */
2175 TYPE_LENGTH (type
) = length
;
2177 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
2178 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2179 TYPE_NFIELDS (type
) = nsyms
;
2180 TYPE_FIELDS (type
) = (struct field
*)
2181 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2183 /* Find the symbols for the values and put them into the type.
2184 The symbols can be found in the symlist that we put them on
2185 to cause them to be defined. osyms contains the old value
2186 of that symlist; everything up to there was defined by us. */
2187 /* Note that we preserve the order of the enum constants, so
2188 that in something like "enum {FOO, LAST_THING=FOO}" we print
2189 FOO, not LAST_THING. */
2191 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2197 for (; j
< syms
->nsyms
; j
++, n
++)
2199 struct symbol
*xsym
= syms
->symbol
[j
];
2200 SYMBOL_TYPE (xsym
) = type
;
2201 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2202 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2203 if (SYMBOL_VALUE (xsym
) < 0)
2205 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2212 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2217 /* Register our ability to parse symbols for coff BFD files. */
2219 static struct sym_fns coff_sym_fns
=
2221 bfd_target_coff_flavour
,
2222 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2223 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2224 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2225 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2226 default_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2227 NULL
/* next: pointer to next struct sym_fns */
2231 _initialize_coffread ()
2233 add_symtab_fns (&coff_sym_fns
);