1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "breakpoint.h"
27 #include "gdbsupport/gdb_obstack.h"
30 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
31 #include "libcoff.h" /* FIXME secret internal data from BFD */
33 #include "buildsym-legacy.h"
34 #include "stabsread.h"
35 #include "complaints.h"
38 #include "dictionary.h"
39 #include "dwarf2/public.h"
41 #include "coff-pe-read.h"
46 /* The objfile we are currently reading. */
48 static struct objfile
*coffread_objfile
;
50 struct coff_symfile_info
52 file_ptr min_lineno_offset
= 0; /* Where in file lowest line#s are. */
53 file_ptr max_lineno_offset
= 0; /* 1+last byte of line#s in file. */
55 CORE_ADDR textaddr
= 0; /* Addr of .text section. */
56 unsigned int textsize
= 0; /* Size of .text section. */
57 std::vector
<asection
*> *stabsects
; /* .stab sections. */
58 asection
*stabstrsect
= nullptr; /* Section pointer for .stab section. */
59 char *stabstrdata
= nullptr;
62 /* Key for COFF-associated data. */
64 static const registry
<objfile
>::key
<coff_symfile_info
> coff_objfile_data_key
;
66 /* Translate an external name string into a user-visible name. */
67 #define EXTERNAL_NAME(string, abfd) \
68 (string[0] == bfd_get_symbol_leading_char (abfd) \
69 ? string + 1 : string)
71 /* To be an sdb debug type, type must have at least a basic or primary
72 derived type. Using this rather than checking against T_NULL is
73 said to prevent core dumps if we try to operate on Michael Bloom
76 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
78 /* Core address of start and end of text of current source file.
79 This comes from a ".text" symbol where x_nlinno > 0. */
81 static CORE_ADDR current_source_start_addr
;
82 static CORE_ADDR current_source_end_addr
;
84 /* The addresses of the symbol table stream and number of symbols
85 of the object file we are reading (as copied into core). */
87 static bfd
*nlist_bfd_global
;
88 static int nlist_nsyms_global
;
91 /* Pointers to scratch storage, used for reading raw symbols and
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
114 structures. (We only need to know this to read them from the file
115 -- BFD will then translate the data in them, into `internal_xxx'
116 structs in the right 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 /* Simplified internal version of coff symbol table information. */
136 int c_symnum
; /* Symbol number of this entry. */
137 int c_naux
; /* 0 if syment only, 1 if syment +
145 /* Vector of types defined so far, indexed by their type numbers. */
147 static struct type
**type_vector
;
149 /* Number of elements allocated for type_vector currently. */
151 static int type_vector_length
;
153 /* Initial size of type vector. Is realloc'd larger if needed, and
154 realloc'd down to the size actually used, when completed. */
156 #define INITIAL_TYPE_VECTOR_LENGTH 160
158 static char *linetab
= NULL
;
159 static file_ptr linetab_offset
;
160 static file_ptr linetab_size
;
162 static char *stringtab
= NULL
;
164 extern void stabsread_clear_cache (void);
166 static struct type
*coff_read_struct_type (int, int, int,
169 static struct type
*decode_base_type (struct coff_symbol
*,
171 union internal_auxent
*,
174 static struct type
*decode_type (struct coff_symbol
*, unsigned int,
175 union internal_auxent
*,
178 static struct type
*decode_function_type (struct coff_symbol
*,
180 union internal_auxent
*,
183 static struct type
*coff_read_enum_type (int, int, int,
186 static struct symbol
*process_coff_symbol (struct coff_symbol
*,
187 union internal_auxent
*,
190 static void patch_opaque_types (struct symtab
*);
192 static void enter_linenos (file_ptr
, int, int, struct objfile
*);
194 static int init_lineno (bfd
*, file_ptr
, file_ptr
, gdb::unique_xmalloc_ptr
<char> *);
196 static char *getsymname (struct internal_syment
*);
198 static const char *coff_getfilename (union internal_auxent
*);
200 static int init_stringtab (bfd
*, file_ptr
, gdb::unique_xmalloc_ptr
<char> *);
202 static void read_one_sym (struct coff_symbol
*,
203 struct internal_syment
*,
204 union internal_auxent
*);
206 static void coff_symtab_read (minimal_symbol_reader
&,
207 file_ptr
, unsigned int, struct objfile
*);
209 /* We are called once per section from coff_symfile_read. We
210 need to examine each section we are passed, check to see
211 if it is something we are interested in processing, and
212 if so, stash away some access information for the section.
214 FIXME: The section names should not be hardwired strings (what
215 should they be? I don't think most object file formats have enough
216 section flags to specify what kind of debug section it is
220 coff_locate_sections (bfd
*abfd
, asection
*sectp
, void *csip
)
222 struct coff_symfile_info
*csi
;
225 csi
= (struct coff_symfile_info
*) csip
;
226 name
= bfd_section_name (sectp
);
227 if (strcmp (name
, ".text") == 0)
229 csi
->textaddr
= bfd_section_vma (sectp
);
230 csi
->textsize
+= bfd_section_size (sectp
);
232 else if (startswith (name
, ".text"))
234 csi
->textsize
+= bfd_section_size (sectp
);
236 else if (strcmp (name
, ".stabstr") == 0)
238 csi
->stabstrsect
= sectp
;
240 else if (startswith (name
, ".stab"))
244 /* We can have multiple .stab sections if linked with
246 for (s
= name
+ sizeof ".stab" - 1; *s
!= '\0'; s
++)
250 csi
->stabsects
->push_back (sectp
);
254 /* Return the section_offsets* that CS points to. */
255 static int cs_to_section (struct coff_symbol
*, struct objfile
*);
257 struct coff_find_targ_sec_arg
264 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
266 struct coff_find_targ_sec_arg
*args
= (struct coff_find_targ_sec_arg
*) obj
;
268 if (sect
->target_index
== args
->targ_index
)
269 *args
->resultp
= sect
;
272 /* Return the bfd_section that CS points to. */
273 static struct bfd_section
*
274 cs_to_bfd_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
276 asection
*sect
= NULL
;
277 struct coff_find_targ_sec_arg args
;
279 args
.targ_index
= cs
->c_secnum
;
280 args
.resultp
= §
;
281 bfd_map_over_sections (objfile
->obfd
.get (), find_targ_sec
, &args
);
285 /* Return the section number (SECT_OFF_*) that CS points to. */
287 cs_to_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
289 asection
*sect
= cs_to_bfd_section (cs
, objfile
);
292 return SECT_OFF_TEXT (objfile
);
293 return gdb_bfd_section_index (objfile
->obfd
.get (), sect
);
296 /* Return the address of the section of a COFF symbol. */
298 static CORE_ADDR
cs_section_address (struct coff_symbol
*, bfd
*);
301 cs_section_address (struct coff_symbol
*cs
, bfd
*abfd
)
303 asection
*sect
= NULL
;
304 struct coff_find_targ_sec_arg args
;
307 args
.targ_index
= cs
->c_secnum
;
308 args
.resultp
= §
;
309 bfd_map_over_sections (abfd
, find_targ_sec
, &args
);
311 addr
= bfd_section_vma (sect
);
315 /* Look up a coff type-number index. Return the address of the slot
316 where the type for that index is stored.
317 The type-number is in INDEX.
319 This can be used for finding the type associated with that index
320 or for associating a new type with the index. */
322 static struct type
**
323 coff_lookup_type (int index
)
325 if (index
>= type_vector_length
)
327 int old_vector_length
= type_vector_length
;
329 type_vector_length
*= 2;
330 if (index
/* is still */ >= type_vector_length
)
331 type_vector_length
= index
* 2;
333 type_vector
= (struct type
**)
334 xrealloc ((char *) type_vector
,
335 type_vector_length
* sizeof (struct type
*));
336 memset (&type_vector
[old_vector_length
], 0,
337 (type_vector_length
- old_vector_length
) * sizeof (struct type
*));
339 return &type_vector
[index
];
342 /* Make sure there is a type allocated for type number index
343 and return the type object.
344 This can create an empty (zeroed) type object. */
347 coff_alloc_type (int index
)
349 struct type
**type_addr
= coff_lookup_type (index
);
350 struct type
*type
= *type_addr
;
352 /* If we are referring to a type not known at all yet,
353 allocate an empty type for it.
354 We will fill it in later if we find out how. */
357 type
= alloc_type (coffread_objfile
);
363 /* Start a new symtab for a new source file.
364 This is called when a COFF ".file" symbol is seen;
365 it indicates the start of data for one original source file. */
368 coff_start_compunit_symtab (struct objfile
*objfile
, const char *name
)
371 start_compunit_symtab (objfile
,
373 /* We never know the directory name for COFF. */
375 /* The start address is irrelevant, since we call
376 set_last_source_start_addr in coff_end_compunit_symtab. */
378 /* Let buildsym.c deduce the language for this symtab. */
380 record_debugformat ("COFF");
383 /* Save the vital information from when starting to read a file,
384 for use when closing off the current file.
385 NAME is the file name the symbols came from, START_ADDR is the
386 first text address for the file, and SIZE is the number of bytes of
390 complete_symtab (const char *name
, CORE_ADDR start_addr
, unsigned int size
)
392 set_last_source_file (name
);
393 current_source_start_addr
= start_addr
;
394 current_source_end_addr
= start_addr
+ size
;
397 /* Finish the symbol definitions for one main source file, close off
398 all the lexical contexts for that file (creating struct block's for
399 them), then make the struct symtab for that file and put it in the
403 coff_end_compunit_symtab (struct objfile
*objfile
)
405 set_last_source_start_addr (current_source_start_addr
);
407 end_compunit_symtab (current_source_end_addr
);
409 /* Reinitialize for beginning of new file. */
410 set_last_source_file (NULL
);
413 /* The linker sometimes generates some non-function symbols inside
414 functions referencing variables imported from another DLL.
415 Return nonzero if the given symbol corresponds to one of them. */
418 is_import_fixup_symbol (struct coff_symbol
*cs
,
419 enum minimal_symbol_type type
)
421 /* The following is a bit of a heuristic using the characteristics
422 of these fixup symbols, but should work well in practice... */
425 /* Must be a non-static text symbol. */
426 if (type
!= mst_text
)
429 /* Must be a non-function symbol. */
430 if (ISFCN (cs
->c_type
))
433 /* The name must start with "__fu<digits>__". */
434 if (!startswith (cs
->c_name
, "__fu"))
436 if (! isdigit (cs
->c_name
[4]))
438 for (i
= 5; cs
->c_name
[i
] != '\0' && isdigit (cs
->c_name
[i
]); i
++)
439 /* Nothing, just incrementing index past all digits. */;
440 if (cs
->c_name
[i
] != '_' || cs
->c_name
[i
+ 1] != '_')
446 static struct minimal_symbol
*
447 record_minimal_symbol (minimal_symbol_reader
&reader
,
448 struct coff_symbol
*cs
, CORE_ADDR address
,
449 enum minimal_symbol_type type
, int section
,
450 struct objfile
*objfile
)
452 /* We don't want TDESC entry points in the minimal symbol table. */
453 if (cs
->c_name
[0] == '@')
456 if (is_import_fixup_symbol (cs
, type
))
458 /* Because the value of these symbols is within a function code
459 range, these symbols interfere with the symbol-from-address
460 reverse lookup; this manifests itself in backtraces, or any
461 other commands that prints symbolic addresses. Just pretend
462 these symbols do not exist. */
466 return reader
.record_full (cs
->c_name
, true, address
, type
, section
);
469 /* coff_symfile_init ()
470 is the coff-specific initialization routine for reading symbols.
471 It is passed a struct objfile which contains, among other things,
472 the BFD for the file whose symbols are being read, and a slot for
473 a pointer to "private data" which we fill with cookies and other
474 treats for coff_symfile_read ().
476 We will only be called if this is a COFF or COFF-like file. BFD
477 handles figuring out the format of the file, and code in symtab.c
478 uses BFD's determination to vector to us.
480 The ultimate result is a new symtab (or, FIXME, eventually a
484 coff_symfile_init (struct objfile
*objfile
)
486 /* Allocate struct to keep track of the symfile. */
487 coff_objfile_data_key
.emplace (objfile
);
490 /* This function is called for every section; it finds the outer
491 limits of the line table (minimum and maximum file offset) so that
492 the mainline code can read the whole thing for efficiency. */
495 find_linenos (bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
497 struct coff_symfile_info
*info
;
499 file_ptr offset
, maxoff
;
501 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
502 count
= asect
->lineno_count
;
503 /* End of warning. */
507 size
= count
* local_linesz
;
509 info
= (struct coff_symfile_info
*) vpinfo
;
510 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
511 offset
= asect
->line_filepos
;
512 /* End of warning. */
514 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
515 info
->min_lineno_offset
= offset
;
517 maxoff
= offset
+ size
;
518 if (maxoff
> info
->max_lineno_offset
)
519 info
->max_lineno_offset
= maxoff
;
523 /* A helper function for coff_symfile_read that reads minimal
524 symbols. It may also read other forms of symbol as well. */
527 coff_read_minsyms (file_ptr symtab_offset
, unsigned int nsyms
,
528 struct objfile
*objfile
)
531 /* If minimal symbols were already read, and if we know we aren't
532 going to read any other kind of symbol here, then we can just
534 if (objfile
->per_bfd
->minsyms_read
&& pe_file
&& nsyms
== 0)
537 minimal_symbol_reader
reader (objfile
);
539 if (pe_file
&& nsyms
== 0)
541 /* We've got no debugging symbols, but it's a portable
542 executable, so try to read the export table. */
543 read_pe_exported_syms (reader
, objfile
);
547 /* Now that the executable file is positioned at symbol table,
548 process it and define symbols accordingly. */
549 coff_symtab_read (reader
, symtab_offset
, nsyms
, objfile
);
552 /* Install any minimal symbols that have been collected as the
553 current minimal symbols for this objfile. */
559 for (minimal_symbol
*msym
: objfile
->msymbols ())
561 const char *name
= msym
->linkage_name ();
563 /* If the minimal symbols whose name are prefixed by "__imp_"
564 or "_imp_", get rid of the prefix, and search the minimal
565 symbol in OBJFILE. Note that 'maintenance print msymbols'
566 shows that type of these "_imp_XXXX" symbols is mst_data. */
567 if (msym
->type () == mst_data
)
569 const char *name1
= NULL
;
571 if (startswith (name
, "_imp_"))
573 else if (startswith (name
, "__imp_"))
578 = bfd_get_symbol_leading_char (objfile
->obfd
.get ());
579 struct bound_minimal_symbol found
;
581 if (lead
!= '\0' && *name1
== lead
)
584 found
= lookup_minimal_symbol (name1
, NULL
, objfile
);
586 /* If found, there are symbols named "_imp_foo" and "foo"
587 respectively in OBJFILE. Set the type of symbol "foo"
588 as 'mst_solib_trampoline'. */
589 if (found
.minsym
!= NULL
590 && found
.minsym
->type () == mst_text
)
591 found
.minsym
->set_type (mst_solib_trampoline
);
598 /* The BFD for this file -- only good while we're actively reading
599 symbols into a psymtab or a symtab. */
601 static bfd
*symfile_bfd
;
603 /* Read a symbol file, after initialization by coff_symfile_init. */
606 coff_symfile_read (struct objfile
*objfile
, symfile_add_flags symfile_flags
)
608 struct coff_symfile_info
*info
;
609 bfd
*abfd
= objfile
->obfd
.get ();
610 coff_data_type
*cdata
= coff_data (abfd
);
611 const char *filename
= bfd_get_filename (abfd
);
613 unsigned int num_symbols
;
614 file_ptr symtab_offset
;
615 file_ptr stringtab_offset
;
616 unsigned int stabstrsize
;
618 info
= coff_objfile_data_key
.get (objfile
);
619 symfile_bfd
= abfd
; /* Kludge for swap routines. */
621 std::vector
<asection
*> stabsects
;
622 scoped_restore restore_stabsects
623 = make_scoped_restore (&info
->stabsects
, &stabsects
);
625 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
626 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
627 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
628 stringtab_offset
= symtab_offset
+ /* String table file offset */
629 num_symbols
* cdata
->local_symesz
;
631 /* Set a few file-statics that give us specific information about
632 the particular COFF file format we're reading. */
633 local_n_btmask
= cdata
->local_n_btmask
;
634 local_n_btshft
= cdata
->local_n_btshft
;
635 local_n_tmask
= cdata
->local_n_tmask
;
636 local_n_tshift
= cdata
->local_n_tshift
;
637 local_linesz
= cdata
->local_linesz
;
638 local_symesz
= cdata
->local_symesz
;
639 local_auxesz
= cdata
->local_auxesz
;
641 /* Allocate space for raw symbol and aux entries, based on their
642 space requirements as reported by BFD. */
643 gdb::def_vector
<char> temp_storage (cdata
->local_symesz
644 + cdata
->local_auxesz
);
645 temp_sym
= temp_storage
.data ();
646 temp_aux
= temp_sym
+ cdata
->local_symesz
;
648 /* We need to know whether this is a PE file, because in PE files,
649 unlike standard COFF files, symbol values are stored as offsets
650 from the section address, rather than as absolute addresses.
651 FIXME: We should use BFD to read the symbol table, and thus avoid
654 startswith (bfd_get_target (objfile
->obfd
.get ()), "pe")
655 || startswith (bfd_get_target (objfile
->obfd
.get ()), "epoc-pe");
657 /* End of warning. */
659 info
->min_lineno_offset
= 0;
660 info
->max_lineno_offset
= 0;
662 /* Only read line number information if we have symbols.
664 On Windows NT, some of the system's DLL's have sections with
665 PointerToLinenumbers fields that are non-zero, but point at
666 random places within the image file. (In the case I found,
667 KERNEL32.DLL's .text section has a line number info pointer that
668 points into the middle of the string `lib\\i386\kernel32.dll'.)
670 However, these DLL's also have no symbols. The line number
671 tables are meaningless without symbols. And in fact, GDB never
672 uses the line number information unless there are symbols. So we
673 can avoid spurious error messages (and maybe run a little
674 faster!) by not even reading the line number table unless we have
676 scoped_restore restore_linetab
= make_scoped_restore (&linetab
);
677 gdb::unique_xmalloc_ptr
<char> linetab_storage
;
680 /* Read the line number table, all at once. */
681 bfd_map_over_sections (abfd
, find_linenos
, (void *) info
);
683 val
= init_lineno (abfd
, info
->min_lineno_offset
,
684 info
->max_lineno_offset
- info
->min_lineno_offset
,
687 error (_("\"%s\": error reading line numbers."), filename
);
690 /* Now read the string table, all at once. */
692 scoped_restore restore_stringtab
= make_scoped_restore (&stringtab
);
693 gdb::unique_xmalloc_ptr
<char> stringtab_storage
;
694 val
= init_stringtab (abfd
, stringtab_offset
, &stringtab_storage
);
696 error (_("\"%s\": can't get string table"), filename
);
698 coff_read_minsyms (symtab_offset
, num_symbols
, objfile
);
700 if (!(objfile
->flags
& OBJF_READNEVER
))
701 bfd_map_over_sections (abfd
, coff_locate_sections
, (void *) info
);
703 if (!info
->stabsects
->empty())
705 if (!info
->stabstrsect
)
707 error (_("The debugging information in `%s' is corrupted.\nThe "
708 "file has a `.stabs' section, but no `.stabstr' section."),
712 /* FIXME: dubious. Why can't we use something normal like
713 bfd_get_section_contents? */
714 bfd_seek (abfd
, abfd
->where
, 0);
716 stabstrsize
= bfd_section_size (info
->stabstrsect
);
718 coffstab_build_psymtabs (objfile
,
719 info
->textaddr
, info
->textsize
,
721 info
->stabstrsect
->filepos
, stabstrsize
);
723 if (dwarf2_has_info (objfile
, NULL
))
725 /* DWARF2 sections. */
726 dwarf2_initialize_objfile (objfile
);
729 /* Try to add separate debug file if no symbols table found. */
730 if (!objfile
->has_partial_symbols ())
732 std::vector
<std::string
> warnings_vector
;
733 std::string debugfile
734 = find_separate_debug_file_by_buildid (objfile
, &warnings_vector
);
736 if (debugfile
.empty ())
738 = find_separate_debug_file_by_debuglink (objfile
, &warnings_vector
);
740 if (!debugfile
.empty ())
742 gdb_bfd_ref_ptr
debug_bfd (symfile_bfd_open (debugfile
.c_str ()));
744 symbol_file_add_separate (debug_bfd
, debugfile
.c_str (),
745 symfile_flags
, objfile
);
747 /* If all the methods to collect the debuginfo failed, print any
748 warnings that were collected. */
749 if (debugfile
.empty () && !warnings_vector
.empty ())
750 for (const std::string
&w
: warnings_vector
)
751 warning ("%s", w
.c_str ());
756 coff_new_init (struct objfile
*ignore
)
760 /* Perform any local cleanups required when we are done with a
761 particular objfile. I.E, we are in the process of discarding all
762 symbol information for an objfile, freeing up all memory held for
763 it, and unlinking the objfile struct from the global list of known
767 coff_symfile_finish (struct objfile
*objfile
)
769 /* Let stabs reader clean up. */
770 stabsread_clear_cache ();
774 /* Given pointers to a symbol table in coff style exec file,
775 analyze them and create struct symtab's describing the symbols.
776 NSYMS is the number of symbols in the symbol table.
777 We read them one at a time using read_one_sym (). */
780 coff_symtab_read (minimal_symbol_reader
&reader
,
781 file_ptr symtab_offset
, unsigned int nsyms
,
782 struct objfile
*objfile
)
784 struct gdbarch
*gdbarch
= objfile
->arch ();
785 struct context_stack
*newobj
= nullptr;
786 struct coff_symbol coff_symbol
;
787 struct coff_symbol
*cs
= &coff_symbol
;
788 static struct internal_syment main_sym
;
789 static union internal_auxent main_aux
;
790 struct coff_symbol fcn_cs_saved
;
791 static struct internal_syment fcn_sym_saved
;
792 static union internal_auxent fcn_aux_saved
;
793 /* A .file is open. */
794 int in_source_file
= 0;
795 int next_file_symnum
= -1;
796 /* Name of the current file. */
797 const char *filestring
= "";
799 int fcn_first_line
= 0;
800 CORE_ADDR fcn_first_line_addr
= 0;
801 int fcn_last_line
= 0;
802 int fcn_start_addr
= 0;
803 long fcn_line_ptr
= 0;
806 struct minimal_symbol
*msym
;
808 scoped_free_pendings free_pending
;
810 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
811 it's hard to know I've really worked around it. The fix should
812 be harmless, anyway). The symptom of the bug is that the first
813 fread (in read_one_sym), will (in my example) actually get data
814 from file offset 268, when the fseek was to 264 (and ftell shows
815 264). This causes all hell to break loose. I was unable to
816 reproduce this on a short test program which operated on the same
817 file, performing (I think) the same sequence of operations.
819 It stopped happening when I put in this (former) rewind().
821 FIXME: Find out if this has been reported to Sun, whether it has
822 been fixed in a later release, etc. */
824 bfd_seek (objfile
->obfd
.get (), 0, 0);
826 /* Position to read the symbol table. */
827 val
= bfd_seek (objfile
->obfd
.get (), symtab_offset
, 0);
829 perror_with_name (objfile_name (objfile
));
831 coffread_objfile
= objfile
;
832 nlist_bfd_global
= objfile
->obfd
.get ();
833 nlist_nsyms_global
= nsyms
;
834 set_last_source_file (NULL
);
835 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
837 if (type_vector
) /* Get rid of previous one. */
839 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
840 type_vector
= XCNEWVEC (struct type
*, type_vector_length
);
842 coff_start_compunit_symtab (objfile
, "");
845 while (symnum
< nsyms
)
847 QUIT
; /* Make this command interruptable. */
849 read_one_sym (cs
, &main_sym
, &main_aux
);
851 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
853 if (get_last_source_file ())
854 coff_end_compunit_symtab (objfile
);
856 coff_start_compunit_symtab (objfile
, "_globals_");
857 /* coff_start_compunit_symtab will set the language of this symtab to
858 language_unknown, since such a ``file name'' is not
859 recognized. Override that with the minimal language to
860 allow printing values in this symtab. */
861 get_current_subfile ()->language
= language_minimal
;
862 complete_symtab ("_globals_", 0, 0);
863 /* Done with all files, everything from here on out is
867 /* Special case for file with type declarations only, no
869 if (!get_last_source_file () && SDB_TYPE (cs
->c_type
)
870 && cs
->c_secnum
== N_DEBUG
)
871 complete_symtab (filestring
, 0, 0);
873 /* Typedefs should not be treated as symbol definitions. */
874 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
876 /* Record all functions -- external and static -- in
878 int section
= cs_to_section (cs
, objfile
);
880 tmpaddr
= cs
->c_value
;
881 /* Don't record unresolved symbols. */
882 if (!(cs
->c_secnum
<= 0 && cs
->c_value
== 0))
883 record_minimal_symbol (reader
, cs
, tmpaddr
, mst_text
,
886 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
887 fcn_start_addr
= tmpaddr
;
889 fcn_sym_saved
= main_sym
;
890 fcn_aux_saved
= main_aux
;
894 switch (cs
->c_sclass
)
903 complaint (_("Bad n_sclass for symbol %s"),
908 /* c_value field contains symnum of next .file entry in
909 table or symnum of first global after last .file. */
910 next_file_symnum
= cs
->c_value
;
912 filestring
= coff_getfilename (&main_aux
);
916 /* Complete symbol table for last object file
917 containing debugging information. */
918 if (get_last_source_file ())
920 coff_end_compunit_symtab (objfile
);
921 coff_start_compunit_symtab (objfile
, filestring
);
926 /* C_LABEL is used for labels and static functions.
927 Including it here allows gdb to see static functions when
928 no debug info is available. */
930 /* However, labels within a function can make weird
931 backtraces, so filter them out (from phdm@macqel.be). */
938 case C_THUMBSTATFUNC
:
939 if (cs
->c_name
[0] == '.')
941 if (strcmp (cs
->c_name
, ".text") == 0)
943 /* FIXME: don't wire in ".text" as section name or
945 /* Check for in_source_file deals with case of a
946 file with debugging symbols followed by a later
947 file with no symbols. */
949 complete_symtab (filestring
,
951 + objfile
->text_section_offset ()),
952 main_aux
.x_scn
.x_scnlen
);
955 /* Flush rest of '.' symbols. */
958 else if (!SDB_TYPE (cs
->c_type
)
959 && cs
->c_name
[0] == 'L'
960 && (startswith (cs
->c_name
, "LI%")
961 || startswith (cs
->c_name
, "LF%")
962 || startswith (cs
->c_name
, "LC%")
963 || startswith (cs
->c_name
, "LP%")
964 || startswith (cs
->c_name
, "LPB%")
965 || startswith (cs
->c_name
, "LBB%")
966 || startswith (cs
->c_name
, "LBE%")
967 || startswith (cs
->c_name
, "LPBX%")))
968 /* At least on a 3b1, gcc generates swbeg and string labels
969 that look like this. Ignore them. */
971 /* For static symbols that don't start with '.'... */
977 /* Record it in the minimal symbols regardless of
978 SDB_TYPE. This parallels what we do for other debug
979 formats, and probably is needed to make
980 print_address_symbolic work right without the (now
981 gone) "set fast-symbolic-addr off" kludge. */
983 enum minimal_symbol_type ms_type
;
985 CORE_ADDR offset
= 0;
987 if (cs
->c_secnum
== N_UNDEF
)
989 /* This is a common symbol. We used to rely on
990 the target to tell us whether it knows where
991 the symbol has been relocated to, but none of
992 the target implementations actually provided
993 that operation. So we just ignore the symbol,
994 the same way we would do if we had a target-side
995 symbol lookup which returned no match. */
998 else if (cs
->c_secnum
== N_ABS
)
1000 /* Use the correct minimal symbol type (and don't
1001 relocate) for absolute values. */
1003 sec
= cs_to_section (cs
, objfile
);
1004 tmpaddr
= cs
->c_value
;
1008 asection
*bfd_section
= cs_to_bfd_section (cs
, objfile
);
1010 sec
= cs_to_section (cs
, objfile
);
1011 tmpaddr
= cs
->c_value
;
1012 /* Statics in a PE file also get relocated. */
1013 if (cs
->c_sclass
== C_EXT
1014 || cs
->c_sclass
== C_THUMBEXTFUNC
1015 || cs
->c_sclass
== C_THUMBEXT
1016 || (pe_file
&& (cs
->c_sclass
== C_STAT
)))
1017 offset
= objfile
->section_offsets
[sec
];
1019 if (bfd_section
->flags
& SEC_CODE
)
1022 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
1023 || cs
->c_sclass
== C_THUMBEXT
?
1024 mst_text
: mst_file_text
;
1025 tmpaddr
= gdbarch_addr_bits_remove (gdbarch
, tmpaddr
);
1027 else if (bfd_section
->flags
& SEC_ALLOC
1028 && bfd_section
->flags
& SEC_LOAD
)
1031 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1032 ? mst_data
: mst_file_data
;
1034 else if (bfd_section
->flags
& SEC_ALLOC
)
1037 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1038 ? mst_bss
: mst_file_bss
;
1041 ms_type
= mst_unknown
;
1044 msym
= record_minimal_symbol (reader
, cs
, tmpaddr
, ms_type
,
1047 gdbarch_coff_make_msymbol_special (gdbarch
,
1048 cs
->c_sclass
, msym
);
1050 if (SDB_TYPE (cs
->c_type
))
1054 sym
= process_coff_symbol
1055 (cs
, &main_aux
, objfile
);
1056 sym
->set_value_longest (tmpaddr
+ offset
);
1057 sym
->set_section_index (sec
);
1063 if (strcmp (cs
->c_name
, ".bf") == 0)
1065 within_function
= 1;
1067 /* Value contains address of first non-init type
1069 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1070 contains line number of '{' }. */
1071 if (cs
->c_naux
!= 1)
1072 complaint (_("`.bf' symbol %d has no aux entry"),
1074 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1075 fcn_first_line_addr
= cs
->c_value
;
1077 /* Might want to check that locals are 0 and
1078 context_stack_depth is zero, and complain if not. */
1081 newobj
= push_context (depth
, fcn_start_addr
);
1082 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1084 process_coff_symbol (&fcn_cs_saved
,
1085 &fcn_aux_saved
, objfile
);
1087 else if (strcmp (cs
->c_name
, ".ef") == 0)
1089 if (!within_function
)
1090 error (_("Bad coff function information."));
1091 /* The value of .ef is the address of epilogue code;
1092 not useful for gdb. */
1093 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1094 contains number of lines to '}' */
1096 if (outermost_context_p ())
1097 { /* We attempted to pop an empty context stack. */
1098 complaint (_("`.ef' symbol without matching `.bf' "
1099 "symbol ignored starting at symnum %d"),
1101 within_function
= 0;
1105 struct context_stack cstk
= pop_context ();
1106 /* Stack must be empty now. */
1107 if (!outermost_context_p () || newobj
== NULL
)
1109 complaint (_("Unmatched .ef symbol(s) ignored "
1110 "starting at symnum %d"),
1112 within_function
= 0;
1115 if (cs
->c_naux
!= 1)
1117 complaint (_("`.ef' symbol %d has no aux entry"),
1119 fcn_last_line
= 0x7FFFFFFF;
1123 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1125 /* fcn_first_line is the line number of the opening '{'.
1126 Do not record it - because it would affect gdb's idea
1127 of the line number of the first statement of the
1128 function - except for one-line functions, for which
1129 it is also the line number of all the statements and
1130 of the closing '}', and for which we do not have any
1131 other statement-line-number. */
1132 if (fcn_last_line
== 1)
1133 record_line (get_current_subfile (), fcn_first_line
,
1134 gdbarch_addr_bits_remove (gdbarch
,
1135 fcn_first_line_addr
));
1137 enter_linenos (fcn_line_ptr
, fcn_first_line
,
1138 fcn_last_line
, objfile
);
1140 finish_block (cstk
.name
, cstk
.old_blocks
,
1141 NULL
, cstk
.start_addr
,
1142 fcn_cs_saved
.c_value
1143 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1144 + objfile
->text_section_offset ());
1145 within_function
= 0;
1150 if (strcmp (cs
->c_name
, ".bb") == 0)
1152 tmpaddr
= cs
->c_value
;
1153 tmpaddr
+= objfile
->text_section_offset ();
1154 push_context (++depth
, tmpaddr
);
1156 else if (strcmp (cs
->c_name
, ".eb") == 0)
1158 if (outermost_context_p ())
1159 { /* We attempted to pop an empty context stack. */
1160 complaint (_("`.eb' symbol without matching `.bb' "
1161 "symbol ignored starting at symnum %d"),
1166 struct context_stack cstk
= pop_context ();
1167 if (depth
-- != cstk
.depth
)
1169 complaint (_("Mismatched .eb symbol ignored "
1170 "starting at symnum %d"),
1174 if (*get_local_symbols () && !outermost_context_p ())
1176 tmpaddr
= cs
->c_value
+ objfile
->text_section_offset ();
1177 /* Make a block for the local symbols within. */
1178 finish_block (0, cstk
.old_blocks
, NULL
,
1179 cstk
.start_addr
, tmpaddr
);
1181 /* Now pop locals of block just finished. */
1182 *get_local_symbols () = cstk
.locals
;
1187 process_coff_symbol (cs
, &main_aux
, objfile
);
1192 if (get_last_source_file ())
1193 coff_end_compunit_symtab (objfile
);
1195 /* Patch up any opaque types (references to types that are not defined
1196 in the file where they are referenced, e.g. "struct foo *bar"). */
1198 for (compunit_symtab
*cu
: objfile
->compunits ())
1200 for (symtab
*s
: cu
->filetabs ())
1201 patch_opaque_types (s
);
1205 coffread_objfile
= NULL
;
1208 /* Routines for reading headers and symbols from executable. */
1210 /* Read the next symbol, swap it, and return it in both
1211 internal_syment form, and coff_symbol form. Also return its first
1212 auxent, if any, in internal_auxent form, and skip any other
1216 read_one_sym (struct coff_symbol
*cs
,
1217 struct internal_syment
*sym
,
1218 union internal_auxent
*aux
)
1221 bfd_size_type bytes
;
1223 cs
->c_symnum
= symnum
;
1224 bytes
= bfd_bread (temp_sym
, local_symesz
, nlist_bfd_global
);
1225 if (bytes
!= local_symesz
)
1226 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1227 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1228 cs
->c_naux
= sym
->n_numaux
& 0xff;
1229 if (cs
->c_naux
>= 1)
1231 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1232 if (bytes
!= local_auxesz
)
1233 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1234 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
,
1235 sym
->n_type
, sym
->n_sclass
,
1236 0, cs
->c_naux
, (char *) aux
);
1237 /* If more than one aux entry, read past it (only the first aux
1239 for (i
= 1; i
< cs
->c_naux
; i
++)
1241 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1242 if (bytes
!= local_auxesz
)
1243 error (_("%s: error reading symbols"),
1244 objfile_name (coffread_objfile
));
1247 cs
->c_name
= getsymname (sym
);
1248 cs
->c_value
= sym
->n_value
;
1249 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1250 cs
->c_secnum
= sym
->n_scnum
;
1251 cs
->c_type
= (unsigned) sym
->n_type
;
1252 if (!SDB_TYPE (cs
->c_type
))
1256 if (cs
->c_sclass
& 128)
1257 printf (_("thumb symbol %s, class 0x%x\n"), cs
->c_name
, cs
->c_sclass
);
1260 symnum
+= 1 + cs
->c_naux
;
1262 /* The PE file format stores symbol values as offsets within the
1263 section, rather than as absolute addresses. We correct that
1264 here, if the symbol has an appropriate storage class. FIXME: We
1265 should use BFD to read the symbols, rather than duplicating the
1269 switch (cs
->c_sclass
)
1273 case C_THUMBEXTFUNC
:
1278 case C_THUMBSTATFUNC
:
1284 if (cs
->c_secnum
!= 0)
1285 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1291 /* Support for string table handling. */
1294 init_stringtab (bfd
*abfd
, file_ptr offset
, gdb::unique_xmalloc_ptr
<char> *storage
)
1298 unsigned char lengthbuf
[4];
1300 /* If the file is stripped, the offset might be zero, indicating no
1301 string table. Just return with `stringtab' set to null. */
1305 if (bfd_seek (abfd
, offset
, 0) < 0)
1308 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1309 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1311 /* If no string table is needed, then the file may end immediately
1312 after the symbols. Just return with `stringtab' set to null. */
1313 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1316 storage
->reset ((char *) xmalloc (length
));
1317 stringtab
= storage
->get ();
1318 /* This is in target format (probably not very useful, and not
1319 currently used), not host format. */
1320 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1321 if (length
== sizeof length
) /* Empty table -- just the count. */
1324 val
= bfd_bread (stringtab
+ sizeof lengthbuf
,
1325 length
- sizeof lengthbuf
, abfd
);
1326 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1333 getsymname (struct internal_syment
*symbol_entry
)
1335 static char buffer
[SYMNMLEN
+ 1];
1338 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1340 /* FIXME: Probably should be detecting corrupt symbol files by
1341 seeing whether offset points to within the stringtab. */
1342 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1346 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1347 buffer
[SYMNMLEN
] = '\0';
1353 /* Extract the file name from the aux entry of a C_FILE symbol.
1354 Return only the last component of the name. Result is in static
1355 storage and is only good for temporary use. */
1358 coff_getfilename (union internal_auxent
*aux_entry
)
1360 static char buffer
[BUFSIZ
];
1363 if (aux_entry
->x_file
.x_n
.x_n
.x_zeroes
== 0)
1365 if (strlen (stringtab
+ aux_entry
->x_file
.x_n
.x_n
.x_offset
) >= BUFSIZ
)
1366 internal_error (_("coff file name too long"));
1367 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_n
.x_offset
);
1371 strncpy (buffer
, aux_entry
->x_file
.x_n
.x_fname
, FILNMLEN
);
1372 buffer
[FILNMLEN
] = '\0';
1376 /* FIXME: We should not be throwing away the information about what
1377 directory. It should go into dirname of the symtab, or some such
1379 result
= lbasename (result
);
1383 /* Support for line number handling. */
1385 /* Read in all the line numbers for fast lookups later. Leave them in
1386 external (unswapped) format in memory; we'll swap them as we enter
1387 them into GDB's data structures. */
1390 init_lineno (bfd
*abfd
, file_ptr offset
, file_ptr size
,
1391 gdb::unique_xmalloc_ptr
<char> *storage
)
1395 linetab_offset
= offset
;
1396 linetab_size
= size
;
1401 if (bfd_seek (abfd
, offset
, 0) < 0)
1404 /* Allocate the desired table, plus a sentinel. */
1405 storage
->reset ((char *) xmalloc (size
+ local_linesz
));
1406 linetab
= storage
->get ();
1408 val
= bfd_bread (storage
->get (), size
, abfd
);
1412 /* Terminate it with an all-zero sentinel record. */
1413 memset (linetab
+ size
, 0, local_linesz
);
1418 #if !defined (L_LNNO32)
1419 #define L_LNNO32(lp) ((lp)->l_lnno)
1423 enter_linenos (file_ptr file_offset
, int first_line
,
1424 int last_line
, struct objfile
*objfile
)
1426 struct gdbarch
*gdbarch
= objfile
->arch ();
1428 struct internal_lineno lptr
;
1432 if (file_offset
< linetab_offset
)
1434 complaint (_("Line number pointer %s lower than start of line numbers"),
1435 plongest (file_offset
));
1436 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1438 file_offset
+= linetab_offset
; /* Try reading at that linetab
1442 rawptr
= &linetab
[file_offset
- linetab_offset
];
1444 /* Skip first line entry for each function. */
1445 rawptr
+= local_linesz
;
1446 /* Line numbers start at one for the first line of the function. */
1449 /* If the line number table is full (e.g. 64K lines in COFF debug
1450 info), the next function's L_LNNO32 might not be zero, so don't
1451 overstep the table's end in any case. */
1452 while (rawptr
<= &linetab
[0] + linetab_size
)
1454 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1455 rawptr
+= local_linesz
;
1456 /* The next function, or the sentinel, will have L_LNNO32 zero;
1458 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1460 CORE_ADDR addr
= lptr
.l_addr
.l_paddr
;
1461 addr
+= objfile
->text_section_offset ();
1462 record_line (get_current_subfile (),
1463 first_line
+ L_LNNO32 (&lptr
),
1464 gdbarch_addr_bits_remove (gdbarch
, addr
));
1472 patch_type (struct type
*type
, struct type
*real_type
)
1474 struct type
*target
= type
->target_type ();
1475 struct type
*real_target
= real_type
->target_type ();
1476 int field_size
= real_target
->num_fields () * sizeof (struct field
);
1478 target
->set_length (real_target
->length ());
1479 target
->set_num_fields (real_target
->num_fields ());
1481 field
*fields
= (struct field
*) TYPE_ALLOC (target
, field_size
);
1482 memcpy (fields
, real_target
->fields (), field_size
);
1483 target
->set_fields (fields
);
1485 if (real_target
->name ())
1487 /* The previous copy of TYPE_NAME is allocated by
1488 process_coff_symbol. */
1489 xfree ((char *) target
->name ());
1490 target
->set_name (xstrdup (real_target
->name ()));
1494 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1495 so that they can be used to print out opaque data structures
1499 patch_opaque_types (struct symtab
*s
)
1501 /* Go through the per-file symbols only. */
1502 const struct block
*b
= s
->compunit ()->blockvector ()->static_block ();
1503 for (struct symbol
*real_sym
: block_iterator_range (b
))
1505 /* Find completed typedefs to use to fix opaque ones.
1506 Remove syms from the chain when their types are stored,
1507 but search the whole chain, as there may be several syms
1508 from different files with the same name. */
1509 if (real_sym
->aclass () == LOC_TYPEDEF
1510 && real_sym
->domain () == VAR_DOMAIN
1511 && real_sym
->type ()->code () == TYPE_CODE_PTR
1512 && real_sym
->type ()->target_type ()->length () != 0)
1514 const char *name
= real_sym
->linkage_name ();
1515 int hash
= hashname (name
);
1516 struct symbol
*sym
, *prev
;
1519 for (sym
= opaque_type_chain
[hash
]; sym
;)
1521 if (name
[0] == sym
->linkage_name ()[0]
1522 && strcmp (name
+ 1, sym
->linkage_name () + 1) == 0)
1525 prev
->set_value_chain (sym
->value_chain ());
1527 opaque_type_chain
[hash
] = sym
->value_chain ();
1529 patch_type (sym
->type (), real_sym
->type ());
1532 sym
= prev
->value_chain ();
1534 sym
= opaque_type_chain
[hash
];
1539 sym
->set_value_chain (sym
);
1547 coff_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
1549 return gdbarch_sdb_reg_to_regnum (gdbarch
, sym
->value_longest ());
1552 static const struct symbol_register_ops coff_register_funcs
= {
1556 /* The "aclass" index for computed COFF symbols. */
1558 static int coff_register_index
;
1560 static struct symbol
*
1561 process_coff_symbol (struct coff_symbol
*cs
,
1562 union internal_auxent
*aux
,
1563 struct objfile
*objfile
)
1565 struct symbol
*sym
= new (&objfile
->objfile_obstack
) symbol
;
1569 name
= EXTERNAL_NAME (name
, objfile
->obfd
.get ());
1570 sym
->set_language (get_current_subfile ()->language
,
1571 &objfile
->objfile_obstack
);
1572 sym
->compute_and_set_names (name
, true, objfile
->per_bfd
);
1574 /* default assumptions */
1575 sym
->set_value_longest (cs
->c_value
);
1576 sym
->set_domain (VAR_DOMAIN
);
1577 sym
->set_section_index (cs_to_section (cs
, objfile
));
1579 if (ISFCN (cs
->c_type
))
1581 sym
->set_value_longest
1582 (sym
->value_longest () + objfile
->text_section_offset ());
1584 (lookup_function_type (decode_function_type (cs
, cs
->c_type
,
1587 sym
->set_aclass_index (LOC_BLOCK
);
1588 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1589 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1590 add_symbol_to_list (sym
, get_file_symbols ());
1591 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1592 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1593 add_symbol_to_list (sym
, get_global_symbols ());
1597 sym
->set_type (decode_type (cs
, cs
->c_type
, aux
, objfile
));
1598 switch (cs
->c_sclass
)
1604 sym
->set_aclass_index (LOC_LOCAL
);
1605 add_symbol_to_list (sym
, get_local_symbols ());
1609 case C_THUMBEXTFUNC
:
1611 sym
->set_aclass_index (LOC_STATIC
);
1612 sym
->set_value_address ((CORE_ADDR
) cs
->c_value
1613 + objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)]);
1614 add_symbol_to_list (sym
, get_global_symbols ());
1618 case C_THUMBSTATFUNC
:
1620 sym
->set_aclass_index (LOC_STATIC
);
1621 sym
->set_value_address ((CORE_ADDR
) cs
->c_value
1622 + objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)]);
1623 if (within_function
)
1625 /* Static symbol of local scope. */
1626 add_symbol_to_list (sym
, get_local_symbols ());
1630 /* Static symbol at top level of file. */
1631 add_symbol_to_list (sym
, get_file_symbols ());
1635 #ifdef C_GLBLREG /* AMD coff */
1639 sym
->set_aclass_index (coff_register_index
);
1640 sym
->set_value_longest (cs
->c_value
);
1641 add_symbol_to_list (sym
, get_local_symbols ());
1649 sym
->set_aclass_index (LOC_ARG
);
1650 sym
->set_is_argument (1);
1651 add_symbol_to_list (sym
, get_local_symbols ());
1655 sym
->set_aclass_index (coff_register_index
);
1656 sym
->set_is_argument (1);
1657 sym
->set_value_longest (cs
->c_value
);
1658 add_symbol_to_list (sym
, get_local_symbols ());
1662 sym
->set_aclass_index (LOC_TYPEDEF
);
1663 sym
->set_domain (VAR_DOMAIN
);
1665 /* If type has no name, give it one. */
1666 if (sym
->type ()->name () == 0)
1668 if (sym
->type ()->code () == TYPE_CODE_PTR
1669 || sym
->type ()->code () == TYPE_CODE_FUNC
)
1671 /* If we are giving a name to a type such as
1672 "pointer to foo" or "function returning foo", we
1673 better not set the TYPE_NAME. If the program
1674 contains "typedef char *caddr_t;", we don't want
1675 all variables of type char * to print as caddr_t.
1676 This is not just a consequence of GDB's type
1677 management; CC and GCC (at least through version
1678 2.4) both output variables of either type char *
1679 or caddr_t with the type refering to the C_TPDEF
1680 symbol for caddr_t. If a future compiler cleans
1681 this up it GDB is not ready for it yet, but if it
1682 becomes ready we somehow need to disable this
1683 check (without breaking the PCC/GCC2.4 case).
1687 Fortunately, this check seems not to be necessary
1688 for anything except pointers or functions. */
1692 sym
->type ()->set_name (xstrdup (sym
->linkage_name ()));
1695 /* Keep track of any type which points to empty structured
1696 type, so it can be filled from a definition from another
1697 file. A simple forward reference (TYPE_CODE_UNDEF) is
1698 not an empty structured type, though; the forward
1699 references work themselves out via the magic of
1700 coff_lookup_type. */
1701 if (sym
->type ()->code () == TYPE_CODE_PTR
1702 && sym
->type ()->target_type ()->length () == 0
1703 && sym
->type ()->target_type ()->code ()
1706 int i
= hashname (sym
->linkage_name ());
1708 sym
->set_value_chain (opaque_type_chain
[i
]);
1709 opaque_type_chain
[i
] = sym
;
1711 add_symbol_to_list (sym
, get_file_symbols ());
1717 sym
->set_aclass_index (LOC_TYPEDEF
);
1718 sym
->set_domain (STRUCT_DOMAIN
);
1720 /* Some compilers try to be helpful by inventing "fake"
1721 names for anonymous enums, structures, and unions, like
1722 "~0fake" or ".0fake". Thanks, but no thanks... */
1723 if (sym
->type ()->name () == 0)
1724 if (sym
->linkage_name () != NULL
1725 && *sym
->linkage_name () != '~'
1726 && *sym
->linkage_name () != '.')
1727 sym
->type ()->set_name (xstrdup (sym
->linkage_name ()));
1729 add_symbol_to_list (sym
, get_file_symbols ());
1739 /* Decode a coff type specifier; return the type that is meant. */
1741 static struct type
*
1742 decode_type (struct coff_symbol
*cs
, unsigned int c_type
,
1743 union internal_auxent
*aux
, struct objfile
*objfile
)
1745 struct type
*type
= 0;
1746 unsigned int new_c_type
;
1748 if (c_type
& ~N_BTMASK
)
1750 new_c_type
= DECREF (c_type
);
1753 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1754 type
= lookup_pointer_type (type
);
1756 else if (ISFCN (c_type
))
1758 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1759 type
= lookup_function_type (type
);
1761 else if (ISARY (c_type
))
1764 unsigned short *dim
;
1765 struct type
*base_type
, *index_type
, *range_type
;
1767 /* Define an array type. */
1768 /* auxent refers to array, not base type. */
1769 if (aux
->x_sym
.x_tagndx
.l
== 0)
1772 /* Shift the indices down. */
1773 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1776 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1780 base_type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1781 index_type
= objfile_type (objfile
)->builtin_int
;
1783 = create_static_range_type (NULL
, index_type
, 0, n
- 1);
1785 create_array_type (NULL
, base_type
, range_type
);
1790 /* Reference to existing type. This only occurs with the struct,
1791 union, and enum types. EPI a29k coff fakes us out by producing
1792 aux entries with a nonzero x_tagndx for definitions of structs,
1793 unions, and enums, so we have to check the c_sclass field. SCO
1794 3.2v4 cc gets confused with pointers to pointers to defined
1795 structs, and generates negative x_tagndx fields. */
1796 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1798 if (cs
->c_sclass
!= C_STRTAG
1799 && cs
->c_sclass
!= C_UNTAG
1800 && cs
->c_sclass
!= C_ENTAG
1801 && aux
->x_sym
.x_tagndx
.l
>= 0)
1803 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1808 complaint (_("Symbol table entry for %s has bad tagndx value"),
1810 /* And fall through to decode_base_type... */
1814 return decode_base_type (cs
, BTYPE (c_type
), aux
, objfile
);
1817 /* Decode a coff type specifier for function definition;
1818 return the type that the function returns. */
1820 static struct type
*
1821 decode_function_type (struct coff_symbol
*cs
,
1822 unsigned int c_type
,
1823 union internal_auxent
*aux
,
1824 struct objfile
*objfile
)
1826 if (aux
->x_sym
.x_tagndx
.l
== 0)
1827 cs
->c_naux
= 0; /* auxent refers to function, not base
1830 return decode_type (cs
, DECREF (c_type
), aux
, objfile
);
1833 /* Basic C types. */
1835 static struct type
*
1836 decode_base_type (struct coff_symbol
*cs
,
1837 unsigned int c_type
,
1838 union internal_auxent
*aux
,
1839 struct objfile
*objfile
)
1841 struct gdbarch
*gdbarch
= objfile
->arch ();
1847 /* Shows up with "void (*foo)();" structure members. */
1848 return objfile_type (objfile
)->builtin_void
;
1852 /* Intel 960 COFF has this symbol and meaning. */
1853 return objfile_type (objfile
)->builtin_void
;
1857 return objfile_type (objfile
)->builtin_char
;
1860 return objfile_type (objfile
)->builtin_short
;
1863 return objfile_type (objfile
)->builtin_int
;
1866 if (cs
->c_sclass
== C_FIELD
1867 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1868 > gdbarch_long_bit (gdbarch
))
1869 return objfile_type (objfile
)->builtin_long_long
;
1871 return objfile_type (objfile
)->builtin_long
;
1874 return objfile_type (objfile
)->builtin_float
;
1877 return objfile_type (objfile
)->builtin_double
;
1880 return objfile_type (objfile
)->builtin_long_double
;
1883 if (cs
->c_naux
!= 1)
1885 /* Anonymous structure type. */
1886 type
= coff_alloc_type (cs
->c_symnum
);
1887 type
->set_code (TYPE_CODE_STRUCT
);
1888 type
->set_name (NULL
);
1889 INIT_CPLUS_SPECIFIC (type
);
1890 type
->set_length (0);
1891 type
->set_fields (nullptr);
1892 type
->set_num_fields (0);
1896 type
= coff_read_struct_type (cs
->c_symnum
,
1897 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1898 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1904 if (cs
->c_naux
!= 1)
1906 /* Anonymous union type. */
1907 type
= coff_alloc_type (cs
->c_symnum
);
1908 type
->set_name (NULL
);
1909 INIT_CPLUS_SPECIFIC (type
);
1910 type
->set_length (0);
1911 type
->set_fields (nullptr);
1912 type
->set_num_fields (0);
1916 type
= coff_read_struct_type (cs
->c_symnum
,
1917 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1918 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1921 type
->set_code (TYPE_CODE_UNION
);
1925 if (cs
->c_naux
!= 1)
1927 /* Anonymous enum type. */
1928 type
= coff_alloc_type (cs
->c_symnum
);
1929 type
->set_code (TYPE_CODE_ENUM
);
1930 type
->set_name (NULL
);
1931 type
->set_length (0);
1932 type
->set_fields (nullptr);
1933 type
->set_num_fields (0);
1937 type
= coff_read_enum_type (cs
->c_symnum
,
1938 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1939 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1945 /* Shouldn't show up here. */
1949 return objfile_type (objfile
)->builtin_unsigned_char
;
1952 return objfile_type (objfile
)->builtin_unsigned_short
;
1955 return objfile_type (objfile
)->builtin_unsigned_int
;
1958 if (cs
->c_sclass
== C_FIELD
1959 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1960 > gdbarch_long_bit (gdbarch
))
1961 return objfile_type (objfile
)->builtin_unsigned_long_long
;
1963 return objfile_type (objfile
)->builtin_unsigned_long
;
1965 complaint (_("Unexpected type for symbol %s"), cs
->c_name
);
1966 return objfile_type (objfile
)->builtin_void
;
1969 /* This page contains subroutines of read_type. */
1971 /* Read the description of a structure (or union type) and return an
1972 object describing the type. */
1974 static struct type
*
1975 coff_read_struct_type (int index
, int length
, int lastsym
,
1976 struct objfile
*objfile
)
1980 struct nextfield
*next
;
1985 struct nextfield
*list
= 0;
1986 struct nextfield
*newobj
;
1990 struct coff_symbol member_sym
;
1991 struct coff_symbol
*ms
= &member_sym
;
1992 struct internal_syment sub_sym
;
1993 union internal_auxent sub_aux
;
1996 type
= coff_alloc_type (index
);
1997 type
->set_code (TYPE_CODE_STRUCT
);
1998 INIT_CPLUS_SPECIFIC (type
);
1999 type
->set_length (length
);
2001 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2003 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2005 name
= EXTERNAL_NAME (name
, objfile
->obfd
.get ());
2007 switch (ms
->c_sclass
)
2012 /* Get space to record the next field's data. */
2013 newobj
= XALLOCA (struct nextfield
);
2014 newobj
->next
= list
;
2017 /* Save the data. */
2018 list
->field
.set_name (obstack_strdup (&objfile
->objfile_obstack
,
2020 list
->field
.set_type (decode_type (ms
, ms
->c_type
, &sub_aux
,
2022 list
->field
.set_loc_bitpos (8 * ms
->c_value
);
2023 FIELD_BITSIZE (list
->field
) = 0;
2029 /* Get space to record the next field's data. */
2030 newobj
= XALLOCA (struct nextfield
);
2031 newobj
->next
= list
;
2034 /* Save the data. */
2035 list
->field
.set_name (obstack_strdup (&objfile
->objfile_obstack
,
2037 list
->field
.set_type (decode_type (ms
, ms
->c_type
, &sub_aux
,
2039 list
->field
.set_loc_bitpos (ms
->c_value
);
2040 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2049 /* Now create the vector of fields, and record how big it is. */
2051 type
->set_num_fields (nfields
);
2053 ((struct field
*) TYPE_ALLOC (type
, sizeof (struct field
) * nfields
));
2055 /* Copy the saved-up fields into the field vector. */
2057 for (n
= nfields
; list
; list
= list
->next
)
2058 type
->field (--n
) = list
->field
;
2063 /* Read a definition of an enumeration type,
2064 and create and return a suitable type object.
2065 Also defines the symbols that represent the values of the type. */
2067 static struct type
*
2068 coff_read_enum_type (int index
, int length
, int lastsym
,
2069 struct objfile
*objfile
)
2071 struct gdbarch
*gdbarch
= objfile
->arch ();
2076 struct pending
**symlist
;
2077 struct coff_symbol member_sym
;
2078 struct coff_symbol
*ms
= &member_sym
;
2079 struct internal_syment sub_sym
;
2080 union internal_auxent sub_aux
;
2081 struct pending
*osyms
, *syms
;
2085 int unsigned_enum
= 1;
2087 type
= coff_alloc_type (index
);
2088 if (within_function
)
2089 symlist
= get_local_symbols ();
2091 symlist
= get_file_symbols ();
2093 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2095 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2097 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2099 name
= EXTERNAL_NAME (name
, objfile
->obfd
.get ());
2101 switch (ms
->c_sclass
)
2104 sym
= new (&objfile
->objfile_obstack
) symbol
;
2106 name
= obstack_strdup (&objfile
->objfile_obstack
, name
);
2107 sym
->set_linkage_name (name
);
2108 sym
->set_aclass_index (LOC_CONST
);
2109 sym
->set_domain (VAR_DOMAIN
);
2110 sym
->set_value_longest (ms
->c_value
);
2111 add_symbol_to_list (sym
, symlist
);
2116 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2117 up the count of how many symbols to read. So stop
2124 /* Now fill in the fields of the type-structure. */
2127 type
->set_length (length
);
2128 else /* Assume ints. */
2129 type
->set_length (gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
);
2130 type
->set_code (TYPE_CODE_ENUM
);
2131 type
->set_num_fields (nsyms
);
2133 ((struct field
*) TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
));
2135 /* Find the symbols for the values and put them into the type.
2136 The symbols can be found in the symlist that we put them on
2137 to cause them to be defined. osyms contains the old value
2138 of that symlist; everything up to there was defined by us. */
2139 /* Note that we preserve the order of the enum constants, so
2140 that in something like "enum {FOO, LAST_THING=FOO}" we print
2141 FOO, not LAST_THING. */
2143 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2149 for (; j
< syms
->nsyms
; j
++, n
++)
2151 struct symbol
*xsym
= syms
->symbol
[j
];
2153 xsym
->set_type (type
);
2154 type
->field (n
).set_name (xsym
->linkage_name ());
2155 type
->field (n
).set_loc_enumval (xsym
->value_longest ());
2156 if (xsym
->value_longest () < 0)
2158 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2165 type
->set_is_unsigned (true);
2170 /* Register our ability to parse symbols for coff BFD files. */
2172 static const struct sym_fns coff_sym_fns
=
2174 coff_new_init
, /* sym_new_init: init anything gbl to
2176 coff_symfile_init
, /* sym_init: read initial info, setup
2178 coff_symfile_read
, /* sym_read: read a symbol file into
2180 coff_symfile_finish
, /* sym_finish: finished with file,
2182 default_symfile_offsets
, /* sym_offsets: xlate external to
2184 default_symfile_segments
, /* sym_segments: Get segment
2185 information from a file */
2186 NULL
, /* sym_read_linetable */
2188 default_symfile_relocate
, /* sym_relocate: Relocate a debug
2190 NULL
, /* sym_probe_fns */
2193 void _initialize_coffread ();
2195 _initialize_coffread ()
2197 add_symtab_fns (bfd_target_coff_flavour
, &coff_sym_fns
);
2200 = register_symbol_register_impl (LOC_REGISTER
, &coff_register_funcs
);