1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2019 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 "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 "gdb-stabs.h"
35 #include "stabsread.h"
36 #include "complaints.h"
39 #include "dictionary.h"
41 #include "coff-pe-read.h"
46 /* Key for COFF-associated data. */
48 static const struct objfile_data
*coff_objfile_data_key
;
50 /* The objfile we are currently reading. */
52 static struct objfile
*coffread_objfile
;
54 struct coff_symfile_info
56 file_ptr min_lineno_offset
; /* Where in file lowest line#s are. */
57 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file. */
59 CORE_ADDR textaddr
; /* Addr of .text section. */
60 unsigned int textsize
; /* Size of .text section. */
61 std::vector
<asection
*> *stabsects
; /* .stab sections. */
62 asection
*stabstrsect
; /* Section pointer for .stab section. */
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 long linetab_offset
;
160 static unsigned long 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 (long, int, int, struct objfile
*);
194 static int init_lineno (bfd
*, long, int, 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
*, long, 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 long, 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_get_section_name (abfd
, sectp
);
227 if (strcmp (name
, ".text") == 0)
229 csi
->textaddr
= bfd_section_vma (abfd
, sectp
);
230 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
232 else if (startswith (name
, ".text"))
234 csi
->textsize
+= bfd_section_size (abfd
, 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 find_targ_sec_arg
264 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
266 struct find_targ_sec_arg
*args
= (struct 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 find_targ_sec_arg args
;
279 args
.targ_index
= cs
->c_secnum
;
280 args
.resultp
= §
;
281 bfd_map_over_sections (objfile
->obfd
, 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
, 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 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_get_section_vma (abfd
, 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_symtab (struct objfile
*objfile
, const char *name
)
371 start_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_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_symtab (struct objfile
*objfile
)
405 set_last_source_start_addr (current_source_start_addr
);
407 end_symtab (current_source_end_addr
, SECT_OFF_TEXT (objfile
));
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 characterictics
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 itselfs in backtraces, or any
461 other commands that prints symbolic addresses. Just pretend
462 these symbols do not exist. */
466 return reader
.record_with_info (cs
->c_name
, 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 struct dbx_symfile_info
*dbx
;
487 struct coff_symfile_info
*coff
;
489 /* Allocate struct to keep track of stab reading. */
490 dbx
= XCNEW (struct dbx_symfile_info
);
491 set_objfile_data (objfile
, dbx_objfile_data_key
, dbx
);
493 /* Allocate struct to keep track of the symfile. */
494 coff
= XCNEW (struct coff_symfile_info
);
495 set_objfile_data (objfile
, coff_objfile_data_key
, coff
);
497 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
498 find this causes a significant slowdown in gdb then we could
499 set it in the debug symbol readers only when necessary. */
500 objfile
->flags
|= OBJF_REORDERED
;
503 /* This function is called for every section; it finds the outer
504 limits of the line table (minimum and maximum file offset) so that
505 the mainline code can read the whole thing for efficiency. */
508 find_linenos (bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
510 struct coff_symfile_info
*info
;
512 file_ptr offset
, maxoff
;
514 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
515 count
= asect
->lineno_count
;
516 /* End of warning. */
520 size
= count
* local_linesz
;
522 info
= (struct coff_symfile_info
*) vpinfo
;
523 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
524 offset
= asect
->line_filepos
;
525 /* End of warning. */
527 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
528 info
->min_lineno_offset
= offset
;
530 maxoff
= offset
+ size
;
531 if (maxoff
> info
->max_lineno_offset
)
532 info
->max_lineno_offset
= maxoff
;
536 /* The BFD for this file -- only good while we're actively reading
537 symbols into a psymtab or a symtab. */
539 static bfd
*symfile_bfd
;
541 /* Read a symbol file, after initialization by coff_symfile_init. */
544 coff_symfile_read (struct objfile
*objfile
, symfile_add_flags symfile_flags
)
546 struct coff_symfile_info
*info
;
547 bfd
*abfd
= objfile
->obfd
;
548 coff_data_type
*cdata
= coff_data (abfd
);
549 char *filename
= bfd_get_filename (abfd
);
551 unsigned int num_symbols
;
553 int stringtab_offset
;
556 info
= (struct coff_symfile_info
*) objfile_data (objfile
,
557 coff_objfile_data_key
);
558 symfile_bfd
= abfd
; /* Kludge for swap routines. */
560 std::vector
<asection
*> stabsects
;
561 scoped_restore restore_stabsects
562 = make_scoped_restore (&info
->stabsects
, &stabsects
);
564 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
565 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
566 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
567 stringtab_offset
= symtab_offset
+ /* String table file offset */
568 num_symbols
* cdata
->local_symesz
;
570 /* Set a few file-statics that give us specific information about
571 the particular COFF file format we're reading. */
572 local_n_btmask
= cdata
->local_n_btmask
;
573 local_n_btshft
= cdata
->local_n_btshft
;
574 local_n_tmask
= cdata
->local_n_tmask
;
575 local_n_tshift
= cdata
->local_n_tshift
;
576 local_linesz
= cdata
->local_linesz
;
577 local_symesz
= cdata
->local_symesz
;
578 local_auxesz
= cdata
->local_auxesz
;
580 /* Allocate space for raw symbol and aux entries, based on their
581 space requirements as reported by BFD. */
582 gdb::def_vector
<char> temp_storage (cdata
->local_symesz
583 + cdata
->local_auxesz
);
584 temp_sym
= temp_storage
.data ();
585 temp_aux
= temp_sym
+ cdata
->local_symesz
;
587 /* We need to know whether this is a PE file, because in PE files,
588 unlike standard COFF files, symbol values are stored as offsets
589 from the section address, rather than as absolute addresses.
590 FIXME: We should use BFD to read the symbol table, and thus avoid
593 startswith (bfd_get_target (objfile
->obfd
), "pe")
594 || startswith (bfd_get_target (objfile
->obfd
), "epoc-pe");
596 /* End of warning. */
598 info
->min_lineno_offset
= 0;
599 info
->max_lineno_offset
= 0;
601 /* Only read line number information if we have symbols.
603 On Windows NT, some of the system's DLL's have sections with
604 PointerToLinenumbers fields that are non-zero, but point at
605 random places within the image file. (In the case I found,
606 KERNEL32.DLL's .text section has a line number info pointer that
607 points into the middle of the string `lib\\i386\kernel32.dll'.)
609 However, these DLL's also have no symbols. The line number
610 tables are meaningless without symbols. And in fact, GDB never
611 uses the line number information unless there are symbols. So we
612 can avoid spurious error messages (and maybe run a little
613 faster!) by not even reading the line number table unless we have
615 scoped_restore restore_linetab
= make_scoped_restore (&linetab
);
616 gdb::unique_xmalloc_ptr
<char> linetab_storage
;
619 /* Read the line number table, all at once. */
620 bfd_map_over_sections (abfd
, find_linenos
, (void *) info
);
622 val
= init_lineno (abfd
, info
->min_lineno_offset
,
623 info
->max_lineno_offset
- info
->min_lineno_offset
,
626 error (_("\"%s\": error reading line numbers."), filename
);
629 /* Now read the string table, all at once. */
631 scoped_restore restore_stringtab
= make_scoped_restore (&stringtab
);
632 gdb::unique_xmalloc_ptr
<char> stringtab_storage
;
633 val
= init_stringtab (abfd
, stringtab_offset
, &stringtab_storage
);
635 error (_("\"%s\": can't get string table"), filename
);
637 minimal_symbol_reader
reader (objfile
);
639 /* Now that the executable file is positioned at symbol table,
640 process it and define symbols accordingly. */
642 coff_symtab_read (reader
, (long) symtab_offset
, num_symbols
, objfile
);
644 /* Install any minimal symbols that have been collected as the
645 current minimal symbols for this objfile. */
651 for (minimal_symbol
*msym
: objfile
->msymbols ())
653 const char *name
= MSYMBOL_LINKAGE_NAME (msym
);
655 /* If the minimal symbols whose name are prefixed by "__imp_"
656 or "_imp_", get rid of the prefix, and search the minimal
657 symbol in OBJFILE. Note that 'maintenance print msymbols'
658 shows that type of these "_imp_XXXX" symbols is mst_data. */
659 if (MSYMBOL_TYPE (msym
) == mst_data
)
661 const char *name1
= NULL
;
663 if (startswith (name
, "_imp_"))
665 else if (startswith (name
, "__imp_"))
669 int lead
= bfd_get_symbol_leading_char (objfile
->obfd
);
670 struct bound_minimal_symbol found
;
672 if (lead
!= '\0' && *name1
== lead
)
675 found
= lookup_minimal_symbol (name1
, NULL
, objfile
);
677 /* If found, there are symbols named "_imp_foo" and "foo"
678 respectively in OBJFILE. Set the type of symbol "foo"
679 as 'mst_solib_trampoline'. */
680 if (found
.minsym
!= NULL
681 && MSYMBOL_TYPE (found
.minsym
) == mst_text
)
682 MSYMBOL_TYPE (found
.minsym
) = mst_solib_trampoline
;
688 if (!(objfile
->flags
& OBJF_READNEVER
))
689 bfd_map_over_sections (abfd
, coff_locate_sections
, (void *) info
);
691 if (!info
->stabsects
->empty())
693 if (!info
->stabstrsect
)
695 error (_("The debugging information in `%s' is corrupted.\nThe "
696 "file has a `.stabs' section, but no `.stabstr' section."),
700 /* FIXME: dubious. Why can't we use something normal like
701 bfd_get_section_contents? */
702 bfd_seek (abfd
, abfd
->where
, 0);
704 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
706 coffstab_build_psymtabs (objfile
,
707 info
->textaddr
, info
->textsize
,
709 info
->stabstrsect
->filepos
, stabstrsize
);
711 if (dwarf2_has_info (objfile
, NULL
))
713 /* DWARF2 sections. */
714 dwarf2_build_psymtabs (objfile
);
717 dwarf2_build_frame_info (objfile
);
719 /* Try to add separate debug file if no symbols table found. */
720 if (!objfile_has_partial_symbols (objfile
))
722 std::string debugfile
= find_separate_debug_file_by_buildid (objfile
);
724 if (debugfile
.empty ())
725 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
727 if (!debugfile
.empty ())
729 gdb_bfd_ref_ptr
debug_bfd (symfile_bfd_open (debugfile
.c_str ()));
731 symbol_file_add_separate (debug_bfd
.get (), debugfile
.c_str (),
732 symfile_flags
, objfile
);
738 coff_new_init (struct objfile
*ignore
)
742 /* Perform any local cleanups required when we are done with a
743 particular objfile. I.E, we are in the process of discarding all
744 symbol information for an objfile, freeing up all memory held for
745 it, and unlinking the objfile struct from the global list of known
749 coff_symfile_finish (struct objfile
*objfile
)
751 /* Let stabs reader clean up. */
752 stabsread_clear_cache ();
756 /* Given pointers to a symbol table in coff style exec file,
757 analyze them and create struct symtab's describing the symbols.
758 NSYMS is the number of symbols in the symbol table.
759 We read them one at a time using read_one_sym (). */
762 coff_symtab_read (minimal_symbol_reader
&reader
,
763 long symtab_offset
, unsigned int nsyms
,
764 struct objfile
*objfile
)
766 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
767 struct context_stack
*newobj
= nullptr;
768 struct coff_symbol coff_symbol
;
769 struct coff_symbol
*cs
= &coff_symbol
;
770 static struct internal_syment main_sym
;
771 static union internal_auxent main_aux
;
772 struct coff_symbol fcn_cs_saved
;
773 static struct internal_syment fcn_sym_saved
;
774 static union internal_auxent fcn_aux_saved
;
775 /* A .file is open. */
776 int in_source_file
= 0;
777 int next_file_symnum
= -1;
778 /* Name of the current file. */
779 const char *filestring
= "";
781 int fcn_first_line
= 0;
782 CORE_ADDR fcn_first_line_addr
= 0;
783 int fcn_last_line
= 0;
784 int fcn_start_addr
= 0;
785 long fcn_line_ptr
= 0;
788 struct minimal_symbol
*msym
;
790 scoped_free_pendings free_pending
;
792 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
793 it's hard to know I've really worked around it. The fix should
794 be harmless, anyway). The symptom of the bug is that the first
795 fread (in read_one_sym), will (in my example) actually get data
796 from file offset 268, when the fseek was to 264 (and ftell shows
797 264). This causes all hell to break loose. I was unable to
798 reproduce this on a short test program which operated on the same
799 file, performing (I think) the same sequence of operations.
801 It stopped happening when I put in this (former) rewind().
803 FIXME: Find out if this has been reported to Sun, whether it has
804 been fixed in a later release, etc. */
806 bfd_seek (objfile
->obfd
, 0, 0);
808 /* Position to read the symbol table. */
809 val
= bfd_seek (objfile
->obfd
, (long) symtab_offset
, 0);
811 perror_with_name (objfile_name (objfile
));
813 coffread_objfile
= objfile
;
814 nlist_bfd_global
= objfile
->obfd
;
815 nlist_nsyms_global
= nsyms
;
816 set_last_source_file (NULL
);
817 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
819 if (type_vector
) /* Get rid of previous one. */
821 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
822 type_vector
= XCNEWVEC (struct type
*, type_vector_length
);
824 coff_start_symtab (objfile
, "");
827 while (symnum
< nsyms
)
829 QUIT
; /* Make this command interruptable. */
831 read_one_sym (cs
, &main_sym
, &main_aux
);
833 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
835 if (get_last_source_file ())
836 coff_end_symtab (objfile
);
838 coff_start_symtab (objfile
, "_globals_");
839 /* coff_start_symtab will set the language of this symtab to
840 language_unknown, since such a ``file name'' is not
841 recognized. Override that with the minimal language to
842 allow printing values in this symtab. */
843 get_current_subfile ()->language
= language_minimal
;
844 complete_symtab ("_globals_", 0, 0);
845 /* Done with all files, everything from here on out is
849 /* Special case for file with type declarations only, no
851 if (!get_last_source_file () && SDB_TYPE (cs
->c_type
)
852 && cs
->c_secnum
== N_DEBUG
)
853 complete_symtab (filestring
, 0, 0);
855 /* Typedefs should not be treated as symbol definitions. */
856 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
858 /* Record all functions -- external and static -- in
860 int section
= cs_to_section (cs
, objfile
);
862 tmpaddr
= cs
->c_value
;
863 /* Don't record unresolved symbols. */
864 if (!(cs
->c_secnum
<= 0 && cs
->c_value
== 0))
865 record_minimal_symbol (reader
, cs
, tmpaddr
, mst_text
,
868 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
869 fcn_start_addr
= tmpaddr
;
871 fcn_sym_saved
= main_sym
;
872 fcn_aux_saved
= main_aux
;
876 switch (cs
->c_sclass
)
885 complaint (_("Bad n_sclass for symbol %s"),
890 /* c_value field contains symnum of next .file entry in
891 table or symnum of first global after last .file. */
892 next_file_symnum
= cs
->c_value
;
894 filestring
= coff_getfilename (&main_aux
);
898 /* Complete symbol table for last object file
899 containing debugging information. */
900 if (get_last_source_file ())
902 coff_end_symtab (objfile
);
903 coff_start_symtab (objfile
, filestring
);
908 /* C_LABEL is used for labels and static functions.
909 Including it here allows gdb to see static functions when
910 no debug info is available. */
912 /* However, labels within a function can make weird
913 backtraces, so filter them out (from phdm@macqel.be). */
920 case C_THUMBSTATFUNC
:
921 if (cs
->c_name
[0] == '.')
923 if (strcmp (cs
->c_name
, ".text") == 0)
925 /* FIXME: don't wire in ".text" as section name or
927 /* Check for in_source_file deals with case of a
928 file with debugging symbols followed by a later
929 file with no symbols. */
931 complete_symtab (filestring
,
932 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
933 SECT_OFF_TEXT (objfile
)),
934 main_aux
.x_scn
.x_scnlen
);
937 /* Flush rest of '.' symbols. */
940 else if (!SDB_TYPE (cs
->c_type
)
941 && cs
->c_name
[0] == 'L'
942 && (startswith (cs
->c_name
, "LI%")
943 || startswith (cs
->c_name
, "LF%")
944 || startswith (cs
->c_name
, "LC%")
945 || startswith (cs
->c_name
, "LP%")
946 || startswith (cs
->c_name
, "LPB%")
947 || startswith (cs
->c_name
, "LBB%")
948 || startswith (cs
->c_name
, "LBE%")
949 || startswith (cs
->c_name
, "LPBX%")))
950 /* At least on a 3b1, gcc generates swbeg and string labels
951 that look like this. Ignore them. */
953 /* For static symbols that don't start with '.'... */
959 /* Record it in the minimal symbols regardless of
960 SDB_TYPE. This parallels what we do for other debug
961 formats, and probably is needed to make
962 print_address_symbolic work right without the (now
963 gone) "set fast-symbolic-addr off" kludge. */
965 enum minimal_symbol_type ms_type
;
967 CORE_ADDR offset
= 0;
969 if (cs
->c_secnum
== N_UNDEF
)
971 /* This is a common symbol. We used to rely on
972 the target to tell us whether it knows where
973 the symbol has been relocated to, but none of
974 the target implementations actually provided
975 that operation. So we just ignore the symbol,
976 the same way we would do if we had a target-side
977 symbol lookup which returned no match. */
980 else if (cs
->c_secnum
== N_ABS
)
982 /* Use the correct minimal symbol type (and don't
983 relocate) for absolute values. */
985 sec
= cs_to_section (cs
, objfile
);
986 tmpaddr
= cs
->c_value
;
990 asection
*bfd_section
= cs_to_bfd_section (cs
, objfile
);
992 sec
= cs_to_section (cs
, objfile
);
993 tmpaddr
= cs
->c_value
;
994 /* Statics in a PE file also get relocated. */
995 if (cs
->c_sclass
== C_EXT
996 || cs
->c_sclass
== C_THUMBEXTFUNC
997 || cs
->c_sclass
== C_THUMBEXT
998 || (pe_file
&& (cs
->c_sclass
== C_STAT
)))
999 offset
= ANOFFSET (objfile
->section_offsets
, sec
);
1001 if (bfd_section
->flags
& SEC_CODE
)
1004 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
1005 || cs
->c_sclass
== C_THUMBEXT
?
1006 mst_text
: mst_file_text
;
1007 tmpaddr
= gdbarch_addr_bits_remove (gdbarch
, tmpaddr
);
1009 else if (bfd_section
->flags
& SEC_ALLOC
1010 && bfd_section
->flags
& SEC_LOAD
)
1013 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1014 ? mst_data
: mst_file_data
;
1016 else if (bfd_section
->flags
& SEC_ALLOC
)
1019 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1020 ? mst_bss
: mst_file_bss
;
1023 ms_type
= mst_unknown
;
1026 msym
= record_minimal_symbol (reader
, cs
, tmpaddr
, ms_type
,
1029 gdbarch_coff_make_msymbol_special (gdbarch
,
1030 cs
->c_sclass
, msym
);
1032 if (SDB_TYPE (cs
->c_type
))
1036 sym
= process_coff_symbol
1037 (cs
, &main_aux
, objfile
);
1038 SYMBOL_VALUE (sym
) = tmpaddr
+ offset
;
1039 SYMBOL_SECTION (sym
) = sec
;
1045 if (strcmp (cs
->c_name
, ".bf") == 0)
1047 within_function
= 1;
1049 /* Value contains address of first non-init type
1051 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1052 contains line number of '{' }. */
1053 if (cs
->c_naux
!= 1)
1054 complaint (_("`.bf' symbol %d has no aux entry"),
1056 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1057 fcn_first_line_addr
= cs
->c_value
;
1059 /* Might want to check that locals are 0 and
1060 context_stack_depth is zero, and complain if not. */
1063 newobj
= push_context (depth
, fcn_start_addr
);
1064 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1066 process_coff_symbol (&fcn_cs_saved
,
1067 &fcn_aux_saved
, objfile
);
1069 else if (strcmp (cs
->c_name
, ".ef") == 0)
1071 if (!within_function
)
1072 error (_("Bad coff function information."));
1073 /* The value of .ef is the address of epilogue code;
1074 not useful for gdb. */
1075 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1076 contains number of lines to '}' */
1078 if (outermost_context_p ())
1079 { /* We attempted to pop an empty context stack. */
1080 complaint (_("`.ef' symbol without matching `.bf' "
1081 "symbol ignored starting at symnum %d"),
1083 within_function
= 0;
1087 struct context_stack cstk
= pop_context ();
1088 /* Stack must be empty now. */
1089 if (!outermost_context_p () || newobj
== NULL
)
1091 complaint (_("Unmatched .ef symbol(s) ignored "
1092 "starting at symnum %d"),
1094 within_function
= 0;
1097 if (cs
->c_naux
!= 1)
1099 complaint (_("`.ef' symbol %d has no aux entry"),
1101 fcn_last_line
= 0x7FFFFFFF;
1105 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1107 /* fcn_first_line is the line number of the opening '{'.
1108 Do not record it - because it would affect gdb's idea
1109 of the line number of the first statement of the
1110 function - except for one-line functions, for which
1111 it is also the line number of all the statements and
1112 of the closing '}', and for which we do not have any
1113 other statement-line-number. */
1114 if (fcn_last_line
== 1)
1115 record_line (get_current_subfile (), fcn_first_line
,
1116 gdbarch_addr_bits_remove (gdbarch
,
1117 fcn_first_line_addr
));
1119 enter_linenos (fcn_line_ptr
, fcn_first_line
,
1120 fcn_last_line
, objfile
);
1122 finish_block (cstk
.name
, cstk
.old_blocks
,
1123 NULL
, cstk
.start_addr
,
1124 fcn_cs_saved
.c_value
1125 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1126 + ANOFFSET (objfile
->section_offsets
,
1127 SECT_OFF_TEXT (objfile
)));
1128 within_function
= 0;
1133 if (strcmp (cs
->c_name
, ".bb") == 0)
1135 tmpaddr
= cs
->c_value
;
1136 tmpaddr
+= ANOFFSET (objfile
->section_offsets
,
1137 SECT_OFF_TEXT (objfile
));
1138 push_context (++depth
, tmpaddr
);
1140 else if (strcmp (cs
->c_name
, ".eb") == 0)
1142 if (outermost_context_p ())
1143 { /* We attempted to pop an empty context stack. */
1144 complaint (_("`.eb' symbol without matching `.bb' "
1145 "symbol ignored starting at symnum %d"),
1150 struct context_stack cstk
= pop_context ();
1151 if (depth
-- != cstk
.depth
)
1153 complaint (_("Mismatched .eb symbol ignored "
1154 "starting at symnum %d"),
1158 if (*get_local_symbols () && !outermost_context_p ())
1161 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
1162 SECT_OFF_TEXT (objfile
));
1163 /* Make a block for the local symbols within. */
1164 finish_block (0, cstk
.old_blocks
, NULL
,
1165 cstk
.start_addr
, tmpaddr
);
1167 /* Now pop locals of block just finished. */
1168 *get_local_symbols () = cstk
.locals
;
1173 process_coff_symbol (cs
, &main_aux
, objfile
);
1178 if ((nsyms
== 0) && (pe_file
))
1180 /* We've got no debugging symbols, but it's a portable
1181 executable, so try to read the export table. */
1182 read_pe_exported_syms (reader
, objfile
);
1185 if (get_last_source_file ())
1186 coff_end_symtab (objfile
);
1188 /* Patch up any opaque types (references to types that are not defined
1189 in the file where they are referenced, e.g. "struct foo *bar"). */
1191 for (compunit_symtab
*cu
: objfile
->compunits ())
1193 for (symtab
*s
: compunit_filetabs (cu
))
1194 patch_opaque_types (s
);
1198 coffread_objfile
= NULL
;
1201 /* Routines for reading headers and symbols from executable. */
1203 /* Read the next symbol, swap it, and return it in both
1204 internal_syment form, and coff_symbol form. Also return its first
1205 auxent, if any, in internal_auxent form, and skip any other
1209 read_one_sym (struct coff_symbol
*cs
,
1210 struct internal_syment
*sym
,
1211 union internal_auxent
*aux
)
1214 bfd_size_type bytes
;
1216 cs
->c_symnum
= symnum
;
1217 bytes
= bfd_bread (temp_sym
, local_symesz
, nlist_bfd_global
);
1218 if (bytes
!= local_symesz
)
1219 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1220 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1221 cs
->c_naux
= sym
->n_numaux
& 0xff;
1222 if (cs
->c_naux
>= 1)
1224 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1225 if (bytes
!= local_auxesz
)
1226 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1227 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
,
1228 sym
->n_type
, sym
->n_sclass
,
1229 0, cs
->c_naux
, (char *) aux
);
1230 /* If more than one aux entry, read past it (only the first aux
1232 for (i
= 1; i
< cs
->c_naux
; i
++)
1234 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1235 if (bytes
!= local_auxesz
)
1236 error (_("%s: error reading symbols"),
1237 objfile_name (coffread_objfile
));
1240 cs
->c_name
= getsymname (sym
);
1241 cs
->c_value
= sym
->n_value
;
1242 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1243 cs
->c_secnum
= sym
->n_scnum
;
1244 cs
->c_type
= (unsigned) sym
->n_type
;
1245 if (!SDB_TYPE (cs
->c_type
))
1249 if (cs
->c_sclass
& 128)
1250 printf (_("thumb symbol %s, class 0x%x\n"), cs
->c_name
, cs
->c_sclass
);
1253 symnum
+= 1 + cs
->c_naux
;
1255 /* The PE file format stores symbol values as offsets within the
1256 section, rather than as absolute addresses. We correct that
1257 here, if the symbol has an appropriate storage class. FIXME: We
1258 should use BFD to read the symbols, rather than duplicating the
1262 switch (cs
->c_sclass
)
1266 case C_THUMBEXTFUNC
:
1271 case C_THUMBSTATFUNC
:
1277 if (cs
->c_secnum
!= 0)
1278 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1284 /* Support for string table handling. */
1287 init_stringtab (bfd
*abfd
, long offset
, gdb::unique_xmalloc_ptr
<char> *storage
)
1291 unsigned char lengthbuf
[4];
1293 /* If the file is stripped, the offset might be zero, indicating no
1294 string table. Just return with `stringtab' set to null. */
1298 if (bfd_seek (abfd
, offset
, 0) < 0)
1301 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1302 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1304 /* If no string table is needed, then the file may end immediately
1305 after the symbols. Just return with `stringtab' set to null. */
1306 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1309 storage
->reset ((char *) xmalloc (length
));
1310 stringtab
= storage
->get ();
1311 /* This is in target format (probably not very useful, and not
1312 currently used), not host format. */
1313 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1314 if (length
== sizeof length
) /* Empty table -- just the count. */
1317 val
= bfd_bread (stringtab
+ sizeof lengthbuf
,
1318 length
- sizeof lengthbuf
, abfd
);
1319 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1326 getsymname (struct internal_syment
*symbol_entry
)
1328 static char buffer
[SYMNMLEN
+ 1];
1331 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1333 /* FIXME: Probably should be detecting corrupt symbol files by
1334 seeing whether offset points to within the stringtab. */
1335 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1339 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1340 buffer
[SYMNMLEN
] = '\0';
1346 /* Extract the file name from the aux entry of a C_FILE symbol.
1347 Return only the last component of the name. Result is in static
1348 storage and is only good for temporary use. */
1351 coff_getfilename (union internal_auxent
*aux_entry
)
1353 static char buffer
[BUFSIZ
];
1356 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1358 if (strlen (stringtab
+ aux_entry
->x_file
.x_n
.x_offset
) >= BUFSIZ
)
1359 internal_error (__FILE__
, __LINE__
, _("coff file name too long"));
1360 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1364 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1365 buffer
[FILNMLEN
] = '\0';
1369 /* FIXME: We should not be throwing away the information about what
1370 directory. It should go into dirname of the symtab, or some such
1372 result
= lbasename (result
);
1376 /* Support for line number handling. */
1378 /* Read in all the line numbers for fast lookups later. Leave them in
1379 external (unswapped) format in memory; we'll swap them as we enter
1380 them into GDB's data structures. */
1383 init_lineno (bfd
*abfd
, long offset
, int size
,
1384 gdb::unique_xmalloc_ptr
<char> *storage
)
1388 linetab_offset
= offset
;
1389 linetab_size
= size
;
1394 if (bfd_seek (abfd
, offset
, 0) < 0)
1397 /* Allocate the desired table, plus a sentinel. */
1398 storage
->reset ((char *) xmalloc (size
+ local_linesz
));
1399 linetab
= storage
->get ();
1401 val
= bfd_bread (storage
->get (), size
, abfd
);
1405 /* Terminate it with an all-zero sentinel record. */
1406 memset (linetab
+ size
, 0, local_linesz
);
1411 #if !defined (L_LNNO32)
1412 #define L_LNNO32(lp) ((lp)->l_lnno)
1416 enter_linenos (long file_offset
, int first_line
,
1417 int last_line
, struct objfile
*objfile
)
1419 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1421 struct internal_lineno lptr
;
1425 if (file_offset
< linetab_offset
)
1427 complaint (_("Line number pointer %ld lower than start of line numbers"),
1429 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1431 file_offset
+= linetab_offset
; /* Try reading at that linetab
1435 rawptr
= &linetab
[file_offset
- linetab_offset
];
1437 /* Skip first line entry for each function. */
1438 rawptr
+= local_linesz
;
1439 /* Line numbers start at one for the first line of the function. */
1442 /* If the line number table is full (e.g. 64K lines in COFF debug
1443 info), the next function's L_LNNO32 might not be zero, so don't
1444 overstep the table's end in any case. */
1445 while (rawptr
<= &linetab
[0] + linetab_size
)
1447 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1448 rawptr
+= local_linesz
;
1449 /* The next function, or the sentinel, will have L_LNNO32 zero;
1451 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1453 CORE_ADDR addr
= lptr
.l_addr
.l_paddr
;
1454 addr
+= ANOFFSET (objfile
->section_offsets
,
1455 SECT_OFF_TEXT (objfile
));
1456 record_line (get_current_subfile (),
1457 first_line
+ L_LNNO32 (&lptr
),
1458 gdbarch_addr_bits_remove (gdbarch
, addr
));
1466 patch_type (struct type
*type
, struct type
*real_type
)
1468 struct type
*target
= TYPE_TARGET_TYPE (type
);
1469 struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1470 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1472 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1473 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1474 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
,
1477 memcpy (TYPE_FIELDS (target
),
1478 TYPE_FIELDS (real_target
),
1481 if (TYPE_NAME (real_target
))
1483 /* The previous copy of TYPE_NAME is allocated by
1484 process_coff_symbol. */
1485 if (TYPE_NAME (target
))
1486 xfree ((char*) TYPE_NAME (target
));
1487 TYPE_NAME (target
) = xstrdup (TYPE_NAME (real_target
));
1491 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1492 so that they can be used to print out opaque data structures
1496 patch_opaque_types (struct symtab
*s
)
1499 struct block_iterator iter
;
1500 struct symbol
*real_sym
;
1502 /* Go through the per-file symbols only. */
1503 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s
), STATIC_BLOCK
);
1504 ALL_BLOCK_SYMBOLS (b
, iter
, real_sym
)
1506 /* Find completed typedefs to use to fix opaque ones.
1507 Remove syms from the chain when their types are stored,
1508 but search the whole chain, as there may be several syms
1509 from different files with the same name. */
1510 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
1511 && SYMBOL_DOMAIN (real_sym
) == VAR_DOMAIN
1512 && TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
1513 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1515 const char *name
= SYMBOL_LINKAGE_NAME (real_sym
);
1516 int hash
= hashname (name
);
1517 struct symbol
*sym
, *prev
;
1520 for (sym
= opaque_type_chain
[hash
]; sym
;)
1522 if (name
[0] == SYMBOL_LINKAGE_NAME (sym
)[0]
1523 && strcmp (name
+ 1, SYMBOL_LINKAGE_NAME (sym
) + 1) == 0)
1527 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1531 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1534 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1538 sym
= SYMBOL_VALUE_CHAIN (prev
);
1542 sym
= opaque_type_chain
[hash
];
1548 sym
= SYMBOL_VALUE_CHAIN (sym
);
1556 coff_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
1558 return gdbarch_sdb_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
1561 static const struct symbol_register_ops coff_register_funcs
= {
1565 /* The "aclass" index for computed COFF symbols. */
1567 static int coff_register_index
;
1569 static struct symbol
*
1570 process_coff_symbol (struct coff_symbol
*cs
,
1571 union internal_auxent
*aux
,
1572 struct objfile
*objfile
)
1574 struct symbol
*sym
= allocate_symbol (objfile
);
1578 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1579 SYMBOL_SET_LANGUAGE (sym
, get_current_subfile ()->language
,
1580 &objfile
->objfile_obstack
);
1581 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), 1, objfile
);
1583 /* default assumptions */
1584 SYMBOL_VALUE (sym
) = cs
->c_value
;
1585 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1586 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1588 if (ISFCN (cs
->c_type
))
1590 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
,
1591 SECT_OFF_TEXT (objfile
));
1593 lookup_function_type (decode_function_type (cs
, cs
->c_type
,
1596 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
1597 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1598 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1599 add_symbol_to_list (sym
, get_file_symbols ());
1600 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1601 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1602 add_symbol_to_list (sym
, get_global_symbols ());
1606 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
, objfile
);
1607 switch (cs
->c_sclass
)
1613 SYMBOL_ACLASS_INDEX (sym
) = LOC_LOCAL
;
1614 add_symbol_to_list (sym
, get_local_symbols ());
1618 case C_THUMBEXTFUNC
:
1620 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1621 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1622 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1623 SECT_OFF_TEXT (objfile
));
1624 add_symbol_to_list (sym
, get_global_symbols ());
1628 case C_THUMBSTATFUNC
:
1630 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1631 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1632 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1633 SECT_OFF_TEXT (objfile
));
1634 if (within_function
)
1636 /* Static symbol of local scope. */
1637 add_symbol_to_list (sym
, get_local_symbols ());
1641 /* Static symbol at top level of file. */
1642 add_symbol_to_list (sym
, get_file_symbols ());
1646 #ifdef C_GLBLREG /* AMD coff */
1650 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1651 SYMBOL_VALUE (sym
) = cs
->c_value
;
1652 add_symbol_to_list (sym
, get_local_symbols ());
1660 SYMBOL_ACLASS_INDEX (sym
) = LOC_ARG
;
1661 SYMBOL_IS_ARGUMENT (sym
) = 1;
1662 add_symbol_to_list (sym
, get_local_symbols ());
1666 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1667 SYMBOL_IS_ARGUMENT (sym
) = 1;
1668 SYMBOL_VALUE (sym
) = cs
->c_value
;
1669 add_symbol_to_list (sym
, get_local_symbols ());
1673 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1674 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1676 /* If type has no name, give it one. */
1677 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1679 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1680 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1682 /* If we are giving a name to a type such as
1683 "pointer to foo" or "function returning foo", we
1684 better not set the TYPE_NAME. If the program
1685 contains "typedef char *caddr_t;", we don't want
1686 all variables of type char * to print as caddr_t.
1687 This is not just a consequence of GDB's type
1688 management; CC and GCC (at least through version
1689 2.4) both output variables of either type char *
1690 or caddr_t with the type refering to the C_TPDEF
1691 symbol for caddr_t. If a future compiler cleans
1692 this up it GDB is not ready for it yet, but if it
1693 becomes ready we somehow need to disable this
1694 check (without breaking the PCC/GCC2.4 case).
1698 Fortunately, this check seems not to be necessary
1699 for anything except pointers or functions. */
1703 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1704 xstrdup (SYMBOL_LINKAGE_NAME (sym
));
1707 /* Keep track of any type which points to empty structured
1708 type, so it can be filled from a definition from another
1709 file. A simple forward reference (TYPE_CODE_UNDEF) is
1710 not an empty structured type, though; the forward
1711 references work themselves out via the magic of
1712 coff_lookup_type. */
1713 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1714 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0
1715 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
)))
1718 int i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
1720 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1721 opaque_type_chain
[i
] = sym
;
1723 add_symbol_to_list (sym
, get_file_symbols ());
1729 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1730 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
1732 /* Some compilers try to be helpful by inventing "fake"
1733 names for anonymous enums, structures, and unions, like
1734 "~0fake" or ".0fake". Thanks, but no thanks... */
1735 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1736 if (SYMBOL_LINKAGE_NAME (sym
) != NULL
1737 && *SYMBOL_LINKAGE_NAME (sym
) != '~'
1738 && *SYMBOL_LINKAGE_NAME (sym
) != '.')
1739 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1740 concat (SYMBOL_LINKAGE_NAME (sym
), (char *)NULL
);
1742 add_symbol_to_list (sym
, get_file_symbols ());
1752 /* Decode a coff type specifier; return the type that is meant. */
1754 static struct type
*
1755 decode_type (struct coff_symbol
*cs
, unsigned int c_type
,
1756 union internal_auxent
*aux
, struct objfile
*objfile
)
1758 struct type
*type
= 0;
1759 unsigned int new_c_type
;
1761 if (c_type
& ~N_BTMASK
)
1763 new_c_type
= DECREF (c_type
);
1766 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1767 type
= lookup_pointer_type (type
);
1769 else if (ISFCN (c_type
))
1771 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1772 type
= lookup_function_type (type
);
1774 else if (ISARY (c_type
))
1777 unsigned short *dim
;
1778 struct type
*base_type
, *index_type
, *range_type
;
1780 /* Define an array type. */
1781 /* auxent refers to array, not base type. */
1782 if (aux
->x_sym
.x_tagndx
.l
== 0)
1785 /* Shift the indices down. */
1786 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1789 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1793 base_type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1794 index_type
= objfile_type (objfile
)->builtin_int
;
1796 = create_static_range_type ((struct type
*) NULL
,
1797 index_type
, 0, n
- 1);
1799 create_array_type ((struct type
*) NULL
,
1800 base_type
, range_type
);
1805 /* Reference to existing type. This only occurs with the struct,
1806 union, and enum types. EPI a29k coff fakes us out by producing
1807 aux entries with a nonzero x_tagndx for definitions of structs,
1808 unions, and enums, so we have to check the c_sclass field. SCO
1809 3.2v4 cc gets confused with pointers to pointers to defined
1810 structs, and generates negative x_tagndx fields. */
1811 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1813 if (cs
->c_sclass
!= C_STRTAG
1814 && cs
->c_sclass
!= C_UNTAG
1815 && cs
->c_sclass
!= C_ENTAG
1816 && aux
->x_sym
.x_tagndx
.l
>= 0)
1818 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1823 complaint (_("Symbol table entry for %s has bad tagndx value"),
1825 /* And fall through to decode_base_type... */
1829 return decode_base_type (cs
, BTYPE (c_type
), aux
, objfile
);
1832 /* Decode a coff type specifier for function definition;
1833 return the type that the function returns. */
1835 static struct type
*
1836 decode_function_type (struct coff_symbol
*cs
,
1837 unsigned int c_type
,
1838 union internal_auxent
*aux
,
1839 struct objfile
*objfile
)
1841 if (aux
->x_sym
.x_tagndx
.l
== 0)
1842 cs
->c_naux
= 0; /* auxent refers to function, not base
1845 return decode_type (cs
, DECREF (c_type
), aux
, objfile
);
1848 /* Basic C types. */
1850 static struct type
*
1851 decode_base_type (struct coff_symbol
*cs
,
1852 unsigned int c_type
,
1853 union internal_auxent
*aux
,
1854 struct objfile
*objfile
)
1856 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1862 /* Shows up with "void (*foo)();" structure members. */
1863 return objfile_type (objfile
)->builtin_void
;
1867 /* Intel 960 COFF has this symbol and meaning. */
1868 return objfile_type (objfile
)->builtin_void
;
1872 return objfile_type (objfile
)->builtin_char
;
1875 return objfile_type (objfile
)->builtin_short
;
1878 return objfile_type (objfile
)->builtin_int
;
1881 if (cs
->c_sclass
== C_FIELD
1882 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1883 > gdbarch_long_bit (gdbarch
))
1884 return objfile_type (objfile
)->builtin_long_long
;
1886 return objfile_type (objfile
)->builtin_long
;
1889 return objfile_type (objfile
)->builtin_float
;
1892 return objfile_type (objfile
)->builtin_double
;
1895 return objfile_type (objfile
)->builtin_long_double
;
1898 if (cs
->c_naux
!= 1)
1900 /* Anonymous structure type. */
1901 type
= coff_alloc_type (cs
->c_symnum
);
1902 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1903 TYPE_NAME (type
) = NULL
;
1904 INIT_CPLUS_SPECIFIC (type
);
1905 TYPE_LENGTH (type
) = 0;
1906 TYPE_FIELDS (type
) = 0;
1907 TYPE_NFIELDS (type
) = 0;
1911 type
= coff_read_struct_type (cs
->c_symnum
,
1912 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1913 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1919 if (cs
->c_naux
!= 1)
1921 /* Anonymous union type. */
1922 type
= coff_alloc_type (cs
->c_symnum
);
1923 TYPE_NAME (type
) = NULL
;
1924 INIT_CPLUS_SPECIFIC (type
);
1925 TYPE_LENGTH (type
) = 0;
1926 TYPE_FIELDS (type
) = 0;
1927 TYPE_NFIELDS (type
) = 0;
1931 type
= coff_read_struct_type (cs
->c_symnum
,
1932 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1933 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1936 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1940 if (cs
->c_naux
!= 1)
1942 /* Anonymous enum type. */
1943 type
= coff_alloc_type (cs
->c_symnum
);
1944 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1945 TYPE_NAME (type
) = NULL
;
1946 TYPE_LENGTH (type
) = 0;
1947 TYPE_FIELDS (type
) = 0;
1948 TYPE_NFIELDS (type
) = 0;
1952 type
= coff_read_enum_type (cs
->c_symnum
,
1953 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1954 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1960 /* Shouldn't show up here. */
1964 return objfile_type (objfile
)->builtin_unsigned_char
;
1967 return objfile_type (objfile
)->builtin_unsigned_short
;
1970 return objfile_type (objfile
)->builtin_unsigned_int
;
1973 if (cs
->c_sclass
== C_FIELD
1974 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1975 > gdbarch_long_bit (gdbarch
))
1976 return objfile_type (objfile
)->builtin_unsigned_long_long
;
1978 return objfile_type (objfile
)->builtin_unsigned_long
;
1980 complaint (_("Unexpected type for symbol %s"), cs
->c_name
);
1981 return objfile_type (objfile
)->builtin_void
;
1984 /* This page contains subroutines of read_type. */
1986 /* Read the description of a structure (or union type) and return an
1987 object describing the type. */
1989 static struct type
*
1990 coff_read_struct_type (int index
, int length
, int lastsym
,
1991 struct objfile
*objfile
)
1995 struct nextfield
*next
;
2000 struct nextfield
*list
= 0;
2001 struct nextfield
*newobj
;
2005 struct coff_symbol member_sym
;
2006 struct coff_symbol
*ms
= &member_sym
;
2007 struct internal_syment sub_sym
;
2008 union internal_auxent sub_aux
;
2011 type
= coff_alloc_type (index
);
2012 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2013 INIT_CPLUS_SPECIFIC (type
);
2014 TYPE_LENGTH (type
) = length
;
2016 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2018 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2020 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2022 switch (ms
->c_sclass
)
2027 /* Get space to record the next field's data. */
2028 newobj
= XALLOCA (struct nextfield
);
2029 newobj
->next
= list
;
2032 /* Save the data. */
2034 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
2035 name
, strlen (name
));
2036 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2038 SET_FIELD_BITPOS (list
->field
, 8 * ms
->c_value
);
2039 FIELD_BITSIZE (list
->field
) = 0;
2045 /* Get space to record the next field's data. */
2046 newobj
= XALLOCA (struct nextfield
);
2047 newobj
->next
= list
;
2050 /* Save the data. */
2052 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
2053 name
, strlen (name
));
2054 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2056 SET_FIELD_BITPOS (list
->field
, ms
->c_value
);
2057 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2066 /* Now create the vector of fields, and record how big it is. */
2068 TYPE_NFIELDS (type
) = nfields
;
2069 TYPE_FIELDS (type
) = (struct field
*)
2070 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2072 /* Copy the saved-up fields into the field vector. */
2074 for (n
= nfields
; list
; list
= list
->next
)
2075 TYPE_FIELD (type
, --n
) = list
->field
;
2080 /* Read a definition of an enumeration type,
2081 and create and return a suitable type object.
2082 Also defines the symbols that represent the values of the type. */
2084 static struct type
*
2085 coff_read_enum_type (int index
, int length
, int lastsym
,
2086 struct objfile
*objfile
)
2088 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2093 struct pending
**symlist
;
2094 struct coff_symbol member_sym
;
2095 struct coff_symbol
*ms
= &member_sym
;
2096 struct internal_syment sub_sym
;
2097 union internal_auxent sub_aux
;
2098 struct pending
*osyms
, *syms
;
2102 int unsigned_enum
= 1;
2104 type
= coff_alloc_type (index
);
2105 if (within_function
)
2106 symlist
= get_local_symbols ();
2108 symlist
= get_file_symbols ();
2110 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2112 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2114 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2116 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2118 switch (ms
->c_sclass
)
2121 sym
= allocate_symbol (objfile
);
2123 name
= (char *) obstack_copy0 (&objfile
->objfile_obstack
, name
,
2125 SYMBOL_SET_LINKAGE_NAME (sym
, name
);
2126 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
2127 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2128 SYMBOL_VALUE (sym
) = ms
->c_value
;
2129 add_symbol_to_list (sym
, symlist
);
2134 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2135 up the count of how many symbols to read. So stop
2142 /* Now fill in the fields of the type-structure. */
2145 TYPE_LENGTH (type
) = length
;
2146 else /* Assume ints. */
2147 TYPE_LENGTH (type
) = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
2148 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2149 TYPE_NFIELDS (type
) = nsyms
;
2150 TYPE_FIELDS (type
) = (struct field
*)
2151 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2153 /* Find the symbols for the values and put them into the type.
2154 The symbols can be found in the symlist that we put them on
2155 to cause them to be defined. osyms contains the old value
2156 of that symlist; everything up to there was defined by us. */
2157 /* Note that we preserve the order of the enum constants, so
2158 that in something like "enum {FOO, LAST_THING=FOO}" we print
2159 FOO, not LAST_THING. */
2161 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2167 for (; j
< syms
->nsyms
; j
++, n
++)
2169 struct symbol
*xsym
= syms
->symbol
[j
];
2171 SYMBOL_TYPE (xsym
) = type
;
2172 TYPE_FIELD_NAME (type
, n
) = SYMBOL_LINKAGE_NAME (xsym
);
2173 SET_FIELD_ENUMVAL (TYPE_FIELD (type
, n
), SYMBOL_VALUE (xsym
));
2174 if (SYMBOL_VALUE (xsym
) < 0)
2176 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2183 TYPE_UNSIGNED (type
) = 1;
2188 /* Register our ability to parse symbols for coff BFD files. */
2190 static const struct sym_fns coff_sym_fns
=
2192 coff_new_init
, /* sym_new_init: init anything gbl to
2194 coff_symfile_init
, /* sym_init: read initial info, setup
2196 coff_symfile_read
, /* sym_read: read a symbol file into
2198 NULL
, /* sym_read_psymbols */
2199 coff_symfile_finish
, /* sym_finish: finished with file,
2201 default_symfile_offsets
, /* sym_offsets: xlate external to
2203 default_symfile_segments
, /* sym_segments: Get segment
2204 information from a file */
2205 NULL
, /* sym_read_linetable */
2207 default_symfile_relocate
, /* sym_relocate: Relocate a debug
2209 NULL
, /* sym_probe_fns */
2213 /* Free the per-objfile COFF data. */
2216 coff_free_info (struct objfile
*objfile
, void *arg
)
2222 _initialize_coffread (void)
2224 add_symtab_fns (bfd_target_coff_flavour
, &coff_sym_fns
);
2226 coff_objfile_data_key
= register_objfile_data_with_cleanup (NULL
,
2230 = register_symbol_register_impl (LOC_REGISTER
, &coff_register_funcs
);