1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2005, 2007-2012 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"
29 #include "gdb_string.h"
32 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
33 #include "libcoff.h" /* FIXME secret internal data from BFD */
36 #include "gdb-stabs.h"
37 #include "stabsread.h"
38 #include "complaints.h"
40 #include "gdb_assert.h"
42 #include "dictionary.h"
44 #include "coff-pe-read.h"
48 extern void _initialize_coffread (void);
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 struct stab_section_list
*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 extern void stabsread_clear_cache (void);
147 static struct type
*coff_read_struct_type (int, int, int,
150 static struct type
*decode_base_type (struct coff_symbol
*,
152 union internal_auxent
*,
155 static struct type
*decode_type (struct coff_symbol
*, unsigned int,
156 union internal_auxent
*,
159 static struct type
*decode_function_type (struct coff_symbol
*,
161 union internal_auxent
*,
164 static struct type
*coff_read_enum_type (int, int, int,
167 static struct symbol
*process_coff_symbol (struct coff_symbol
*,
168 union internal_auxent
*,
171 static void patch_opaque_types (struct symtab
*);
173 static void enter_linenos (long, int, int, struct objfile
*);
175 static void free_linetab (void);
177 static void free_linetab_cleanup (void *ignore
);
179 static int init_lineno (bfd
*, long, int);
181 static char *getsymname (struct internal_syment
*);
183 static const char *coff_getfilename (union internal_auxent
*);
185 static void free_stringtab (void);
187 static void free_stringtab_cleanup (void *ignore
);
189 static int init_stringtab (bfd
*, long);
191 static void read_one_sym (struct coff_symbol
*,
192 struct internal_syment
*,
193 union internal_auxent
*);
195 static void coff_symtab_read (long, unsigned int, struct objfile
*);
197 /* We are called once per section from coff_symfile_read. We
198 need to examine each section we are passed, check to see
199 if it is something we are interested in processing, and
200 if so, stash away some access information for the section.
202 FIXME: The section names should not be hardwired strings (what
203 should they be? I don't think most object file formats have enough
204 section flags to specify what kind of debug section it is
208 coff_locate_sections (bfd
*abfd
, asection
*sectp
, void *csip
)
210 struct coff_symfile_info
*csi
;
213 csi
= (struct coff_symfile_info
*) csip
;
214 name
= bfd_get_section_name (abfd
, sectp
);
215 if (strcmp (name
, ".text") == 0)
217 csi
->textaddr
= bfd_section_vma (abfd
, sectp
);
218 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
220 else if (strncmp (name
, ".text", sizeof ".text" - 1) == 0)
222 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
224 else if (strcmp (name
, ".stabstr") == 0)
226 csi
->stabstrsect
= sectp
;
228 else if (strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
232 /* We can have multiple .stab sections if linked with
234 for (s
= name
+ sizeof ".stab" - 1; *s
!= '\0'; s
++)
239 struct stab_section_list
*n
, **pn
;
241 n
= ((struct stab_section_list
*)
242 xmalloc (sizeof (struct stab_section_list
)));
245 for (pn
= &csi
->stabsects
; *pn
!= NULL
; pn
= &(*pn
)->next
)
249 /* This will be run after coffstab_build_psymtabs is called
250 in coff_symfile_read, at which point we no longer need
252 make_cleanup (xfree
, n
);
257 /* Return the section_offsets* that CS points to. */
258 static int cs_to_section (struct coff_symbol
*, struct objfile
*);
260 struct find_targ_sec_arg
267 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
269 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
271 if (sect
->target_index
== args
->targ_index
)
272 *args
->resultp
= sect
;
275 /* Return the bfd_section that CS points to. */
276 static struct bfd_section
*
277 cs_to_bfd_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
279 asection
*sect
= NULL
;
280 struct find_targ_sec_arg args
;
282 args
.targ_index
= cs
->c_secnum
;
283 args
.resultp
= §
;
284 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
288 /* Return the section number (SECT_OFF_*) that CS points to. */
290 cs_to_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
292 asection
*sect
= cs_to_bfd_section (cs
, objfile
);
295 return SECT_OFF_TEXT (objfile
);
299 /* Return the address of the section of a COFF symbol. */
301 static CORE_ADDR
cs_section_address (struct coff_symbol
*, bfd
*);
304 cs_section_address (struct coff_symbol
*cs
, bfd
*abfd
)
306 asection
*sect
= NULL
;
307 struct find_targ_sec_arg args
;
310 args
.targ_index
= cs
->c_secnum
;
311 args
.resultp
= §
;
312 bfd_map_over_sections (abfd
, find_targ_sec
, &args
);
314 addr
= bfd_get_section_vma (abfd
, sect
);
318 /* Look up a coff type-number index. Return the address of the slot
319 where the type for that index is stored.
320 The type-number is in INDEX.
322 This can be used for finding the type associated with that index
323 or for associating a new type with the index. */
325 static struct type
**
326 coff_lookup_type (int index
)
328 if (index
>= type_vector_length
)
330 int old_vector_length
= type_vector_length
;
332 type_vector_length
*= 2;
333 if (index
/* is still */ >= type_vector_length
)
334 type_vector_length
= index
* 2;
336 type_vector
= (struct type
**)
337 xrealloc ((char *) type_vector
,
338 type_vector_length
* sizeof (struct type
*));
339 memset (&type_vector
[old_vector_length
], 0,
340 (type_vector_length
- old_vector_length
) * sizeof (struct type
*));
342 return &type_vector
[index
];
345 /* Make sure there is a type allocated for type number index
346 and return the type object.
347 This can create an empty (zeroed) type object. */
350 coff_alloc_type (int index
)
352 struct type
**type_addr
= coff_lookup_type (index
);
353 struct type
*type
= *type_addr
;
355 /* If we are referring to a type not known at all yet,
356 allocate an empty type for it.
357 We will fill it in later if we find out how. */
360 type
= alloc_type (coffread_objfile
);
366 /* Start a new symtab for a new source file.
367 This is called when a COFF ".file" symbol is seen;
368 it indicates the start of data for one original source file. */
371 coff_start_symtab (const char *name
)
374 /* We fill in the filename later. start_symtab puts this pointer
375 into last_source_file and we put it in subfiles->name, which
376 end_symtab frees; that's why it must be malloc'd. */
378 /* We never know the directory name for COFF. */
380 /* The start address is irrelevant, since we set
381 last_source_start_addr in coff_end_symtab. */
383 record_debugformat ("COFF");
386 /* Save the vital information from when starting to read a file,
387 for use when closing off the current file.
388 NAME is the file name the symbols came from, START_ADDR is the
389 first text address for the file, and SIZE is the number of bytes of
393 complete_symtab (const char *name
, CORE_ADDR start_addr
, unsigned int size
)
395 if (last_source_file
!= NULL
)
396 xfree (last_source_file
);
397 last_source_file
= xstrdup (name
);
398 current_source_start_addr
= start_addr
;
399 current_source_end_addr
= start_addr
+ size
;
402 /* Finish the symbol definitions for one main source file, close off
403 all the lexical contexts for that file (creating struct block's for
404 them), then make the struct symtab for that file and put it in the
408 coff_end_symtab (struct objfile
*objfile
)
410 last_source_start_addr
= current_source_start_addr
;
412 end_symtab (current_source_end_addr
, objfile
,
413 SECT_OFF_TEXT (objfile
));
415 /* Reinitialize for beginning of new file. */
416 last_source_file
= NULL
;
419 static struct minimal_symbol
*
420 record_minimal_symbol (struct coff_symbol
*cs
, CORE_ADDR address
,
421 enum minimal_symbol_type type
, int section
,
422 struct objfile
*objfile
)
424 struct bfd_section
*bfd_section
;
426 /* We don't want TDESC entry points in the minimal symbol table. */
427 if (cs
->c_name
[0] == '@')
430 bfd_section
= cs_to_bfd_section (cs
, objfile
);
431 return prim_record_minimal_symbol_and_info (cs
->c_name
, address
,
433 bfd_section
, objfile
);
436 /* coff_symfile_init ()
437 is the coff-specific initialization routine for reading symbols.
438 It is passed a struct objfile which contains, among other things,
439 the BFD for the file whose symbols are being read, and a slot for
440 a pointer to "private data" which we fill with cookies and other
441 treats for coff_symfile_read ().
443 We will only be called if this is a COFF or COFF-like file. BFD
444 handles figuring out the format of the file, and code in symtab.c
445 uses BFD's determination to vector to us.
447 The ultimate result is a new symtab (or, FIXME, eventually a
451 coff_symfile_init (struct objfile
*objfile
)
453 /* Allocate struct to keep track of stab reading. */
454 objfile
->deprecated_sym_stab_info
= (struct dbx_symfile_info
*)
455 xmalloc (sizeof (struct dbx_symfile_info
));
457 memset (objfile
->deprecated_sym_stab_info
, 0,
458 sizeof (struct dbx_symfile_info
));
460 /* Allocate struct to keep track of the symfile. */
461 objfile
->deprecated_sym_private
462 = xmalloc (sizeof (struct coff_symfile_info
));
464 memset (objfile
->deprecated_sym_private
, 0,
465 sizeof (struct coff_symfile_info
));
467 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
468 find this causes a significant slowdown in gdb then we could
469 set it in the debug symbol readers only when necessary. */
470 objfile
->flags
|= OBJF_REORDERED
;
472 init_entry_point_info (objfile
);
475 /* This function is called for every section; it finds the outer
476 limits of the line table (minimum and maximum file offset) so that
477 the mainline code can read the whole thing for efficiency. */
480 find_linenos (bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
482 struct coff_symfile_info
*info
;
484 file_ptr offset
, maxoff
;
486 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
487 count
= asect
->lineno_count
;
488 /* End of warning. */
492 size
= count
* local_linesz
;
494 info
= (struct coff_symfile_info
*) vpinfo
;
495 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
496 offset
= asect
->line_filepos
;
497 /* End of warning. */
499 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
500 info
->min_lineno_offset
= offset
;
502 maxoff
= offset
+ size
;
503 if (maxoff
> info
->max_lineno_offset
)
504 info
->max_lineno_offset
= maxoff
;
508 /* The BFD for this file -- only good while we're actively reading
509 symbols into a psymtab or a symtab. */
511 static bfd
*symfile_bfd
;
513 /* Read a symbol file, after initialization by coff_symfile_init. */
516 coff_symfile_read (struct objfile
*objfile
, int symfile_flags
)
518 struct coff_symfile_info
*info
;
519 struct dbx_symfile_info
*dbxinfo
;
520 bfd
*abfd
= objfile
->obfd
;
521 coff_data_type
*cdata
= coff_data (abfd
);
522 char *name
= bfd_get_filename (abfd
);
524 unsigned int num_symbols
;
526 int stringtab_offset
;
527 struct cleanup
*back_to
, *cleanup_minimal_symbols
;
530 info
= (struct coff_symfile_info
*) objfile
->deprecated_sym_private
;
531 dbxinfo
= objfile
->deprecated_sym_stab_info
;
532 symfile_bfd
= abfd
; /* Kludge for swap routines. */
534 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
535 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
536 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
537 stringtab_offset
= symtab_offset
+ /* String table file offset */
538 num_symbols
* cdata
->local_symesz
;
540 /* Set a few file-statics that give us specific information about
541 the particular COFF file format we're reading. */
542 local_n_btmask
= cdata
->local_n_btmask
;
543 local_n_btshft
= cdata
->local_n_btshft
;
544 local_n_tmask
= cdata
->local_n_tmask
;
545 local_n_tshift
= cdata
->local_n_tshift
;
546 local_linesz
= cdata
->local_linesz
;
547 local_symesz
= cdata
->local_symesz
;
548 local_auxesz
= cdata
->local_auxesz
;
550 /* Allocate space for raw symbol and aux entries, based on their
551 space requirements as reported by BFD. */
552 temp_sym
= (char *) xmalloc
553 (cdata
->local_symesz
+ cdata
->local_auxesz
);
554 temp_aux
= temp_sym
+ cdata
->local_symesz
;
555 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
557 /* We need to know whether this is a PE file, because in PE files,
558 unlike standard COFF files, symbol values are stored as offsets
559 from the section address, rather than as absolute addresses.
560 FIXME: We should use BFD to read the symbol table, and thus avoid
563 strncmp (bfd_get_target (objfile
->obfd
), "pe", 2) == 0
564 || strncmp (bfd_get_target (objfile
->obfd
), "epoc-pe", 7) == 0;
566 /* End of warning. */
568 info
->min_lineno_offset
= 0;
569 info
->max_lineno_offset
= 0;
571 /* Only read line number information if we have symbols.
573 On Windows NT, some of the system's DLL's have sections with
574 PointerToLinenumbers fields that are non-zero, but point at
575 random places within the image file. (In the case I found,
576 KERNEL32.DLL's .text section has a line number info pointer that
577 points into the middle of the string `lib\\i386\kernel32.dll'.)
579 However, these DLL's also have no symbols. The line number
580 tables are meaningless without symbols. And in fact, GDB never
581 uses the line number information unless there are symbols. So we
582 can avoid spurious error messages (and maybe run a little
583 faster!) by not even reading the line number table unless we have
587 /* Read the line number table, all at once. */
588 bfd_map_over_sections (abfd
, find_linenos
, (void *) info
);
590 make_cleanup (free_linetab_cleanup
, 0 /*ignore*/);
591 val
= init_lineno (abfd
, info
->min_lineno_offset
,
592 info
->max_lineno_offset
- info
->min_lineno_offset
);
594 error (_("\"%s\": error reading line numbers."), name
);
597 /* Now read the string table, all at once. */
599 make_cleanup (free_stringtab_cleanup
, 0 /*ignore*/);
600 val
= init_stringtab (abfd
, stringtab_offset
);
602 error (_("\"%s\": can't get string table"), name
);
604 init_minimal_symbol_collection ();
605 cleanup_minimal_symbols
= make_cleanup_discard_minimal_symbols ();
607 /* Now that the executable file is positioned at symbol table,
608 process it and define symbols accordingly. */
610 coff_symtab_read ((long) symtab_offset
, num_symbols
, objfile
);
612 /* Install any minimal symbols that have been collected as the
613 current minimal symbols for this objfile. */
615 install_minimal_symbols (objfile
);
617 /* Free the installed minimal symbol data. */
618 do_cleanups (cleanup_minimal_symbols
);
620 bfd_map_over_sections (abfd
, coff_locate_sections
, (void *) info
);
624 if (!info
->stabstrsect
)
626 error (_("The debugging information in `%s' is corrupted.\nThe "
627 "file has a `.stabs' section, but no `.stabstr' section."),
631 /* FIXME: dubious. Why can't we use something normal like
632 bfd_get_section_contents? */
633 bfd_seek (abfd
, abfd
->where
, 0);
635 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
637 coffstab_build_psymtabs (objfile
,
638 info
->textaddr
, info
->textsize
,
640 info
->stabstrsect
->filepos
, stabstrsize
);
642 if (dwarf2_has_info (objfile
, NULL
))
644 /* DWARF2 sections. */
645 dwarf2_build_psymtabs (objfile
);
648 dwarf2_build_frame_info (objfile
);
650 /* Try to add separate debug file if no symbols table found. */
651 if (!objfile_has_partial_symbols (objfile
))
655 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
656 make_cleanup (xfree
, debugfile
);
660 bfd
*abfd
= symfile_bfd_open (debugfile
);
662 make_cleanup_bfd_unref (abfd
);
663 symbol_file_add_separate (abfd
, symfile_flags
, objfile
);
667 do_cleanups (back_to
);
671 coff_new_init (struct objfile
*ignore
)
675 /* Perform any local cleanups required when we are done with a
676 particular objfile. I.E, we are in the process of discarding all
677 symbol information for an objfile, freeing up all memory held for
678 it, and unlinking the objfile struct from the global list of known
682 coff_symfile_finish (struct objfile
*objfile
)
684 if (objfile
->deprecated_sym_private
!= NULL
)
686 xfree (objfile
->deprecated_sym_private
);
689 /* Let stabs reader clean up. */
690 stabsread_clear_cache ();
692 dwarf2_free_objfile (objfile
);
696 /* Given pointers to a symbol table in coff style exec file,
697 analyze them and create struct symtab's describing the symbols.
698 NSYMS is the number of symbols in the symbol table.
699 We read them one at a time using read_one_sym (). */
702 coff_symtab_read (long symtab_offset
, unsigned int nsyms
,
703 struct objfile
*objfile
)
705 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
706 struct context_stack
*new;
707 struct coff_symbol coff_symbol
;
708 struct coff_symbol
*cs
= &coff_symbol
;
709 static struct internal_syment main_sym
;
710 static union internal_auxent main_aux
;
711 struct coff_symbol fcn_cs_saved
;
712 static struct internal_syment fcn_sym_saved
;
713 static union internal_auxent fcn_aux_saved
;
715 /* A .file is open. */
716 int in_source_file
= 0;
717 int next_file_symnum
= -1;
718 /* Name of the current file. */
719 const char *filestring
= "";
721 int fcn_first_line
= 0;
722 CORE_ADDR fcn_first_line_addr
= 0;
723 int fcn_last_line
= 0;
724 int fcn_start_addr
= 0;
725 long fcn_line_ptr
= 0;
728 struct minimal_symbol
*msym
;
730 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
731 it's hard to know I've really worked around it. The fix should
732 be harmless, anyway). The symptom of the bug is that the first
733 fread (in read_one_sym), will (in my example) actually get data
734 from file offset 268, when the fseek was to 264 (and ftell shows
735 264). This causes all hell to break loose. I was unable to
736 reproduce this on a short test program which operated on the same
737 file, performing (I think) the same sequence of operations.
739 It stopped happening when I put in this (former) rewind().
741 FIXME: Find out if this has been reported to Sun, whether it has
742 been fixed in a later release, etc. */
744 bfd_seek (objfile
->obfd
, 0, 0);
746 /* Position to read the symbol table. */
747 val
= bfd_seek (objfile
->obfd
, (long) symtab_offset
, 0);
749 perror_with_name (objfile
->name
);
751 coffread_objfile
= objfile
;
752 nlist_bfd_global
= objfile
->obfd
;
753 nlist_nsyms_global
= nsyms
;
754 last_source_file
= NULL
;
755 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
757 if (type_vector
) /* Get rid of previous one. */
759 type_vector_length
= 160;
760 type_vector
= (struct type
**)
761 xmalloc (type_vector_length
* sizeof (struct type
*));
762 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
764 coff_start_symtab ("");
767 while (symnum
< nsyms
)
769 QUIT
; /* Make this command interruptable. */
771 read_one_sym (cs
, &main_sym
, &main_aux
);
773 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
775 if (last_source_file
)
776 coff_end_symtab (objfile
);
778 coff_start_symtab ("_globals_");
779 /* coff_start_symtab will set the language of this symtab to
780 language_unknown, since such a ``file name'' is not
781 recognized. Override that with the minimal language to
782 allow printing values in this symtab. */
783 current_subfile
->language
= language_minimal
;
784 complete_symtab ("_globals_", 0, 0);
785 /* Done with all files, everything from here on out is
789 /* Special case for file with type declarations only, no
791 if (!last_source_file
&& SDB_TYPE (cs
->c_type
)
792 && cs
->c_secnum
== N_DEBUG
)
793 complete_symtab (filestring
, 0, 0);
795 /* Typedefs should not be treated as symbol definitions. */
796 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
798 /* Record all functions -- external and static -- in
800 int section
= cs_to_section (cs
, objfile
);
802 tmpaddr
= cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
803 SECT_OFF_TEXT (objfile
));
804 record_minimal_symbol (cs
, tmpaddr
, mst_text
,
807 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
808 fcn_start_addr
= tmpaddr
;
810 fcn_sym_saved
= main_sym
;
811 fcn_aux_saved
= main_aux
;
815 switch (cs
->c_sclass
)
824 complaint (&symfile_complaints
,
825 _("Bad n_sclass for symbol %s"),
830 /* c_value field contains symnum of next .file entry in
831 table or symnum of first global after last .file. */
832 next_file_symnum
= cs
->c_value
;
834 filestring
= coff_getfilename (&main_aux
);
838 /* Complete symbol table for last object file
839 containing debugging information. */
840 if (last_source_file
)
842 coff_end_symtab (objfile
);
843 coff_start_symtab (filestring
);
848 /* C_LABEL is used for labels and static functions.
849 Including it here allows gdb to see static functions when
850 no debug info is available. */
852 /* However, labels within a function can make weird
853 backtraces, so filter them out (from phdm@macqel.be). */
859 case C_THUMBSTATFUNC
:
860 if (cs
->c_name
[0] == '.')
862 if (strcmp (cs
->c_name
, ".text") == 0)
864 /* FIXME: don't wire in ".text" as section name or
866 /* Check for in_source_file deals with case of a
867 file with debugging symbols followed by a later
868 file with no symbols. */
870 complete_symtab (filestring
,
871 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
872 SECT_OFF_TEXT (objfile
)),
873 main_aux
.x_scn
.x_scnlen
);
876 /* Flush rest of '.' symbols. */
879 else if (!SDB_TYPE (cs
->c_type
)
880 && cs
->c_name
[0] == 'L'
881 && (strncmp (cs
->c_name
, "LI%", 3) == 0
882 || strncmp (cs
->c_name
, "LF%", 3) == 0
883 || strncmp (cs
->c_name
, "LC%", 3) == 0
884 || strncmp (cs
->c_name
, "LP%", 3) == 0
885 || strncmp (cs
->c_name
, "LPB%", 4) == 0
886 || strncmp (cs
->c_name
, "LBB%", 4) == 0
887 || strncmp (cs
->c_name
, "LBE%", 4) == 0
888 || strncmp (cs
->c_name
, "LPBX%", 5) == 0))
889 /* At least on a 3b1, gcc generates swbeg and string labels
890 that look like this. Ignore them. */
892 /* Fall in for static symbols that don't start with '.' */
897 /* Record it in the minimal symbols regardless of
898 SDB_TYPE. This parallels what we do for other debug
899 formats, and probably is needed to make
900 print_address_symbolic work right without the (now
901 gone) "set fast-symbolic-addr off" kludge. */
903 enum minimal_symbol_type ms_type
;
906 if (cs
->c_secnum
== N_UNDEF
)
908 /* This is a common symbol. We used to rely on
909 the target to tell us whether it knows where
910 the symbol has been relocated to, but none of
911 the target implementations actually provided
912 that operation. So we just ignore the symbol,
913 the same way we would do if we had a target-side
914 symbol lookup which returned no match. */
917 else if (cs
->c_secnum
== N_ABS
)
919 /* Use the correct minimal symbol type (and don't
920 relocate) for absolute values. */
922 sec
= cs_to_section (cs
, objfile
);
923 tmpaddr
= cs
->c_value
;
927 asection
*bfd_section
= cs_to_bfd_section (cs
, objfile
);
929 sec
= cs_to_section (cs
, objfile
);
930 tmpaddr
= cs
->c_value
;
931 /* Statics in a PE file also get relocated. */
932 if (cs
->c_sclass
== C_EXT
933 || cs
->c_sclass
== C_THUMBEXTFUNC
934 || cs
->c_sclass
== C_THUMBEXT
935 || (pe_file
&& (cs
->c_sclass
== C_STAT
)))
936 tmpaddr
+= ANOFFSET (objfile
->section_offsets
, sec
);
938 if (bfd_section
->flags
& SEC_CODE
)
941 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
942 || cs
->c_sclass
== C_THUMBEXT
?
943 mst_text
: mst_file_text
;
944 tmpaddr
= gdbarch_smash_text_address (gdbarch
, tmpaddr
);
946 else if (bfd_section
->flags
& SEC_ALLOC
947 && bfd_section
->flags
& SEC_LOAD
)
950 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
951 ? mst_data
: mst_file_data
;
953 else if (bfd_section
->flags
& SEC_ALLOC
)
956 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
957 ? mst_bss
: mst_file_bss
;
960 ms_type
= mst_unknown
;
963 msym
= record_minimal_symbol (cs
, tmpaddr
, ms_type
,
966 gdbarch_coff_make_msymbol_special (gdbarch
,
969 if (SDB_TYPE (cs
->c_type
))
973 sym
= process_coff_symbol
974 (cs
, &main_aux
, objfile
);
975 SYMBOL_VALUE (sym
) = tmpaddr
;
976 SYMBOL_SECTION (sym
) = sec
;
982 if (strcmp (cs
->c_name
, ".bf") == 0)
986 /* Value contains address of first non-init type
988 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
989 contains line number of '{' }. */
991 complaint (&symfile_complaints
,
992 _("`.bf' symbol %d has no aux entry"),
994 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
995 fcn_first_line_addr
= cs
->c_value
;
997 /* Might want to check that locals are 0 and
998 context_stack_depth is zero, and complain if not. */
1001 new = push_context (depth
, fcn_start_addr
);
1002 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1004 process_coff_symbol (&fcn_cs_saved
,
1005 &fcn_aux_saved
, objfile
);
1007 else if (strcmp (cs
->c_name
, ".ef") == 0)
1009 if (!within_function
)
1010 error (_("Bad coff function information."));
1011 /* The value of .ef is the address of epilogue code;
1012 not useful for gdb. */
1013 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1014 contains number of lines to '}' */
1016 if (context_stack_depth
<= 0)
1017 { /* We attempted to pop an empty context stack. */
1018 complaint (&symfile_complaints
,
1019 _("`.ef' symbol without matching `.bf' "
1020 "symbol ignored starting at symnum %d"),
1022 within_function
= 0;
1026 new = pop_context ();
1027 /* Stack must be empty now. */
1028 if (context_stack_depth
> 0 || new == NULL
)
1030 complaint (&symfile_complaints
,
1031 _("Unmatched .ef symbol(s) ignored "
1032 "starting at symnum %d"),
1034 within_function
= 0;
1037 if (cs
->c_naux
!= 1)
1039 complaint (&symfile_complaints
,
1040 _("`.ef' symbol %d has no aux entry"),
1042 fcn_last_line
= 0x7FFFFFFF;
1046 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1048 /* fcn_first_line is the line number of the opening '{'.
1049 Do not record it - because it would affect gdb's idea
1050 of the line number of the first statement of the
1051 function - except for one-line functions, for which
1052 it is also the line number of all the statements and
1053 of the closing '}', and for which we do not have any
1054 other statement-line-number. */
1055 if (fcn_last_line
== 1)
1056 record_line (current_subfile
, fcn_first_line
,
1057 gdbarch_addr_bits_remove (gdbarch
,
1058 fcn_first_line_addr
));
1060 enter_linenos (fcn_line_ptr
, fcn_first_line
,
1061 fcn_last_line
, objfile
);
1063 finish_block (new->name
, &local_symbols
,
1064 new->old_blocks
, new->start_addr
,
1065 fcn_cs_saved
.c_value
1066 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1067 + ANOFFSET (objfile
->section_offsets
,
1068 SECT_OFF_TEXT (objfile
)),
1071 within_function
= 0;
1076 if (strcmp (cs
->c_name
, ".bb") == 0)
1078 tmpaddr
= cs
->c_value
;
1079 tmpaddr
+= ANOFFSET (objfile
->section_offsets
,
1080 SECT_OFF_TEXT (objfile
));
1081 push_context (++depth
, tmpaddr
);
1083 else if (strcmp (cs
->c_name
, ".eb") == 0)
1085 if (context_stack_depth
<= 0)
1086 { /* We attempted to pop an empty context stack. */
1087 complaint (&symfile_complaints
,
1088 _("`.eb' symbol without matching `.bb' "
1089 "symbol ignored starting at symnum %d"),
1094 new = pop_context ();
1095 if (depth
-- != new->depth
)
1097 complaint (&symfile_complaints
,
1098 _("Mismatched .eb symbol ignored "
1099 "starting at symnum %d"),
1103 if (local_symbols
&& context_stack_depth
> 0)
1106 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
1107 SECT_OFF_TEXT (objfile
));
1108 /* Make a block for the local symbols within. */
1109 finish_block (0, &local_symbols
, new->old_blocks
,
1110 new->start_addr
, tmpaddr
, objfile
);
1112 /* Now pop locals of block just finished. */
1113 local_symbols
= new->locals
;
1118 process_coff_symbol (cs
, &main_aux
, objfile
);
1123 if ((nsyms
== 0) && (pe_file
))
1125 /* We've got no debugging symbols, but it's a portable
1126 executable, so try to read the export table. */
1127 read_pe_exported_syms (objfile
);
1130 if (last_source_file
)
1131 coff_end_symtab (objfile
);
1133 /* Patch up any opaque types (references to types that are not defined
1134 in the file where they are referenced, e.g. "struct foo *bar"). */
1135 ALL_OBJFILE_SYMTABS (objfile
, s
)
1136 patch_opaque_types (s
);
1138 coffread_objfile
= NULL
;
1141 /* Routines for reading headers and symbols from executable. */
1143 /* Read the next symbol, swap it, and return it in both
1144 internal_syment form, and coff_symbol form. Also return its first
1145 auxent, if any, in internal_auxent form, and skip any other
1149 read_one_sym (struct coff_symbol
*cs
,
1150 struct internal_syment
*sym
,
1151 union internal_auxent
*aux
)
1154 bfd_size_type bytes
;
1156 cs
->c_symnum
= symnum
;
1157 bytes
= bfd_bread (temp_sym
, local_symesz
, nlist_bfd_global
);
1158 if (bytes
!= local_symesz
)
1159 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1160 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1161 cs
->c_naux
= sym
->n_numaux
& 0xff;
1162 if (cs
->c_naux
>= 1)
1164 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1165 if (bytes
!= local_auxesz
)
1166 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1167 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
,
1168 sym
->n_type
, sym
->n_sclass
,
1169 0, cs
->c_naux
, (char *) aux
);
1170 /* If more than one aux entry, read past it (only the first aux
1172 for (i
= 1; i
< cs
->c_naux
; i
++)
1174 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1175 if (bytes
!= local_auxesz
)
1176 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1179 cs
->c_name
= getsymname (sym
);
1180 cs
->c_value
= sym
->n_value
;
1181 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1182 cs
->c_secnum
= sym
->n_scnum
;
1183 cs
->c_type
= (unsigned) sym
->n_type
;
1184 if (!SDB_TYPE (cs
->c_type
))
1188 if (cs
->c_sclass
& 128)
1189 printf (_("thumb symbol %s, class 0x%x\n"), cs
->c_name
, cs
->c_sclass
);
1192 symnum
+= 1 + cs
->c_naux
;
1194 /* The PE file format stores symbol values as offsets within the
1195 section, rather than as absolute addresses. We correct that
1196 here, if the symbol has an appropriate storage class. FIXME: We
1197 should use BFD to read the symbols, rather than duplicating the
1201 switch (cs
->c_sclass
)
1205 case C_THUMBEXTFUNC
:
1210 case C_THUMBSTATFUNC
:
1216 if (cs
->c_secnum
!= 0)
1217 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1223 /* Support for string table handling. */
1225 static char *stringtab
= NULL
;
1228 init_stringtab (bfd
*abfd
, long offset
)
1232 unsigned char lengthbuf
[4];
1236 /* If the file is stripped, the offset might be zero, indicating no
1237 string table. Just return with `stringtab' set to null. */
1241 if (bfd_seek (abfd
, offset
, 0) < 0)
1244 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1245 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1247 /* If no string table is needed, then the file may end immediately
1248 after the symbols. Just return with `stringtab' set to null. */
1249 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1252 stringtab
= (char *) xmalloc (length
);
1253 /* This is in target format (probably not very useful, and not
1254 currently used), not host format. */
1255 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1256 if (length
== sizeof length
) /* Empty table -- just the count. */
1259 val
= bfd_bread (stringtab
+ sizeof lengthbuf
,
1260 length
- sizeof lengthbuf
, abfd
);
1261 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1268 free_stringtab (void)
1276 free_stringtab_cleanup (void *ignore
)
1282 getsymname (struct internal_syment
*symbol_entry
)
1284 static char buffer
[SYMNMLEN
+ 1];
1287 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1289 /* FIXME: Probably should be detecting corrupt symbol files by
1290 seeing whether offset points to within the stringtab. */
1291 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1295 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1296 buffer
[SYMNMLEN
] = '\0';
1302 /* Extract the file name from the aux entry of a C_FILE symbol.
1303 Return only the last component of the name. Result is in static
1304 storage and is only good for temporary use. */
1307 coff_getfilename (union internal_auxent
*aux_entry
)
1309 static char buffer
[BUFSIZ
];
1312 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1314 if (strlen (stringtab
+ aux_entry
->x_file
.x_n
.x_offset
) >= BUFSIZ
)
1315 internal_error (__FILE__
, __LINE__
, _("coff file name too long"));
1316 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1320 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1321 buffer
[FILNMLEN
] = '\0';
1325 /* FIXME: We should not be throwing away the information about what
1326 directory. It should go into dirname of the symtab, or some such
1328 result
= lbasename (result
);
1332 /* Support for line number handling. */
1334 static char *linetab
= NULL
;
1335 static long linetab_offset
;
1336 static unsigned long linetab_size
;
1338 /* Read in all the line numbers for fast lookups later. Leave them in
1339 external (unswapped) format in memory; we'll swap them as we enter
1340 them into GDB's data structures. */
1343 init_lineno (bfd
*abfd
, long offset
, int size
)
1347 linetab_offset
= offset
;
1348 linetab_size
= size
;
1355 if (bfd_seek (abfd
, offset
, 0) < 0)
1358 /* Allocate the desired table, plus a sentinel. */
1359 linetab
= (char *) xmalloc (size
+ local_linesz
);
1361 val
= bfd_bread (linetab
, size
, abfd
);
1365 /* Terminate it with an all-zero sentinel record. */
1366 memset (linetab
+ size
, 0, local_linesz
);
1380 free_linetab_cleanup (void *ignore
)
1385 #if !defined (L_LNNO32)
1386 #define L_LNNO32(lp) ((lp)->l_lnno)
1390 enter_linenos (long file_offset
, int first_line
,
1391 int last_line
, struct objfile
*objfile
)
1393 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1395 struct internal_lineno lptr
;
1399 if (file_offset
< linetab_offset
)
1401 complaint (&symfile_complaints
,
1402 _("Line number pointer %ld lower than start of line numbers"),
1404 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1406 file_offset
+= linetab_offset
; /* Try reading at that linetab
1410 rawptr
= &linetab
[file_offset
- linetab_offset
];
1412 /* Skip first line entry for each function. */
1413 rawptr
+= local_linesz
;
1414 /* Line numbers start at one for the first line of the function. */
1417 /* If the line number table is full (e.g. 64K lines in COFF debug
1418 info), the next function's L_LNNO32 might not be zero, so don't
1419 overstep the table's end in any case. */
1420 while (rawptr
<= &linetab
[0] + linetab_size
)
1422 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1423 rawptr
+= local_linesz
;
1424 /* The next function, or the sentinel, will have L_LNNO32 zero;
1426 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1428 CORE_ADDR addr
= lptr
.l_addr
.l_paddr
;
1429 addr
+= ANOFFSET (objfile
->section_offsets
,
1430 SECT_OFF_TEXT (objfile
));
1431 record_line (current_subfile
,
1432 first_line
+ L_LNNO32 (&lptr
),
1433 gdbarch_addr_bits_remove (gdbarch
, addr
));
1441 patch_type (struct type
*type
, struct type
*real_type
)
1443 struct type
*target
= TYPE_TARGET_TYPE (type
);
1444 struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1445 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1447 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1448 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1449 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
,
1452 memcpy (TYPE_FIELDS (target
),
1453 TYPE_FIELDS (real_target
),
1456 if (TYPE_NAME (real_target
))
1458 /* The previous copy of TYPE_NAME is allocated by
1459 process_coff_symbol. */
1460 if (TYPE_NAME (target
))
1461 xfree ((char*) TYPE_NAME (target
));
1462 TYPE_NAME (target
) = xstrdup (TYPE_NAME (real_target
));
1466 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1467 so that they can be used to print out opaque data structures
1471 patch_opaque_types (struct symtab
*s
)
1474 struct block_iterator iter
;
1475 struct symbol
*real_sym
;
1477 /* Go through the per-file symbols only. */
1478 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1479 ALL_BLOCK_SYMBOLS (b
, iter
, real_sym
)
1481 /* Find completed typedefs to use to fix opaque ones.
1482 Remove syms from the chain when their types are stored,
1483 but search the whole chain, as there may be several syms
1484 from different files with the same name. */
1485 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
1486 && SYMBOL_DOMAIN (real_sym
) == VAR_DOMAIN
1487 && TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
1488 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1490 const char *name
= SYMBOL_LINKAGE_NAME (real_sym
);
1491 int hash
= hashname (name
);
1492 struct symbol
*sym
, *prev
;
1495 for (sym
= opaque_type_chain
[hash
]; sym
;)
1497 if (name
[0] == SYMBOL_LINKAGE_NAME (sym
)[0]
1498 && strcmp (name
+ 1, SYMBOL_LINKAGE_NAME (sym
) + 1) == 0)
1502 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1506 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1509 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1513 sym
= SYMBOL_VALUE_CHAIN (prev
);
1517 sym
= opaque_type_chain
[hash
];
1523 sym
= SYMBOL_VALUE_CHAIN (sym
);
1531 coff_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
1533 return gdbarch_sdb_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
1536 static const struct symbol_register_ops coff_register_funcs
= {
1540 static struct symbol
*
1541 process_coff_symbol (struct coff_symbol
*cs
,
1542 union internal_auxent
*aux
,
1543 struct objfile
*objfile
)
1546 = (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
1547 sizeof (struct symbol
));
1550 memset (sym
, 0, sizeof (struct symbol
));
1552 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1553 SYMBOL_SET_LANGUAGE (sym
, current_subfile
->language
);
1554 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), 1, objfile
);
1556 /* default assumptions */
1557 SYMBOL_VALUE (sym
) = cs
->c_value
;
1558 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1559 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1561 if (ISFCN (cs
->c_type
))
1563 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
,
1564 SECT_OFF_TEXT (objfile
));
1566 lookup_function_type (decode_function_type (cs
, cs
->c_type
,
1569 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1570 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1571 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1572 add_symbol_to_list (sym
, &file_symbols
);
1573 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1574 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1575 add_symbol_to_list (sym
, &global_symbols
);
1579 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
, objfile
);
1580 switch (cs
->c_sclass
)
1586 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1587 add_symbol_to_list (sym
, &local_symbols
);
1591 case C_THUMBEXTFUNC
:
1593 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1594 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1595 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1596 SECT_OFF_TEXT (objfile
));
1597 add_symbol_to_list (sym
, &global_symbols
);
1601 case C_THUMBSTATFUNC
:
1603 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1604 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1605 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1606 SECT_OFF_TEXT (objfile
));
1607 if (within_function
)
1609 /* Static symbol of local scope. */
1610 add_symbol_to_list (sym
, &local_symbols
);
1614 /* Static symbol at top level of file. */
1615 add_symbol_to_list (sym
, &file_symbols
);
1619 #ifdef C_GLBLREG /* AMD coff */
1623 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1624 SYMBOL_REGISTER_OPS (sym
) = &coff_register_funcs
;
1625 SYMBOL_VALUE (sym
) = cs
->c_value
;
1626 add_symbol_to_list (sym
, &local_symbols
);
1634 SYMBOL_CLASS (sym
) = LOC_ARG
;
1635 SYMBOL_IS_ARGUMENT (sym
) = 1;
1636 add_symbol_to_list (sym
, &local_symbols
);
1640 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1641 SYMBOL_REGISTER_OPS (sym
) = &coff_register_funcs
;
1642 SYMBOL_IS_ARGUMENT (sym
) = 1;
1643 SYMBOL_VALUE (sym
) = cs
->c_value
;
1644 add_symbol_to_list (sym
, &local_symbols
);
1648 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1649 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1651 /* If type has no name, give it one. */
1652 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1654 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1655 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1657 /* If we are giving a name to a type such as
1658 "pointer to foo" or "function returning foo", we
1659 better not set the TYPE_NAME. If the program
1660 contains "typedef char *caddr_t;", we don't want
1661 all variables of type char * to print as caddr_t.
1662 This is not just a consequence of GDB's type
1663 management; CC and GCC (at least through version
1664 2.4) both output variables of either type char *
1665 or caddr_t with the type refering to the C_TPDEF
1666 symbol for caddr_t. If a future compiler cleans
1667 this up it GDB is not ready for it yet, but if it
1668 becomes ready we somehow need to disable this
1669 check (without breaking the PCC/GCC2.4 case).
1673 Fortunately, this check seems not to be necessary
1674 for anything except pointers or functions. */
1678 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1679 xstrdup (SYMBOL_LINKAGE_NAME (sym
));
1682 /* Keep track of any type which points to empty structured
1683 type, so it can be filled from a definition from another
1684 file. A simple forward reference (TYPE_CODE_UNDEF) is
1685 not an empty structured type, though; the forward
1686 references work themselves out via the magic of
1687 coff_lookup_type. */
1688 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1689 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0
1690 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
)))
1693 int i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
1695 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1696 opaque_type_chain
[i
] = sym
;
1698 add_symbol_to_list (sym
, &file_symbols
);
1704 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1705 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
1707 /* Some compilers try to be helpful by inventing "fake"
1708 names for anonymous enums, structures, and unions, like
1709 "~0fake" or ".0fake". Thanks, but no thanks... */
1710 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1711 if (SYMBOL_LINKAGE_NAME (sym
) != NULL
1712 && *SYMBOL_LINKAGE_NAME (sym
) != '~'
1713 && *SYMBOL_LINKAGE_NAME (sym
) != '.')
1714 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1715 concat (SYMBOL_LINKAGE_NAME (sym
), (char *)NULL
);
1717 add_symbol_to_list (sym
, &file_symbols
);
1727 /* Decode a coff type specifier; return the type that is meant. */
1729 static struct type
*
1730 decode_type (struct coff_symbol
*cs
, unsigned int c_type
,
1731 union internal_auxent
*aux
, struct objfile
*objfile
)
1733 struct type
*type
= 0;
1734 unsigned int new_c_type
;
1736 if (c_type
& ~N_BTMASK
)
1738 new_c_type
= DECREF (c_type
);
1741 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1742 type
= lookup_pointer_type (type
);
1744 else if (ISFCN (c_type
))
1746 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1747 type
= lookup_function_type (type
);
1749 else if (ISARY (c_type
))
1752 unsigned short *dim
;
1753 struct type
*base_type
, *index_type
, *range_type
;
1755 /* Define an array type. */
1756 /* auxent refers to array, not base type. */
1757 if (aux
->x_sym
.x_tagndx
.l
== 0)
1760 /* Shift the indices down. */
1761 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1764 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1768 base_type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1769 index_type
= objfile_type (objfile
)->builtin_int
;
1771 create_range_type ((struct type
*) NULL
,
1772 index_type
, 0, n
- 1);
1774 create_array_type ((struct type
*) NULL
,
1775 base_type
, range_type
);
1780 /* Reference to existing type. This only occurs with the struct,
1781 union, and enum types. EPI a29k coff fakes us out by producing
1782 aux entries with a nonzero x_tagndx for definitions of structs,
1783 unions, and enums, so we have to check the c_sclass field. SCO
1784 3.2v4 cc gets confused with pointers to pointers to defined
1785 structs, and generates negative x_tagndx fields. */
1786 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1788 if (cs
->c_sclass
!= C_STRTAG
1789 && cs
->c_sclass
!= C_UNTAG
1790 && cs
->c_sclass
!= C_ENTAG
1791 && aux
->x_sym
.x_tagndx
.l
>= 0)
1793 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1798 complaint (&symfile_complaints
,
1799 _("Symbol table entry for %s has bad tagndx value"),
1801 /* And fall through to decode_base_type... */
1805 return decode_base_type (cs
, BTYPE (c_type
), aux
, objfile
);
1808 /* Decode a coff type specifier for function definition;
1809 return the type that the function returns. */
1811 static struct type
*
1812 decode_function_type (struct coff_symbol
*cs
,
1813 unsigned int c_type
,
1814 union internal_auxent
*aux
,
1815 struct objfile
*objfile
)
1817 if (aux
->x_sym
.x_tagndx
.l
== 0)
1818 cs
->c_naux
= 0; /* auxent refers to function, not base
1821 return decode_type (cs
, DECREF (c_type
), aux
, objfile
);
1824 /* Basic C types. */
1826 static struct type
*
1827 decode_base_type (struct coff_symbol
*cs
,
1828 unsigned int c_type
,
1829 union internal_auxent
*aux
,
1830 struct objfile
*objfile
)
1832 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1838 /* Shows up with "void (*foo)();" structure members. */
1839 return objfile_type (objfile
)->builtin_void
;
1843 /* Intel 960 COFF has this symbol and meaning. */
1844 return objfile_type (objfile
)->builtin_void
;
1848 return objfile_type (objfile
)->builtin_char
;
1851 return objfile_type (objfile
)->builtin_short
;
1854 return objfile_type (objfile
)->builtin_int
;
1857 if (cs
->c_sclass
== C_FIELD
1858 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1859 > gdbarch_long_bit (gdbarch
))
1860 return objfile_type (objfile
)->builtin_long_long
;
1862 return objfile_type (objfile
)->builtin_long
;
1865 return objfile_type (objfile
)->builtin_float
;
1868 return objfile_type (objfile
)->builtin_double
;
1871 return objfile_type (objfile
)->builtin_long_double
;
1874 if (cs
->c_naux
!= 1)
1876 /* Anonymous structure type. */
1877 type
= coff_alloc_type (cs
->c_symnum
);
1878 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1879 TYPE_NAME (type
) = NULL
;
1880 /* This used to set the tag to "<opaque>". But I think
1881 setting it to NULL is right, and the printing code can
1882 print it as "struct {...}". */
1883 TYPE_TAG_NAME (type
) = NULL
;
1884 INIT_CPLUS_SPECIFIC (type
);
1885 TYPE_LENGTH (type
) = 0;
1886 TYPE_FIELDS (type
) = 0;
1887 TYPE_NFIELDS (type
) = 0;
1891 type
= coff_read_struct_type (cs
->c_symnum
,
1892 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1893 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1899 if (cs
->c_naux
!= 1)
1901 /* Anonymous union type. */
1902 type
= coff_alloc_type (cs
->c_symnum
);
1903 TYPE_NAME (type
) = NULL
;
1904 /* This used to set the tag to "<opaque>". But I think
1905 setting it to NULL is right, and the printing code can
1906 print it as "union {...}". */
1907 TYPE_TAG_NAME (type
) = NULL
;
1908 INIT_CPLUS_SPECIFIC (type
);
1909 TYPE_LENGTH (type
) = 0;
1910 TYPE_FIELDS (type
) = 0;
1911 TYPE_NFIELDS (type
) = 0;
1915 type
= coff_read_struct_type (cs
->c_symnum
,
1916 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1917 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1920 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1924 if (cs
->c_naux
!= 1)
1926 /* Anonymous enum type. */
1927 type
= coff_alloc_type (cs
->c_symnum
);
1928 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1929 TYPE_NAME (type
) = NULL
;
1930 /* This used to set the tag to "<opaque>". But I think
1931 setting it to NULL is right, and the printing code can
1932 print it as "enum {...}". */
1933 TYPE_TAG_NAME (type
) = NULL
;
1934 TYPE_LENGTH (type
) = 0;
1935 TYPE_FIELDS (type
) = 0;
1936 TYPE_NFIELDS (type
) = 0;
1940 type
= coff_read_enum_type (cs
->c_symnum
,
1941 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1942 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1948 /* Shouldn't show up here. */
1952 return objfile_type (objfile
)->builtin_unsigned_char
;
1955 return objfile_type (objfile
)->builtin_unsigned_short
;
1958 return objfile_type (objfile
)->builtin_unsigned_int
;
1961 if (cs
->c_sclass
== C_FIELD
1962 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1963 > gdbarch_long_bit (gdbarch
))
1964 return objfile_type (objfile
)->builtin_unsigned_long_long
;
1966 return objfile_type (objfile
)->builtin_unsigned_long
;
1968 complaint (&symfile_complaints
,
1969 _("Unexpected type for symbol %s"), cs
->c_name
);
1970 return objfile_type (objfile
)->builtin_void
;
1973 /* This page contains subroutines of read_type. */
1975 /* Read the description of a structure (or union type) and return an
1976 object describing the type. */
1978 static struct type
*
1979 coff_read_struct_type (int index
, int length
, int lastsym
,
1980 struct objfile
*objfile
)
1984 struct nextfield
*next
;
1989 struct nextfield
*list
= 0;
1990 struct nextfield
*new;
1994 struct coff_symbol member_sym
;
1995 struct coff_symbol
*ms
= &member_sym
;
1996 struct internal_syment sub_sym
;
1997 union internal_auxent sub_aux
;
2000 type
= coff_alloc_type (index
);
2001 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2002 INIT_CPLUS_SPECIFIC (type
);
2003 TYPE_LENGTH (type
) = length
;
2005 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2007 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2009 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2011 switch (ms
->c_sclass
)
2016 /* Get space to record the next field's data. */
2017 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2021 /* Save the data. */
2022 list
->field
.name
= obsavestring (name
, strlen (name
),
2023 &objfile
->objfile_obstack
);
2024 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2026 SET_FIELD_BITPOS (list
->field
, 8 * ms
->c_value
);
2027 FIELD_BITSIZE (list
->field
) = 0;
2033 /* Get space to record the next field's data. */
2034 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2038 /* Save the data. */
2039 list
->field
.name
= obsavestring (name
, strlen (name
),
2040 &objfile
->objfile_obstack
);
2041 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2043 SET_FIELD_BITPOS (list
->field
, ms
->c_value
);
2044 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2053 /* Now create the vector of fields, and record how big it is. */
2055 TYPE_NFIELDS (type
) = nfields
;
2056 TYPE_FIELDS (type
) = (struct field
*)
2057 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2059 /* Copy the saved-up fields into the field vector. */
2061 for (n
= nfields
; list
; list
= list
->next
)
2062 TYPE_FIELD (type
, --n
) = list
->field
;
2067 /* Read a definition of an enumeration type,
2068 and create and return a suitable type object.
2069 Also defines the symbols that represent the values of the type. */
2071 static struct type
*
2072 coff_read_enum_type (int index
, int length
, int lastsym
,
2073 struct objfile
*objfile
)
2075 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2080 struct pending
**symlist
;
2081 struct coff_symbol member_sym
;
2082 struct coff_symbol
*ms
= &member_sym
;
2083 struct internal_syment sub_sym
;
2084 union internal_auxent sub_aux
;
2085 struct pending
*osyms
, *syms
;
2089 int unsigned_enum
= 1;
2091 type
= coff_alloc_type (index
);
2092 if (within_function
)
2093 symlist
= &local_symbols
;
2095 symlist
= &file_symbols
;
2097 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2099 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2101 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2103 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2105 switch (ms
->c_sclass
)
2108 sym
= (struct symbol
*) obstack_alloc
2109 (&objfile
->objfile_obstack
, sizeof (struct symbol
));
2110 memset (sym
, 0, sizeof (struct symbol
));
2112 SYMBOL_SET_LINKAGE_NAME (sym
,
2113 obsavestring (name
, strlen (name
),
2114 &objfile
->objfile_obstack
));
2115 SYMBOL_CLASS (sym
) = LOC_CONST
;
2116 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2117 SYMBOL_VALUE (sym
) = ms
->c_value
;
2118 add_symbol_to_list (sym
, symlist
);
2123 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2124 up the count of how many symbols to read. So stop
2131 /* Now fill in the fields of the type-structure. */
2134 TYPE_LENGTH (type
) = length
;
2135 else /* Assume ints. */
2136 TYPE_LENGTH (type
) = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
2137 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2138 TYPE_NFIELDS (type
) = nsyms
;
2139 TYPE_FIELDS (type
) = (struct field
*)
2140 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2142 /* Find the symbols for the values and put them into the type.
2143 The symbols can be found in the symlist that we put them on
2144 to cause them to be defined. osyms contains the old value
2145 of that symlist; everything up to there was defined by us. */
2146 /* Note that we preserve the order of the enum constants, so
2147 that in something like "enum {FOO, LAST_THING=FOO}" we print
2148 FOO, not LAST_THING. */
2150 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2156 for (; j
< syms
->nsyms
; j
++, n
++)
2158 struct symbol
*xsym
= syms
->symbol
[j
];
2160 SYMBOL_TYPE (xsym
) = type
;
2161 TYPE_FIELD_NAME (type
, n
) = SYMBOL_LINKAGE_NAME (xsym
);
2162 SET_FIELD_ENUMVAL (TYPE_FIELD (type
, n
), SYMBOL_VALUE (xsym
));
2163 if (SYMBOL_VALUE (xsym
) < 0)
2165 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2172 TYPE_UNSIGNED (type
) = 1;
2177 /* Register our ability to parse symbols for coff BFD files. */
2179 static const struct sym_fns coff_sym_fns
=
2181 bfd_target_coff_flavour
,
2182 coff_new_init
, /* sym_new_init: init anything gbl to
2184 coff_symfile_init
, /* sym_init: read initial info, setup
2186 coff_symfile_read
, /* sym_read: read a symbol file into
2188 NULL
, /* sym_read_psymbols */
2189 coff_symfile_finish
, /* sym_finish: finished with file,
2191 default_symfile_offsets
, /* sym_offsets: xlate external to
2193 default_symfile_segments
, /* sym_segments: Get segment
2194 information from a file */
2195 NULL
, /* sym_read_linetable */
2197 default_symfile_relocate
, /* sym_relocate: Relocate a debug
2199 NULL
, /* sym_probe_fns */
2204 _initialize_coffread (void)
2206 add_symtab_fns (&coff_sym_fns
);