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
);
986 if (sec
== SECT_OFF_DATA (objfile
))
989 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
?
990 mst_data
: mst_file_data
;
993 if (sec
== SECT_OFF_BSS (objfile
))
996 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
?
997 mst_data
: mst_file_data
;
1000 ms_type
= mst_unknown
;
1003 if (cs
->c_name
[0] != '@' /* Skip tdesc symbols */ )
1005 struct minimal_symbol
*msym
;
1007 msym
= prim_record_minimal_symbol_and_info
1008 (cs
->c_name
, tmpaddr
, ms_type
, (char *) cs
->c_sclass
, sec
,
1010 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1012 COFF_MAKE_MSYMBOL_SPECIAL (cs
->c_sclass
, msym
);
1015 if (SDB_TYPE (cs
->c_type
))
1018 sym
= process_coff_symbol
1019 (cs
, &main_aux
, objfile
);
1020 SYMBOL_VALUE (sym
) = tmpaddr
;
1021 SYMBOL_SECTION (sym
) = sec
;
1027 if (STREQ (cs
->c_name
, ".bf"))
1029 within_function
= 1;
1031 /* value contains address of first non-init type code */
1032 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1033 contains line number of '{' } */
1034 if (cs
->c_naux
!= 1)
1035 complain (&bf_no_aux_complaint
, cs
->c_symnum
);
1036 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1037 fcn_first_line_addr
= cs
->c_value
;
1039 /* Might want to check that locals are 0 and
1040 context_stack_depth is zero, and complain if not. */
1043 new = push_context (depth
, fcn_start_addr
);
1044 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1046 process_coff_symbol (&fcn_cs_saved
, &fcn_aux_saved
, objfile
);
1048 else if (STREQ (cs
->c_name
, ".ef"))
1050 /* the value of .ef is the address of epilogue code;
1051 not useful for gdb. */
1052 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1053 contains number of lines to '}' */
1055 if (context_stack_depth
<= 0)
1056 { /* We attempted to pop an empty context stack */
1057 complain (&ef_stack_complaint
, cs
->c_symnum
);
1058 within_function
= 0;
1062 new = pop_context ();
1063 /* Stack must be empty now. */
1064 if (context_stack_depth
> 0 || new == NULL
)
1066 complain (&ef_complaint
, cs
->c_symnum
);
1067 within_function
= 0;
1070 if (cs
->c_naux
!= 1)
1072 complain (&ef_no_aux_complaint
, cs
->c_symnum
);
1073 fcn_last_line
= 0x7FFFFFFF;
1077 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1079 /* fcn_first_line is the line number of the opening '{'.
1080 Do not record it - because it would affect gdb's idea
1081 of the line number of the first statement of the function -
1082 except for one-line functions, for which it is also the line
1083 number of all the statements and of the closing '}', and
1084 for which we do not have any other statement-line-number. */
1085 if (fcn_last_line
== 1)
1086 record_line (current_subfile
, fcn_first_line
,
1087 fcn_first_line_addr
);
1089 enter_linenos (fcn_line_ptr
, fcn_first_line
, fcn_last_line
,
1092 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1094 #if defined (FUNCTION_EPILOGUE_SIZE)
1095 /* This macro should be defined only on
1097 fcn_aux_saved.x_sym.x_misc.x_fsize
1098 field is always zero.
1099 So use the .bf record information that
1100 points to the epilogue and add the size
1103 + FUNCTION_EPILOGUE_SIZE
1104 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)),
1106 fcn_cs_saved
.c_value
1107 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1108 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)),
1112 within_function
= 0;
1117 if (STREQ (cs
->c_name
, ".bb"))
1119 tmpaddr
= cs
->c_value
;
1120 tmpaddr
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1121 push_context (++depth
, tmpaddr
);
1123 else if (STREQ (cs
->c_name
, ".eb"))
1125 if (context_stack_depth
<= 0)
1126 { /* We attempted to pop an empty context stack */
1127 complain (&eb_stack_complaint
, cs
->c_symnum
);
1131 new = pop_context ();
1132 if (depth
-- != new->depth
)
1134 complain (&eb_complaint
, symnum
);
1137 if (local_symbols
&& context_stack_depth
> 0)
1140 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1141 /* Make a block for the local symbols within. */
1142 finish_block (0, &local_symbols
, new->old_blocks
,
1143 new->start_addr
, tmpaddr
, objfile
);
1145 /* Now pop locals of block just finished. */
1146 local_symbols
= new->locals
;
1151 process_coff_symbol (cs
, &main_aux
, objfile
);
1156 if (last_source_file
)
1157 coff_end_symtab (objfile
);
1159 /* Patch up any opaque types (references to types that are not defined
1160 in the file where they are referenced, e.g. "struct foo *bar"). */
1161 ALL_OBJFILE_SYMTABS (objfile
, s
)
1162 patch_opaque_types (s
);
1164 current_objfile
= NULL
;
1167 /* Routines for reading headers and symbols from executable. */
1169 /* Read the next symbol, swap it, and return it in both internal_syment
1170 form, and coff_symbol form. Also return its first auxent, if any,
1171 in internal_auxent form, and skip any other auxents. */
1174 read_one_sym (cs
, sym
, aux
)
1175 register struct coff_symbol
*cs
;
1176 register struct internal_syment
*sym
;
1177 register union internal_auxent
*aux
;
1181 cs
->c_symnum
= symnum
;
1182 bfd_read (temp_sym
, local_symesz
, 1, nlist_bfd_global
);
1183 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1184 cs
->c_naux
= sym
->n_numaux
& 0xff;
1185 if (cs
->c_naux
>= 1)
1187 bfd_read (temp_aux
, local_auxesz
, 1, nlist_bfd_global
);
1188 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
, sym
->n_type
, sym
->n_sclass
,
1189 0, cs
->c_naux
, (char *) aux
);
1190 /* If more than one aux entry, read past it (only the first aux
1192 for (i
= 1; i
< cs
->c_naux
; i
++)
1193 bfd_read (temp_aux
, local_auxesz
, 1, nlist_bfd_global
);
1195 cs
->c_name
= getsymname (sym
);
1196 cs
->c_value
= sym
->n_value
;
1197 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1198 cs
->c_secnum
= sym
->n_scnum
;
1199 cs
->c_type
= (unsigned) sym
->n_type
;
1200 if (!SDB_TYPE (cs
->c_type
))
1204 if (cs
->c_sclass
& 128)
1205 printf ("thumb symbol %s, class 0x%x\n", cs
->c_name
, cs
->c_sclass
);
1208 symnum
+= 1 + cs
->c_naux
;
1210 /* The PE file format stores symbol values as offsets within the
1211 section, rather than as absolute addresses. We correct that
1212 here, if the symbol has an appropriate storage class. FIXME: We
1213 should use BFD to read the symbols, rather than duplicating the
1217 switch (cs
->c_sclass
)
1221 case C_THUMBEXTFUNC
:
1226 case C_THUMBSTATFUNC
:
1232 if (cs
->c_secnum
!= 0)
1233 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1239 /* Support for string table handling */
1241 static char *stringtab
= NULL
;
1244 init_stringtab (abfd
, offset
)
1250 unsigned char lengthbuf
[4];
1254 /* If the file is stripped, the offset might be zero, indicating no
1255 string table. Just return with `stringtab' set to null. */
1259 if (bfd_seek (abfd
, offset
, 0) < 0)
1262 val
= bfd_read ((char *) lengthbuf
, sizeof lengthbuf
, 1, abfd
);
1263 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1265 /* If no string table is needed, then the file may end immediately
1266 after the symbols. Just return with `stringtab' set to null. */
1267 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1270 stringtab
= (char *) xmalloc (length
);
1271 /* This is in target format (probably not very useful, and not currently
1272 used), not host format. */
1273 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1274 if (length
== sizeof length
) /* Empty table -- just the count */
1277 val
= bfd_read (stringtab
+ sizeof lengthbuf
, length
- sizeof lengthbuf
, 1, abfd
);
1278 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1293 free_stringtab_cleanup (void *ignore
)
1299 getsymname (symbol_entry
)
1300 struct internal_syment
*symbol_entry
;
1302 static char buffer
[SYMNMLEN
+ 1];
1305 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1307 /* FIXME: Probably should be detecting corrupt symbol files by
1308 seeing whether offset points to within the stringtab. */
1309 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1313 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1314 buffer
[SYMNMLEN
] = '\0';
1320 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1321 only the last component of the name. Result is in static storage and
1322 is only good for temporary use. */
1325 coff_getfilename (aux_entry
)
1326 union internal_auxent
*aux_entry
;
1328 static char buffer
[BUFSIZ
];
1329 register char *temp
;
1332 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1333 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1336 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1337 buffer
[FILNMLEN
] = '\0';
1341 /* FIXME: We should not be throwing away the information about what
1342 directory. It should go into dirname of the symtab, or some such
1344 if ((temp
= strrchr (result
, '/')) != NULL
)
1349 /* Support for line number handling. */
1351 static char *linetab
= NULL
;
1352 static long linetab_offset
;
1353 static unsigned long linetab_size
;
1355 /* Read in all the line numbers for fast lookups later. Leave them in
1356 external (unswapped) format in memory; we'll swap them as we enter
1357 them into GDB's data structures. */
1360 init_lineno (abfd
, offset
, size
)
1367 linetab_offset
= offset
;
1368 linetab_size
= size
;
1375 if (bfd_seek (abfd
, offset
, 0) < 0)
1378 /* Allocate the desired table, plus a sentinel */
1379 linetab
= (char *) xmalloc (size
+ local_linesz
);
1381 val
= bfd_read (linetab
, size
, 1, abfd
);
1385 /* Terminate it with an all-zero sentinel record */
1386 memset (linetab
+ size
, 0, local_linesz
);
1400 free_linetab_cleanup (void *ignore
)
1405 #if !defined (L_LNNO32)
1406 #define L_LNNO32(lp) ((lp)->l_lnno)
1410 enter_linenos (file_offset
, first_line
, last_line
, objfile
)
1412 register int first_line
;
1413 register int last_line
;
1414 struct objfile
*objfile
;
1416 register char *rawptr
;
1417 struct internal_lineno lptr
;
1421 if (file_offset
< linetab_offset
)
1423 complain (&lineno_complaint
, file_offset
);
1424 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1426 file_offset
+= linetab_offset
; /* Try reading at that linetab offset */
1429 rawptr
= &linetab
[file_offset
- linetab_offset
];
1431 /* skip first line entry for each function */
1432 rawptr
+= local_linesz
;
1433 /* line numbers start at one for the first line of the function */
1438 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1439 rawptr
+= local_linesz
;
1440 /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
1441 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1442 record_line (current_subfile
, first_line
+ L_LNNO32 (&lptr
),
1444 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)));
1451 patch_type (type
, real_type
)
1453 struct type
*real_type
;
1455 register struct type
*target
= TYPE_TARGET_TYPE (type
);
1456 register struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1457 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1459 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1460 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1461 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
, field_size
);
1463 memcpy (TYPE_FIELDS (target
), TYPE_FIELDS (real_target
), field_size
);
1465 if (TYPE_NAME (real_target
))
1467 if (TYPE_NAME (target
))
1468 free (TYPE_NAME (target
));
1469 TYPE_NAME (target
) = concat (TYPE_NAME (real_target
), NULL
);
1473 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1474 so that they can be used to print out opaque data structures properly. */
1477 patch_opaque_types (s
)
1480 register struct block
*b
;
1482 register struct symbol
*real_sym
;
1484 /* Go through the per-file symbols only */
1485 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1486 for (i
= BLOCK_NSYMS (b
) - 1; i
>= 0; i
--)
1488 /* Find completed typedefs to use to fix opaque ones.
1489 Remove syms from the chain when their types are stored,
1490 but search the whole chain, as there may be several syms
1491 from different files with the same name. */
1492 real_sym
= BLOCK_SYM (b
, i
);
1493 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
&&
1494 SYMBOL_NAMESPACE (real_sym
) == VAR_NAMESPACE
&&
1495 TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
&&
1496 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1498 register char *name
= SYMBOL_NAME (real_sym
);
1499 register int hash
= hashname (name
);
1500 register struct symbol
*sym
, *prev
;
1503 for (sym
= opaque_type_chain
[hash
]; sym
;)
1505 if (name
[0] == SYMBOL_NAME (sym
)[0] &&
1506 STREQ (name
+ 1, SYMBOL_NAME (sym
) + 1))
1510 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1514 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1517 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1521 sym
= SYMBOL_VALUE_CHAIN (prev
);
1525 sym
= opaque_type_chain
[hash
];
1531 sym
= SYMBOL_VALUE_CHAIN (sym
);
1538 static struct symbol
*
1539 process_coff_symbol (cs
, aux
, objfile
)
1540 register struct coff_symbol
*cs
;
1541 register union internal_auxent
*aux
;
1542 struct objfile
*objfile
;
1544 register struct symbol
*sym
1545 = (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1546 sizeof (struct symbol
));
1549 memset (sym
, 0, sizeof (struct symbol
));
1551 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1552 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
1553 &objfile
->symbol_obstack
);
1554 SYMBOL_LANGUAGE (sym
) = language_auto
;
1555 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1557 /* default assumptions */
1558 SYMBOL_VALUE (sym
) = cs
->c_value
;
1559 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1560 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1562 if (ISFCN (cs
->c_type
))
1564 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1566 lookup_function_type (decode_function_type (cs
, cs
->c_type
, aux
));
1568 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1569 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1570 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1571 add_symbol_to_list (sym
, &file_symbols
);
1572 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1573 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1574 add_symbol_to_list (sym
, &global_symbols
);
1578 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
);
1579 switch (cs
->c_sclass
)
1585 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1586 add_symbol_to_list (sym
, &local_symbols
);
1590 case C_THUMBEXTFUNC
:
1592 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1593 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1594 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1595 add_symbol_to_list (sym
, &global_symbols
);
1599 case C_THUMBSTATFUNC
:
1601 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1602 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1603 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1604 if (within_function
)
1606 /* Static symbol of local scope */
1607 add_symbol_to_list (sym
, &local_symbols
);
1611 /* Static symbol at top level of file */
1612 add_symbol_to_list (sym
, &file_symbols
);
1616 #ifdef C_GLBLREG /* AMD coff */
1620 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1621 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM (cs
->c_value
);
1622 add_symbol_to_list (sym
, &local_symbols
);
1630 SYMBOL_CLASS (sym
) = LOC_ARG
;
1631 add_symbol_to_list (sym
, &local_symbols
);
1632 #if !defined (BELIEVE_PCC_PROMOTION)
1633 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1635 /* If PCC says a parameter is a short or a char,
1636 aligned on an int boundary, realign it to the
1637 "little end" of the int. */
1638 struct type
*temptype
;
1639 temptype
= lookup_fundamental_type (current_objfile
,
1641 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1642 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1643 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1645 SYMBOL_VALUE (sym
) +=
1646 TYPE_LENGTH (temptype
)
1647 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1654 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1655 SYMBOL_VALUE (sym
) = SDB_REG_TO_REGNUM (cs
->c_value
);
1656 add_symbol_to_list (sym
, &local_symbols
);
1657 #if !defined (BELIEVE_PCC_PROMOTION)
1658 /* FIXME: This should retain the current type, since it's just
1659 a register value. gnu@adobe, 26Feb93 */
1661 /* If PCC says a parameter is a short or a char,
1662 it is really an int. */
1663 struct type
*temptype
;
1665 lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1666 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1667 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1670 (TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1671 ? lookup_fundamental_type (current_objfile
,
1672 FT_UNSIGNED_INTEGER
)
1680 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1681 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1683 /* If type has no name, give it one */
1684 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1686 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1687 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1689 /* If we are giving a name to a type such as "pointer to
1690 foo" or "function returning foo", we better not set
1691 the TYPE_NAME. If the program contains "typedef char
1692 *caddr_t;", we don't want all variables of type char
1693 * to print as caddr_t. This is not just a
1694 consequence of GDB's type management; CC and GCC (at
1695 least through version 2.4) both output variables of
1696 either type char * or caddr_t with the type
1697 refering to the C_TPDEF symbol for caddr_t. If a future
1698 compiler cleans this up it GDB is not ready for it
1699 yet, but if it becomes ready we somehow need to
1700 disable this check (without breaking the PCC/GCC2.4
1705 Fortunately, this check seems not to be necessary
1706 for anything except pointers or functions. */
1710 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1711 concat (SYMBOL_NAME (sym
), NULL
);
1714 /* Ignore vendor section for Harris CX/UX targets. */
1715 else if (cs
->c_name
[0] == '$')
1717 #endif /* CXUX_TARGET */
1719 /* Keep track of any type which points to empty structured type,
1720 so it can be filled from a definition from another file. A
1721 simple forward reference (TYPE_CODE_UNDEF) is not an
1722 empty structured type, though; the forward references
1723 work themselves out via the magic of coff_lookup_type. */
1724 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
&&
1725 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0 &&
1726 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) !=
1729 register int i
= hashname (SYMBOL_NAME (sym
));
1731 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1732 opaque_type_chain
[i
] = sym
;
1734 add_symbol_to_list (sym
, &file_symbols
);
1740 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1741 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1743 /* Some compilers try to be helpful by inventing "fake"
1744 names for anonymous enums, structures, and unions, like
1745 "~0fake" or ".0fake". Thanks, but no thanks... */
1746 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1747 if (SYMBOL_NAME (sym
) != NULL
1748 && *SYMBOL_NAME (sym
) != '~'
1749 && *SYMBOL_NAME (sym
) != '.')
1750 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1751 concat (SYMBOL_NAME (sym
), NULL
);
1753 add_symbol_to_list (sym
, &file_symbols
);
1763 /* Decode a coff type specifier; return the type that is meant. */
1765 static struct type
*
1766 decode_type (cs
, c_type
, aux
)
1767 register struct coff_symbol
*cs
;
1768 unsigned int c_type
;
1769 register union internal_auxent
*aux
;
1771 register struct type
*type
= 0;
1772 unsigned int new_c_type
;
1774 if (c_type
& ~N_BTMASK
)
1776 new_c_type
= DECREF (c_type
);
1779 type
= decode_type (cs
, new_c_type
, aux
);
1780 type
= lookup_pointer_type (type
);
1782 else if (ISFCN (c_type
))
1784 type
= decode_type (cs
, new_c_type
, aux
);
1785 type
= lookup_function_type (type
);
1787 else if (ISARY (c_type
))
1790 register unsigned short *dim
;
1791 struct type
*base_type
, *index_type
, *range_type
;
1793 /* Define an array type. */
1794 /* auxent refers to array, not base type */
1795 if (aux
->x_sym
.x_tagndx
.l
== 0)
1798 /* shift the indices down */
1799 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1802 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1806 base_type
= decode_type (cs
, new_c_type
, aux
);
1807 index_type
= lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1809 create_range_type ((struct type
*) NULL
, index_type
, 0, n
- 1);
1811 create_array_type ((struct type
*) NULL
, base_type
, range_type
);
1816 /* Reference to existing type. This only occurs with the
1817 struct, union, and enum types. EPI a29k coff
1818 fakes us out by producing aux entries with a nonzero
1819 x_tagndx for definitions of structs, unions, and enums, so we
1820 have to check the c_sclass field. SCO 3.2v4 cc gets confused
1821 with pointers to pointers to defined structs, and generates
1822 negative x_tagndx fields. */
1823 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1825 if (cs
->c_sclass
!= C_STRTAG
1826 && cs
->c_sclass
!= C_UNTAG
1827 && cs
->c_sclass
!= C_ENTAG
1828 && aux
->x_sym
.x_tagndx
.l
>= 0)
1830 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1835 complain (&tagndx_bad_complaint
, cs
->c_name
);
1836 /* And fall through to decode_base_type... */
1840 return decode_base_type (cs
, BTYPE (c_type
), aux
);
1843 /* Decode a coff type specifier for function definition;
1844 return the type that the function returns. */
1846 static struct type
*
1847 decode_function_type (cs
, c_type
, aux
)
1848 register struct coff_symbol
*cs
;
1849 unsigned int c_type
;
1850 register union internal_auxent
*aux
;
1852 if (aux
->x_sym
.x_tagndx
.l
== 0)
1853 cs
->c_naux
= 0; /* auxent refers to function, not base type */
1855 return decode_type (cs
, DECREF (c_type
), aux
);
1860 static struct type
*
1861 decode_base_type (cs
, c_type
, aux
)
1862 register struct coff_symbol
*cs
;
1863 unsigned int c_type
;
1864 register union internal_auxent
*aux
;
1871 /* shows up with "void (*foo)();" structure members */
1872 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1875 /* DGUX actually defines both T_ARG and T_VOID to the same value. */
1878 /* Shows up in DGUX, I think. Not sure where. */
1879 return lookup_fundamental_type (current_objfile
, FT_VOID
); /* shouldn't show up here */
1885 /* Intel 960 COFF has this symbol and meaning. */
1886 return lookup_fundamental_type (current_objfile
, FT_VOID
);
1890 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
1893 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
1896 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
1899 if (cs
->c_sclass
== C_FIELD
1900 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
> TARGET_LONG_BIT
)
1901 return lookup_fundamental_type (current_objfile
, FT_LONG_LONG
);
1903 return lookup_fundamental_type (current_objfile
, FT_LONG
);
1906 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
1909 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
1912 return lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
1915 if (cs
->c_naux
!= 1)
1917 /* anonymous structure type */
1918 type
= coff_alloc_type (cs
->c_symnum
);
1919 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1920 TYPE_NAME (type
) = NULL
;
1921 /* This used to set the tag to "<opaque>". But I think setting it
1922 to NULL is right, and the printing code can print it as
1924 TYPE_TAG_NAME (type
) = NULL
;
1925 INIT_CPLUS_SPECIFIC (type
);
1926 TYPE_LENGTH (type
) = 0;
1927 TYPE_FIELDS (type
) = 0;
1928 TYPE_NFIELDS (type
) = 0;
1932 type
= coff_read_struct_type (cs
->c_symnum
,
1933 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1934 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1939 if (cs
->c_naux
!= 1)
1941 /* anonymous union type */
1942 type
= coff_alloc_type (cs
->c_symnum
);
1943 TYPE_NAME (type
) = NULL
;
1944 /* This used to set the tag to "<opaque>". But I think setting it
1945 to NULL is right, and the printing code can print it as
1947 TYPE_TAG_NAME (type
) = NULL
;
1948 INIT_CPLUS_SPECIFIC (type
);
1949 TYPE_LENGTH (type
) = 0;
1950 TYPE_FIELDS (type
) = 0;
1951 TYPE_NFIELDS (type
) = 0;
1955 type
= coff_read_struct_type (cs
->c_symnum
,
1956 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1957 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1959 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1963 if (cs
->c_naux
!= 1)
1965 /* anonymous enum type */
1966 type
= coff_alloc_type (cs
->c_symnum
);
1967 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1968 TYPE_NAME (type
) = NULL
;
1969 /* This used to set the tag to "<opaque>". But I think setting it
1970 to NULL is right, and the printing code can print it as
1972 TYPE_TAG_NAME (type
) = NULL
;
1973 TYPE_LENGTH (type
) = 0;
1974 TYPE_FIELDS (type
) = 0;
1975 TYPE_NFIELDS (type
) = 0;
1979 type
= coff_read_enum_type (cs
->c_symnum
,
1980 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1981 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
);
1986 /* shouldn't show up here */
1990 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
1993 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
1996 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
1999 if (cs
->c_sclass
== C_FIELD
2000 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
> TARGET_LONG_BIT
)
2001 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG_LONG
);
2003 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2005 complain (&unexpected_type_complaint
, cs
->c_name
);
2006 return lookup_fundamental_type (current_objfile
, FT_VOID
);
2009 /* This page contains subroutines of read_type. */
2011 /* Read the description of a structure (or union type) and return an
2012 object describing the type. */
2014 static struct type
*
2015 coff_read_struct_type (index
, length
, lastsym
)
2022 struct nextfield
*next
;
2026 register struct type
*type
;
2027 register struct nextfield
*list
= 0;
2028 struct nextfield
*new;
2032 struct coff_symbol member_sym
;
2033 register struct coff_symbol
*ms
= &member_sym
;
2034 struct internal_syment sub_sym
;
2035 union internal_auxent sub_aux
;
2038 type
= coff_alloc_type (index
);
2039 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2040 INIT_CPLUS_SPECIFIC (type
);
2041 TYPE_LENGTH (type
) = length
;
2043 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2045 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2047 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2049 switch (ms
->c_sclass
)
2054 /* Get space to record the next field's data. */
2055 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2059 /* Save the data. */
2063 ¤t_objfile
->symbol_obstack
);
2064 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
, &sub_aux
);
2065 FIELD_BITPOS (list
->field
) = 8 * ms
->c_value
;
2066 FIELD_BITSIZE (list
->field
) = 0;
2072 /* Get space to record the next field's data. */
2073 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2077 /* Save the data. */
2081 ¤t_objfile
->symbol_obstack
);
2082 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
, &sub_aux
);
2083 FIELD_BITPOS (list
->field
) = ms
->c_value
;
2084 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2093 /* Now create the vector of fields, and record how big it is. */
2095 TYPE_NFIELDS (type
) = nfields
;
2096 TYPE_FIELDS (type
) = (struct field
*)
2097 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2099 /* Copy the saved-up fields into the field vector. */
2101 for (n
= nfields
; list
; list
= list
->next
)
2102 TYPE_FIELD (type
, --n
) = list
->field
;
2107 /* Read a definition of an enumeration type,
2108 and create and return a suitable type object.
2109 Also defines the symbols that represent the values of the type. */
2112 static struct type
*
2113 coff_read_enum_type (index
, length
, lastsym
)
2118 register struct symbol
*sym
;
2119 register struct type
*type
;
2122 struct pending
**symlist
;
2123 struct coff_symbol member_sym
;
2124 register struct coff_symbol
*ms
= &member_sym
;
2125 struct internal_syment sub_sym
;
2126 union internal_auxent sub_aux
;
2127 struct pending
*osyms
, *syms
;
2131 int unsigned_enum
= 1;
2133 type
= coff_alloc_type (index
);
2134 if (within_function
)
2135 symlist
= &local_symbols
;
2137 symlist
= &file_symbols
;
2139 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2141 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2143 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2145 name
= EXTERNAL_NAME (name
, current_objfile
->obfd
);
2147 switch (ms
->c_sclass
)
2150 sym
= (struct symbol
*) obstack_alloc
2151 (¤t_objfile
->symbol_obstack
,
2152 sizeof (struct symbol
));
2153 memset (sym
, 0, sizeof (struct symbol
));
2156 obsavestring (name
, strlen (name
),
2157 ¤t_objfile
->symbol_obstack
);
2158 SYMBOL_CLASS (sym
) = LOC_CONST
;
2159 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2160 SYMBOL_VALUE (sym
) = ms
->c_value
;
2161 add_symbol_to_list (sym
, symlist
);
2166 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2167 up the count of how many symbols to read. So stop
2174 /* Now fill in the fields of the type-structure. */
2177 TYPE_LENGTH (type
) = length
;
2179 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ TARGET_CHAR_BIT
; /* Assume ints */
2180 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2181 TYPE_NFIELDS (type
) = nsyms
;
2182 TYPE_FIELDS (type
) = (struct field
*)
2183 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2185 /* Find the symbols for the values and put them into the type.
2186 The symbols can be found in the symlist that we put them on
2187 to cause them to be defined. osyms contains the old value
2188 of that symlist; everything up to there was defined by us. */
2189 /* Note that we preserve the order of the enum constants, so
2190 that in something like "enum {FOO, LAST_THING=FOO}" we print
2191 FOO, not LAST_THING. */
2193 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2199 for (; j
< syms
->nsyms
; j
++, n
++)
2201 struct symbol
*xsym
= syms
->symbol
[j
];
2202 SYMBOL_TYPE (xsym
) = type
;
2203 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2204 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2205 if (SYMBOL_VALUE (xsym
) < 0)
2207 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2214 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2219 /* Register our ability to parse symbols for coff BFD files. */
2221 static struct sym_fns coff_sym_fns
=
2223 bfd_target_coff_flavour
,
2224 coff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2225 coff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2226 coff_symfile_read
, /* sym_read: read a symbol file into symtab */
2227 coff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2228 default_symfile_offsets
, /* sym_offsets: xlate external to internal form */
2229 NULL
/* next: pointer to next struct sym_fns */
2233 _initialize_coffread ()
2235 add_symtab_fns (&coff_sym_fns
);