1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2013 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 /* Key for COFF-associated data. */
52 static const struct objfile_data
*coff_objfile_data_key
;
54 /* The objfile we are currently reading. */
56 static struct objfile
*coffread_objfile
;
58 struct coff_symfile_info
60 file_ptr min_lineno_offset
; /* Where in file lowest line#s are. */
61 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file. */
63 CORE_ADDR textaddr
; /* Addr of .text section. */
64 unsigned int textsize
; /* Size of .text section. */
65 struct stab_section_list
*stabsects
; /* .stab sections. */
66 asection
*stabstrsect
; /* Section pointer for .stab section. */
70 /* Translate an external name string into a user-visible name. */
71 #define EXTERNAL_NAME(string, abfd) \
72 (string[0] == bfd_get_symbol_leading_char (abfd) \
73 ? string + 1 : string)
75 /* To be an sdb debug type, type must have at least a basic or primary
76 derived type. Using this rather than checking against T_NULL is
77 said to prevent core dumps if we try to operate on Michael Bloom
80 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
82 /* Core address of start and end of text of current source file.
83 This comes from a ".text" symbol where x_nlinno > 0. */
85 static CORE_ADDR current_source_start_addr
;
86 static CORE_ADDR current_source_end_addr
;
88 /* The addresses of the symbol table stream and number of symbols
89 of the object file we are reading (as copied into core). */
91 static bfd
*nlist_bfd_global
;
92 static int nlist_nsyms_global
;
95 /* Pointers to scratch storage, used for reading raw symbols and
98 static char *temp_sym
;
99 static char *temp_aux
;
101 /* Local variables that hold the shift and mask values for the
102 COFF file that we are currently reading. These come back to us
103 from BFD, and are referenced by their macro names, as well as
104 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
105 macros from include/coff/internal.h . */
107 static unsigned local_n_btmask
;
108 static unsigned local_n_btshft
;
109 static unsigned local_n_tmask
;
110 static unsigned local_n_tshift
;
112 #define N_BTMASK local_n_btmask
113 #define N_BTSHFT local_n_btshft
114 #define N_TMASK local_n_tmask
115 #define N_TSHIFT local_n_tshift
117 /* Local variables that hold the sizes in the file of various COFF
118 structures. (We only need to know this to read them from the file
119 -- BFD will then translate the data in them, into `internal_xxx'
120 structs in the right byte order, alignment, etc.) */
122 static unsigned local_linesz
;
123 static unsigned local_symesz
;
124 static unsigned local_auxesz
;
126 /* This is set if this is a PE format file. */
130 /* Chain of typedefs of pointers to empty struct/union types.
131 They are chained thru the SYMBOL_VALUE_CHAIN. */
133 static struct symbol
*opaque_type_chain
[HASHSIZE
];
135 /* Simplified internal version of coff symbol table information. */
140 int c_symnum
; /* Symbol number of this entry. */
141 int c_naux
; /* 0 if syment only, 1 if syment +
149 extern void stabsread_clear_cache (void);
151 static struct type
*coff_read_struct_type (int, int, int,
154 static struct type
*decode_base_type (struct coff_symbol
*,
156 union internal_auxent
*,
159 static struct type
*decode_type (struct coff_symbol
*, unsigned int,
160 union internal_auxent
*,
163 static struct type
*decode_function_type (struct coff_symbol
*,
165 union internal_auxent
*,
168 static struct type
*coff_read_enum_type (int, int, int,
171 static struct symbol
*process_coff_symbol (struct coff_symbol
*,
172 union internal_auxent
*,
175 static void patch_opaque_types (struct symtab
*);
177 static void enter_linenos (long, int, int, struct objfile
*);
179 static void free_linetab (void);
181 static void free_linetab_cleanup (void *ignore
);
183 static int init_lineno (bfd
*, long, int);
185 static char *getsymname (struct internal_syment
*);
187 static const char *coff_getfilename (union internal_auxent
*);
189 static void free_stringtab (void);
191 static void free_stringtab_cleanup (void *ignore
);
193 static int init_stringtab (bfd
*, long);
195 static void read_one_sym (struct coff_symbol
*,
196 struct internal_syment
*,
197 union internal_auxent
*);
199 static void coff_symtab_read (long, unsigned int, struct objfile
*);
201 /* We are called once per section from coff_symfile_read. We
202 need to examine each section we are passed, check to see
203 if it is something we are interested in processing, and
204 if so, stash away some access information for the section.
206 FIXME: The section names should not be hardwired strings (what
207 should they be? I don't think most object file formats have enough
208 section flags to specify what kind of debug section it is
212 coff_locate_sections (bfd
*abfd
, asection
*sectp
, void *csip
)
214 struct coff_symfile_info
*csi
;
217 csi
= (struct coff_symfile_info
*) csip
;
218 name
= bfd_get_section_name (abfd
, sectp
);
219 if (strcmp (name
, ".text") == 0)
221 csi
->textaddr
= bfd_section_vma (abfd
, sectp
);
222 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
224 else if (strncmp (name
, ".text", sizeof ".text" - 1) == 0)
226 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
228 else if (strcmp (name
, ".stabstr") == 0)
230 csi
->stabstrsect
= sectp
;
232 else if (strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
236 /* We can have multiple .stab sections if linked with
238 for (s
= name
+ sizeof ".stab" - 1; *s
!= '\0'; s
++)
243 struct stab_section_list
*n
, **pn
;
245 n
= ((struct stab_section_list
*)
246 xmalloc (sizeof (struct stab_section_list
)));
249 for (pn
= &csi
->stabsects
; *pn
!= NULL
; pn
= &(*pn
)->next
)
253 /* This will be run after coffstab_build_psymtabs is called
254 in coff_symfile_read, at which point we no longer need
256 make_cleanup (xfree
, n
);
261 /* Return the section_offsets* that CS points to. */
262 static int cs_to_section (struct coff_symbol
*, struct objfile
*);
264 struct find_targ_sec_arg
271 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
273 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
275 if (sect
->target_index
== args
->targ_index
)
276 *args
->resultp
= sect
;
279 /* Return the bfd_section that CS points to. */
280 static struct bfd_section
*
281 cs_to_bfd_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
283 asection
*sect
= NULL
;
284 struct find_targ_sec_arg args
;
286 args
.targ_index
= cs
->c_secnum
;
287 args
.resultp
= §
;
288 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
292 /* Return the section number (SECT_OFF_*) that CS points to. */
294 cs_to_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
296 asection
*sect
= cs_to_bfd_section (cs
, objfile
);
299 return SECT_OFF_TEXT (objfile
);
300 return gdb_bfd_section_index (objfile
->obfd
, sect
);
303 /* Return the address of the section of a COFF symbol. */
305 static CORE_ADDR
cs_section_address (struct coff_symbol
*, bfd
*);
308 cs_section_address (struct coff_symbol
*cs
, bfd
*abfd
)
310 asection
*sect
= NULL
;
311 struct find_targ_sec_arg args
;
314 args
.targ_index
= cs
->c_secnum
;
315 args
.resultp
= §
;
316 bfd_map_over_sections (abfd
, find_targ_sec
, &args
);
318 addr
= bfd_get_section_vma (abfd
, sect
);
322 /* Look up a coff type-number index. Return the address of the slot
323 where the type for that index is stored.
324 The type-number is in INDEX.
326 This can be used for finding the type associated with that index
327 or for associating a new type with the index. */
329 static struct type
**
330 coff_lookup_type (int index
)
332 if (index
>= type_vector_length
)
334 int old_vector_length
= type_vector_length
;
336 type_vector_length
*= 2;
337 if (index
/* is still */ >= type_vector_length
)
338 type_vector_length
= index
* 2;
340 type_vector
= (struct type
**)
341 xrealloc ((char *) type_vector
,
342 type_vector_length
* sizeof (struct type
*));
343 memset (&type_vector
[old_vector_length
], 0,
344 (type_vector_length
- old_vector_length
) * sizeof (struct type
*));
346 return &type_vector
[index
];
349 /* Make sure there is a type allocated for type number index
350 and return the type object.
351 This can create an empty (zeroed) type object. */
354 coff_alloc_type (int index
)
356 struct type
**type_addr
= coff_lookup_type (index
);
357 struct type
*type
= *type_addr
;
359 /* If we are referring to a type not known at all yet,
360 allocate an empty type for it.
361 We will fill it in later if we find out how. */
364 type
= alloc_type (coffread_objfile
);
370 /* Start a new symtab for a new source file.
371 This is called when a COFF ".file" symbol is seen;
372 it indicates the start of data for one original source file. */
375 coff_start_symtab (const char *name
)
378 /* We fill in the filename later. start_symtab puts this pointer
379 into last_source_file and we put it in subfiles->name, which
380 end_symtab frees; that's why it must be malloc'd. */
382 /* We never know the directory name for COFF. */
384 /* The start address is irrelevant, since we set
385 last_source_start_addr in coff_end_symtab. */
387 record_debugformat ("COFF");
390 /* Save the vital information from when starting to read a file,
391 for use when closing off the current file.
392 NAME is the file name the symbols came from, START_ADDR is the
393 first text address for the file, and SIZE is the number of bytes of
397 complete_symtab (const char *name
, CORE_ADDR start_addr
, unsigned int size
)
399 set_last_source_file (name
);
400 current_source_start_addr
= start_addr
;
401 current_source_end_addr
= start_addr
+ size
;
404 /* Finish the symbol definitions for one main source file, close off
405 all the lexical contexts for that file (creating struct block's for
406 them), then make the struct symtab for that file and put it in the
410 coff_end_symtab (struct objfile
*objfile
)
412 last_source_start_addr
= current_source_start_addr
;
414 end_symtab (current_source_end_addr
, objfile
,
415 SECT_OFF_TEXT (objfile
));
417 /* Reinitialize for beginning of new file. */
418 set_last_source_file (NULL
);
421 /* The linker sometimes generates some non-function symbols inside
422 functions referencing variables imported from another DLL.
423 Return nonzero if the given symbol corresponds to one of them. */
426 is_import_fixup_symbol (struct coff_symbol
*cs
,
427 enum minimal_symbol_type type
)
429 /* The following is a bit of a heuristic using the characterictics
430 of these fixup symbols, but should work well in practice... */
433 /* Must be a non-static text symbol. */
434 if (type
!= mst_text
)
437 /* Must be a non-function symbol. */
438 if (ISFCN (cs
->c_type
))
441 /* The name must start with "__fu<digits>__". */
442 if (strncmp (cs
->c_name
, "__fu", 4) != 0)
444 if (! isdigit (cs
->c_name
[4]))
446 for (i
= 5; cs
->c_name
[i
] != '\0' && isdigit (cs
->c_name
[i
]); i
++)
447 /* Nothing, just incrementing index past all digits. */;
448 if (cs
->c_name
[i
] != '_' || cs
->c_name
[i
+ 1] != '_')
454 static struct minimal_symbol
*
455 record_minimal_symbol (struct coff_symbol
*cs
, CORE_ADDR address
,
456 enum minimal_symbol_type type
, int section
,
457 struct objfile
*objfile
)
459 /* We don't want TDESC entry points in the minimal symbol table. */
460 if (cs
->c_name
[0] == '@')
463 if (is_import_fixup_symbol (cs
, type
))
465 /* Because the value of these symbols is within a function code
466 range, these symbols interfere with the symbol-from-address
467 reverse lookup; this manifests itselfs in backtraces, or any
468 other commands that prints symbolic addresses. Just pretend
469 these symbols do not exist. */
473 return prim_record_minimal_symbol_and_info (cs
->c_name
, address
,
474 type
, section
, objfile
);
477 /* coff_symfile_init ()
478 is the coff-specific initialization routine for reading symbols.
479 It is passed a struct objfile which contains, among other things,
480 the BFD for the file whose symbols are being read, and a slot for
481 a pointer to "private data" which we fill with cookies and other
482 treats for coff_symfile_read ().
484 We will only be called if this is a COFF or COFF-like file. BFD
485 handles figuring out the format of the file, and code in symtab.c
486 uses BFD's determination to vector to us.
488 The ultimate result is a new symtab (or, FIXME, eventually a
492 coff_symfile_init (struct objfile
*objfile
)
494 struct dbx_symfile_info
*dbx
;
495 struct coff_symfile_info
*coff
;
497 /* Allocate struct to keep track of stab reading. */
498 dbx
= XCNEW (struct dbx_symfile_info
);
499 set_objfile_data (objfile
, dbx_objfile_data_key
, dbx
);
501 /* Allocate struct to keep track of the symfile. */
502 coff
= XCNEW (struct coff_symfile_info
);
503 set_objfile_data (objfile
, coff_objfile_data_key
, coff
);
505 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
506 find this causes a significant slowdown in gdb then we could
507 set it in the debug symbol readers only when necessary. */
508 objfile
->flags
|= OBJF_REORDERED
;
511 /* This function is called for every section; it finds the outer
512 limits of the line table (minimum and maximum file offset) so that
513 the mainline code can read the whole thing for efficiency. */
516 find_linenos (bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
518 struct coff_symfile_info
*info
;
520 file_ptr offset
, maxoff
;
522 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
523 count
= asect
->lineno_count
;
524 /* End of warning. */
528 size
= count
* local_linesz
;
530 info
= (struct coff_symfile_info
*) vpinfo
;
531 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
532 offset
= asect
->line_filepos
;
533 /* End of warning. */
535 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
536 info
->min_lineno_offset
= offset
;
538 maxoff
= offset
+ size
;
539 if (maxoff
> info
->max_lineno_offset
)
540 info
->max_lineno_offset
= maxoff
;
544 /* The BFD for this file -- only good while we're actively reading
545 symbols into a psymtab or a symtab. */
547 static bfd
*symfile_bfd
;
549 /* Read a symbol file, after initialization by coff_symfile_init. */
552 coff_symfile_read (struct objfile
*objfile
, int symfile_flags
)
554 struct coff_symfile_info
*info
;
555 struct dbx_symfile_info
*dbxinfo
;
556 bfd
*abfd
= objfile
->obfd
;
557 coff_data_type
*cdata
= coff_data (abfd
);
558 char *name
= bfd_get_filename (abfd
);
560 unsigned int num_symbols
;
562 int stringtab_offset
;
563 struct cleanup
*back_to
, *cleanup_minimal_symbols
;
566 info
= objfile_data (objfile
, coff_objfile_data_key
);
567 dbxinfo
= DBX_SYMFILE_INFO (objfile
);
568 symfile_bfd
= abfd
; /* Kludge for swap routines. */
570 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
571 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
572 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
573 stringtab_offset
= symtab_offset
+ /* String table file offset */
574 num_symbols
* cdata
->local_symesz
;
576 /* Set a few file-statics that give us specific information about
577 the particular COFF file format we're reading. */
578 local_n_btmask
= cdata
->local_n_btmask
;
579 local_n_btshft
= cdata
->local_n_btshft
;
580 local_n_tmask
= cdata
->local_n_tmask
;
581 local_n_tshift
= cdata
->local_n_tshift
;
582 local_linesz
= cdata
->local_linesz
;
583 local_symesz
= cdata
->local_symesz
;
584 local_auxesz
= cdata
->local_auxesz
;
586 /* Allocate space for raw symbol and aux entries, based on their
587 space requirements as reported by BFD. */
588 temp_sym
= (char *) xmalloc
589 (cdata
->local_symesz
+ cdata
->local_auxesz
);
590 temp_aux
= temp_sym
+ cdata
->local_symesz
;
591 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
593 /* We need to know whether this is a PE file, because in PE files,
594 unlike standard COFF files, symbol values are stored as offsets
595 from the section address, rather than as absolute addresses.
596 FIXME: We should use BFD to read the symbol table, and thus avoid
599 strncmp (bfd_get_target (objfile
->obfd
), "pe", 2) == 0
600 || strncmp (bfd_get_target (objfile
->obfd
), "epoc-pe", 7) == 0;
602 /* End of warning. */
604 info
->min_lineno_offset
= 0;
605 info
->max_lineno_offset
= 0;
607 /* Only read line number information if we have symbols.
609 On Windows NT, some of the system's DLL's have sections with
610 PointerToLinenumbers fields that are non-zero, but point at
611 random places within the image file. (In the case I found,
612 KERNEL32.DLL's .text section has a line number info pointer that
613 points into the middle of the string `lib\\i386\kernel32.dll'.)
615 However, these DLL's also have no symbols. The line number
616 tables are meaningless without symbols. And in fact, GDB never
617 uses the line number information unless there are symbols. So we
618 can avoid spurious error messages (and maybe run a little
619 faster!) by not even reading the line number table unless we have
623 /* Read the line number table, all at once. */
624 bfd_map_over_sections (abfd
, find_linenos
, (void *) info
);
626 make_cleanup (free_linetab_cleanup
, 0 /*ignore*/);
627 val
= init_lineno (abfd
, info
->min_lineno_offset
,
628 info
->max_lineno_offset
- info
->min_lineno_offset
);
630 error (_("\"%s\": error reading line numbers."), name
);
633 /* Now read the string table, all at once. */
635 make_cleanup (free_stringtab_cleanup
, 0 /*ignore*/);
636 val
= init_stringtab (abfd
, stringtab_offset
);
638 error (_("\"%s\": can't get string table"), name
);
640 init_minimal_symbol_collection ();
641 cleanup_minimal_symbols
= make_cleanup_discard_minimal_symbols ();
643 /* Now that the executable file is positioned at symbol table,
644 process it and define symbols accordingly. */
646 coff_symtab_read ((long) symtab_offset
, num_symbols
, objfile
);
648 /* Install any minimal symbols that have been collected as the
649 current minimal symbols for this objfile. */
651 install_minimal_symbols (objfile
);
653 /* Free the installed minimal symbol data. */
654 do_cleanups (cleanup_minimal_symbols
);
656 bfd_map_over_sections (abfd
, coff_locate_sections
, (void *) info
);
660 if (!info
->stabstrsect
)
662 error (_("The debugging information in `%s' is corrupted.\nThe "
663 "file has a `.stabs' section, but no `.stabstr' section."),
667 /* FIXME: dubious. Why can't we use something normal like
668 bfd_get_section_contents? */
669 bfd_seek (abfd
, abfd
->where
, 0);
671 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
673 coffstab_build_psymtabs (objfile
,
674 info
->textaddr
, info
->textsize
,
676 info
->stabstrsect
->filepos
, stabstrsize
);
678 if (dwarf2_has_info (objfile
, NULL
))
680 /* DWARF2 sections. */
681 dwarf2_build_psymtabs (objfile
);
684 dwarf2_build_frame_info (objfile
);
686 /* Try to add separate debug file if no symbols table found. */
687 if (!objfile_has_partial_symbols (objfile
))
691 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
692 make_cleanup (xfree
, debugfile
);
696 bfd
*abfd
= symfile_bfd_open (debugfile
);
698 make_cleanup_bfd_unref (abfd
);
699 symbol_file_add_separate (abfd
, symfile_flags
, objfile
);
703 do_cleanups (back_to
);
707 coff_new_init (struct objfile
*ignore
)
711 /* Perform any local cleanups required when we are done with a
712 particular objfile. I.E, we are in the process of discarding all
713 symbol information for an objfile, freeing up all memory held for
714 it, and unlinking the objfile struct from the global list of known
718 coff_symfile_finish (struct objfile
*objfile
)
720 /* Let stabs reader clean up. */
721 stabsread_clear_cache ();
723 dwarf2_free_objfile (objfile
);
727 /* Given pointers to a symbol table in coff style exec file,
728 analyze them and create struct symtab's describing the symbols.
729 NSYMS is the number of symbols in the symbol table.
730 We read them one at a time using read_one_sym (). */
733 coff_symtab_read (long symtab_offset
, unsigned int nsyms
,
734 struct objfile
*objfile
)
736 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
737 struct context_stack
*new;
738 struct coff_symbol coff_symbol
;
739 struct coff_symbol
*cs
= &coff_symbol
;
740 static struct internal_syment main_sym
;
741 static union internal_auxent main_aux
;
742 struct coff_symbol fcn_cs_saved
;
743 static struct internal_syment fcn_sym_saved
;
744 static union internal_auxent fcn_aux_saved
;
746 /* A .file is open. */
747 int in_source_file
= 0;
748 int next_file_symnum
= -1;
749 /* Name of the current file. */
750 const char *filestring
= "";
752 int fcn_first_line
= 0;
753 CORE_ADDR fcn_first_line_addr
= 0;
754 int fcn_last_line
= 0;
755 int fcn_start_addr
= 0;
756 long fcn_line_ptr
= 0;
759 struct minimal_symbol
*msym
;
761 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
762 it's hard to know I've really worked around it. The fix should
763 be harmless, anyway). The symptom of the bug is that the first
764 fread (in read_one_sym), will (in my example) actually get data
765 from file offset 268, when the fseek was to 264 (and ftell shows
766 264). This causes all hell to break loose. I was unable to
767 reproduce this on a short test program which operated on the same
768 file, performing (I think) the same sequence of operations.
770 It stopped happening when I put in this (former) rewind().
772 FIXME: Find out if this has been reported to Sun, whether it has
773 been fixed in a later release, etc. */
775 bfd_seek (objfile
->obfd
, 0, 0);
777 /* Position to read the symbol table. */
778 val
= bfd_seek (objfile
->obfd
, (long) symtab_offset
, 0);
780 perror_with_name (objfile
->name
);
782 coffread_objfile
= objfile
;
783 nlist_bfd_global
= objfile
->obfd
;
784 nlist_nsyms_global
= nsyms
;
785 set_last_source_file (NULL
);
786 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
788 if (type_vector
) /* Get rid of previous one. */
790 type_vector_length
= 160;
791 type_vector
= (struct type
**)
792 xmalloc (type_vector_length
* sizeof (struct type
*));
793 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
795 coff_start_symtab ("");
798 while (symnum
< nsyms
)
800 QUIT
; /* Make this command interruptable. */
802 read_one_sym (cs
, &main_sym
, &main_aux
);
804 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
806 if (get_last_source_file ())
807 coff_end_symtab (objfile
);
809 coff_start_symtab ("_globals_");
810 /* coff_start_symtab will set the language of this symtab to
811 language_unknown, since such a ``file name'' is not
812 recognized. Override that with the minimal language to
813 allow printing values in this symtab. */
814 current_subfile
->language
= language_minimal
;
815 complete_symtab ("_globals_", 0, 0);
816 /* Done with all files, everything from here on out is
820 /* Special case for file with type declarations only, no
822 if (!get_last_source_file () && SDB_TYPE (cs
->c_type
)
823 && cs
->c_secnum
== N_DEBUG
)
824 complete_symtab (filestring
, 0, 0);
826 /* Typedefs should not be treated as symbol definitions. */
827 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
829 /* Record all functions -- external and static -- in
831 int section
= cs_to_section (cs
, objfile
);
833 tmpaddr
= cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
834 SECT_OFF_TEXT (objfile
));
835 record_minimal_symbol (cs
, tmpaddr
, mst_text
,
838 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
839 fcn_start_addr
= tmpaddr
;
841 fcn_sym_saved
= main_sym
;
842 fcn_aux_saved
= main_aux
;
846 switch (cs
->c_sclass
)
855 complaint (&symfile_complaints
,
856 _("Bad n_sclass for symbol %s"),
861 /* c_value field contains symnum of next .file entry in
862 table or symnum of first global after last .file. */
863 next_file_symnum
= cs
->c_value
;
865 filestring
= coff_getfilename (&main_aux
);
869 /* Complete symbol table for last object file
870 containing debugging information. */
871 if (get_last_source_file ())
873 coff_end_symtab (objfile
);
874 coff_start_symtab (filestring
);
879 /* C_LABEL is used for labels and static functions.
880 Including it here allows gdb to see static functions when
881 no debug info is available. */
883 /* However, labels within a function can make weird
884 backtraces, so filter them out (from phdm@macqel.be). */
890 case C_THUMBSTATFUNC
:
891 if (cs
->c_name
[0] == '.')
893 if (strcmp (cs
->c_name
, ".text") == 0)
895 /* FIXME: don't wire in ".text" as section name or
897 /* Check for in_source_file deals with case of a
898 file with debugging symbols followed by a later
899 file with no symbols. */
901 complete_symtab (filestring
,
902 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
903 SECT_OFF_TEXT (objfile
)),
904 main_aux
.x_scn
.x_scnlen
);
907 /* Flush rest of '.' symbols. */
910 else if (!SDB_TYPE (cs
->c_type
)
911 && cs
->c_name
[0] == 'L'
912 && (strncmp (cs
->c_name
, "LI%", 3) == 0
913 || strncmp (cs
->c_name
, "LF%", 3) == 0
914 || strncmp (cs
->c_name
, "LC%", 3) == 0
915 || strncmp (cs
->c_name
, "LP%", 3) == 0
916 || strncmp (cs
->c_name
, "LPB%", 4) == 0
917 || strncmp (cs
->c_name
, "LBB%", 4) == 0
918 || strncmp (cs
->c_name
, "LBE%", 4) == 0
919 || strncmp (cs
->c_name
, "LPBX%", 5) == 0))
920 /* At least on a 3b1, gcc generates swbeg and string labels
921 that look like this. Ignore them. */
923 /* Fall in for static symbols that don't start with '.' */
928 /* Record it in the minimal symbols regardless of
929 SDB_TYPE. This parallels what we do for other debug
930 formats, and probably is needed to make
931 print_address_symbolic work right without the (now
932 gone) "set fast-symbolic-addr off" kludge. */
934 enum minimal_symbol_type ms_type
;
937 if (cs
->c_secnum
== N_UNDEF
)
939 /* This is a common symbol. We used to rely on
940 the target to tell us whether it knows where
941 the symbol has been relocated to, but none of
942 the target implementations actually provided
943 that operation. So we just ignore the symbol,
944 the same way we would do if we had a target-side
945 symbol lookup which returned no match. */
948 else if (cs
->c_secnum
== N_ABS
)
950 /* Use the correct minimal symbol type (and don't
951 relocate) for absolute values. */
953 sec
= cs_to_section (cs
, objfile
);
954 tmpaddr
= cs
->c_value
;
958 asection
*bfd_section
= cs_to_bfd_section (cs
, objfile
);
960 sec
= cs_to_section (cs
, objfile
);
961 tmpaddr
= cs
->c_value
;
962 /* Statics in a PE file also get relocated. */
963 if (cs
->c_sclass
== C_EXT
964 || cs
->c_sclass
== C_THUMBEXTFUNC
965 || cs
->c_sclass
== C_THUMBEXT
966 || (pe_file
&& (cs
->c_sclass
== C_STAT
)))
967 tmpaddr
+= ANOFFSET (objfile
->section_offsets
, sec
);
969 if (bfd_section
->flags
& SEC_CODE
)
972 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
973 || cs
->c_sclass
== C_THUMBEXT
?
974 mst_text
: mst_file_text
;
975 tmpaddr
= gdbarch_addr_bits_remove (gdbarch
, tmpaddr
);
977 else if (bfd_section
->flags
& SEC_ALLOC
978 && bfd_section
->flags
& SEC_LOAD
)
981 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
982 ? mst_data
: mst_file_data
;
984 else if (bfd_section
->flags
& SEC_ALLOC
)
987 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
988 ? mst_bss
: mst_file_bss
;
991 ms_type
= mst_unknown
;
994 msym
= record_minimal_symbol (cs
, tmpaddr
, ms_type
,
997 gdbarch_coff_make_msymbol_special (gdbarch
,
1000 if (SDB_TYPE (cs
->c_type
))
1004 sym
= process_coff_symbol
1005 (cs
, &main_aux
, objfile
);
1006 SYMBOL_VALUE (sym
) = tmpaddr
;
1007 SYMBOL_SECTION (sym
) = sec
;
1013 if (strcmp (cs
->c_name
, ".bf") == 0)
1015 within_function
= 1;
1017 /* Value contains address of first non-init type
1019 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1020 contains line number of '{' }. */
1021 if (cs
->c_naux
!= 1)
1022 complaint (&symfile_complaints
,
1023 _("`.bf' symbol %d has no aux entry"),
1025 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1026 fcn_first_line_addr
= cs
->c_value
;
1028 /* Might want to check that locals are 0 and
1029 context_stack_depth is zero, and complain if not. */
1032 new = push_context (depth
, fcn_start_addr
);
1033 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1035 process_coff_symbol (&fcn_cs_saved
,
1036 &fcn_aux_saved
, objfile
);
1038 else if (strcmp (cs
->c_name
, ".ef") == 0)
1040 if (!within_function
)
1041 error (_("Bad coff function information."));
1042 /* The value of .ef is the address of epilogue code;
1043 not useful for gdb. */
1044 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1045 contains number of lines to '}' */
1047 if (context_stack_depth
<= 0)
1048 { /* We attempted to pop an empty context stack. */
1049 complaint (&symfile_complaints
,
1050 _("`.ef' symbol without matching `.bf' "
1051 "symbol ignored starting at symnum %d"),
1053 within_function
= 0;
1057 new = pop_context ();
1058 /* Stack must be empty now. */
1059 if (context_stack_depth
> 0 || new == NULL
)
1061 complaint (&symfile_complaints
,
1062 _("Unmatched .ef symbol(s) ignored "
1063 "starting at symnum %d"),
1065 within_function
= 0;
1068 if (cs
->c_naux
!= 1)
1070 complaint (&symfile_complaints
,
1071 _("`.ef' symbol %d has no aux entry"),
1073 fcn_last_line
= 0x7FFFFFFF;
1077 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1079 /* fcn_first_line is the line number of the opening '{'.
1080 Do not record it - because it would affect gdb's idea
1081 of the line number of the first statement of the
1082 function - except for one-line functions, for which
1083 it is also the line number of all the statements and
1084 of the closing '}', and for which we do not have any
1085 other statement-line-number. */
1086 if (fcn_last_line
== 1)
1087 record_line (current_subfile
, fcn_first_line
,
1088 gdbarch_addr_bits_remove (gdbarch
,
1089 fcn_first_line_addr
));
1091 enter_linenos (fcn_line_ptr
, fcn_first_line
,
1092 fcn_last_line
, objfile
);
1094 finish_block (new->name
, &local_symbols
,
1095 new->old_blocks
, new->start_addr
,
1096 fcn_cs_saved
.c_value
1097 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1098 + ANOFFSET (objfile
->section_offsets
,
1099 SECT_OFF_TEXT (objfile
)),
1102 within_function
= 0;
1107 if (strcmp (cs
->c_name
, ".bb") == 0)
1109 tmpaddr
= cs
->c_value
;
1110 tmpaddr
+= ANOFFSET (objfile
->section_offsets
,
1111 SECT_OFF_TEXT (objfile
));
1112 push_context (++depth
, tmpaddr
);
1114 else if (strcmp (cs
->c_name
, ".eb") == 0)
1116 if (context_stack_depth
<= 0)
1117 { /* We attempted to pop an empty context stack. */
1118 complaint (&symfile_complaints
,
1119 _("`.eb' symbol without matching `.bb' "
1120 "symbol ignored starting at symnum %d"),
1125 new = pop_context ();
1126 if (depth
-- != new->depth
)
1128 complaint (&symfile_complaints
,
1129 _("Mismatched .eb symbol ignored "
1130 "starting at symnum %d"),
1134 if (local_symbols
&& context_stack_depth
> 0)
1137 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
1138 SECT_OFF_TEXT (objfile
));
1139 /* Make a block for the local symbols within. */
1140 finish_block (0, &local_symbols
, new->old_blocks
,
1141 new->start_addr
, tmpaddr
, objfile
);
1143 /* Now pop locals of block just finished. */
1144 local_symbols
= new->locals
;
1149 process_coff_symbol (cs
, &main_aux
, objfile
);
1154 if ((nsyms
== 0) && (pe_file
))
1156 /* We've got no debugging symbols, but it's a portable
1157 executable, so try to read the export table. */
1158 read_pe_exported_syms (objfile
);
1161 if (get_last_source_file ())
1162 coff_end_symtab (objfile
);
1164 /* Patch up any opaque types (references to types that are not defined
1165 in the file where they are referenced, e.g. "struct foo *bar"). */
1166 ALL_OBJFILE_SYMTABS (objfile
, s
)
1167 patch_opaque_types (s
);
1169 coffread_objfile
= NULL
;
1172 /* Routines for reading headers and symbols from executable. */
1174 /* Read the next symbol, swap it, and return it in both
1175 internal_syment form, and coff_symbol form. Also return its first
1176 auxent, if any, in internal_auxent form, and skip any other
1180 read_one_sym (struct coff_symbol
*cs
,
1181 struct internal_syment
*sym
,
1182 union internal_auxent
*aux
)
1185 bfd_size_type bytes
;
1187 cs
->c_symnum
= symnum
;
1188 bytes
= bfd_bread (temp_sym
, local_symesz
, nlist_bfd_global
);
1189 if (bytes
!= local_symesz
)
1190 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1191 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1192 cs
->c_naux
= sym
->n_numaux
& 0xff;
1193 if (cs
->c_naux
>= 1)
1195 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1196 if (bytes
!= local_auxesz
)
1197 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1198 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
,
1199 sym
->n_type
, sym
->n_sclass
,
1200 0, cs
->c_naux
, (char *) aux
);
1201 /* If more than one aux entry, read past it (only the first aux
1203 for (i
= 1; i
< cs
->c_naux
; i
++)
1205 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1206 if (bytes
!= local_auxesz
)
1207 error (_("%s: error reading symbols"), coffread_objfile
->name
);
1210 cs
->c_name
= getsymname (sym
);
1211 cs
->c_value
= sym
->n_value
;
1212 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1213 cs
->c_secnum
= sym
->n_scnum
;
1214 cs
->c_type
= (unsigned) sym
->n_type
;
1215 if (!SDB_TYPE (cs
->c_type
))
1219 if (cs
->c_sclass
& 128)
1220 printf (_("thumb symbol %s, class 0x%x\n"), cs
->c_name
, cs
->c_sclass
);
1223 symnum
+= 1 + cs
->c_naux
;
1225 /* The PE file format stores symbol values as offsets within the
1226 section, rather than as absolute addresses. We correct that
1227 here, if the symbol has an appropriate storage class. FIXME: We
1228 should use BFD to read the symbols, rather than duplicating the
1232 switch (cs
->c_sclass
)
1236 case C_THUMBEXTFUNC
:
1241 case C_THUMBSTATFUNC
:
1247 if (cs
->c_secnum
!= 0)
1248 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1254 /* Support for string table handling. */
1256 static char *stringtab
= NULL
;
1259 init_stringtab (bfd
*abfd
, long offset
)
1263 unsigned char lengthbuf
[4];
1267 /* If the file is stripped, the offset might be zero, indicating no
1268 string table. Just return with `stringtab' set to null. */
1272 if (bfd_seek (abfd
, offset
, 0) < 0)
1275 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1276 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1278 /* If no string table is needed, then the file may end immediately
1279 after the symbols. Just return with `stringtab' set to null. */
1280 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1283 stringtab
= (char *) xmalloc (length
);
1284 /* This is in target format (probably not very useful, and not
1285 currently used), not host format. */
1286 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1287 if (length
== sizeof length
) /* Empty table -- just the count. */
1290 val
= bfd_bread (stringtab
+ sizeof lengthbuf
,
1291 length
- sizeof lengthbuf
, abfd
);
1292 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1299 free_stringtab (void)
1307 free_stringtab_cleanup (void *ignore
)
1313 getsymname (struct internal_syment
*symbol_entry
)
1315 static char buffer
[SYMNMLEN
+ 1];
1318 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1320 /* FIXME: Probably should be detecting corrupt symbol files by
1321 seeing whether offset points to within the stringtab. */
1322 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1326 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1327 buffer
[SYMNMLEN
] = '\0';
1333 /* Extract the file name from the aux entry of a C_FILE symbol.
1334 Return only the last component of the name. Result is in static
1335 storage and is only good for temporary use. */
1338 coff_getfilename (union internal_auxent
*aux_entry
)
1340 static char buffer
[BUFSIZ
];
1343 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1345 if (strlen (stringtab
+ aux_entry
->x_file
.x_n
.x_offset
) >= BUFSIZ
)
1346 internal_error (__FILE__
, __LINE__
, _("coff file name too long"));
1347 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1351 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1352 buffer
[FILNMLEN
] = '\0';
1356 /* FIXME: We should not be throwing away the information about what
1357 directory. It should go into dirname of the symtab, or some such
1359 result
= lbasename (result
);
1363 /* Support for line number handling. */
1365 static char *linetab
= NULL
;
1366 static long linetab_offset
;
1367 static unsigned long linetab_size
;
1369 /* Read in all the line numbers for fast lookups later. Leave them in
1370 external (unswapped) format in memory; we'll swap them as we enter
1371 them into GDB's data structures. */
1374 init_lineno (bfd
*abfd
, long offset
, int size
)
1378 linetab_offset
= offset
;
1379 linetab_size
= size
;
1386 if (bfd_seek (abfd
, offset
, 0) < 0)
1389 /* Allocate the desired table, plus a sentinel. */
1390 linetab
= (char *) xmalloc (size
+ local_linesz
);
1392 val
= bfd_bread (linetab
, size
, abfd
);
1396 /* Terminate it with an all-zero sentinel record. */
1397 memset (linetab
+ size
, 0, local_linesz
);
1411 free_linetab_cleanup (void *ignore
)
1416 #if !defined (L_LNNO32)
1417 #define L_LNNO32(lp) ((lp)->l_lnno)
1421 enter_linenos (long file_offset
, int first_line
,
1422 int last_line
, struct objfile
*objfile
)
1424 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1426 struct internal_lineno lptr
;
1430 if (file_offset
< linetab_offset
)
1432 complaint (&symfile_complaints
,
1433 _("Line number pointer %ld lower than start of line numbers"),
1435 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1437 file_offset
+= linetab_offset
; /* Try reading at that linetab
1441 rawptr
= &linetab
[file_offset
- linetab_offset
];
1443 /* Skip first line entry for each function. */
1444 rawptr
+= local_linesz
;
1445 /* Line numbers start at one for the first line of the function. */
1448 /* If the line number table is full (e.g. 64K lines in COFF debug
1449 info), the next function's L_LNNO32 might not be zero, so don't
1450 overstep the table's end in any case. */
1451 while (rawptr
<= &linetab
[0] + linetab_size
)
1453 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1454 rawptr
+= local_linesz
;
1455 /* The next function, or the sentinel, will have L_LNNO32 zero;
1457 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1459 CORE_ADDR addr
= lptr
.l_addr
.l_paddr
;
1460 addr
+= ANOFFSET (objfile
->section_offsets
,
1461 SECT_OFF_TEXT (objfile
));
1462 record_line (current_subfile
,
1463 first_line
+ L_LNNO32 (&lptr
),
1464 gdbarch_addr_bits_remove (gdbarch
, addr
));
1472 patch_type (struct type
*type
, struct type
*real_type
)
1474 struct type
*target
= TYPE_TARGET_TYPE (type
);
1475 struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1476 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1478 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1479 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1480 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
,
1483 memcpy (TYPE_FIELDS (target
),
1484 TYPE_FIELDS (real_target
),
1487 if (TYPE_NAME (real_target
))
1489 /* The previous copy of TYPE_NAME is allocated by
1490 process_coff_symbol. */
1491 if (TYPE_NAME (target
))
1492 xfree ((char*) TYPE_NAME (target
));
1493 TYPE_NAME (target
) = xstrdup (TYPE_NAME (real_target
));
1497 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1498 so that they can be used to print out opaque data structures
1502 patch_opaque_types (struct symtab
*s
)
1505 struct block_iterator iter
;
1506 struct symbol
*real_sym
;
1508 /* Go through the per-file symbols only. */
1509 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1510 ALL_BLOCK_SYMBOLS (b
, iter
, real_sym
)
1512 /* Find completed typedefs to use to fix opaque ones.
1513 Remove syms from the chain when their types are stored,
1514 but search the whole chain, as there may be several syms
1515 from different files with the same name. */
1516 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
1517 && SYMBOL_DOMAIN (real_sym
) == VAR_DOMAIN
1518 && TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
1519 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1521 const char *name
= SYMBOL_LINKAGE_NAME (real_sym
);
1522 int hash
= hashname (name
);
1523 struct symbol
*sym
, *prev
;
1526 for (sym
= opaque_type_chain
[hash
]; sym
;)
1528 if (name
[0] == SYMBOL_LINKAGE_NAME (sym
)[0]
1529 && strcmp (name
+ 1, SYMBOL_LINKAGE_NAME (sym
) + 1) == 0)
1533 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1537 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1540 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1544 sym
= SYMBOL_VALUE_CHAIN (prev
);
1548 sym
= opaque_type_chain
[hash
];
1554 sym
= SYMBOL_VALUE_CHAIN (sym
);
1562 coff_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
1564 return gdbarch_sdb_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
1567 static const struct symbol_register_ops coff_register_funcs
= {
1571 /* The "aclass" index for computed COFF symbols. */
1573 static int coff_register_index
;
1575 static struct symbol
*
1576 process_coff_symbol (struct coff_symbol
*cs
,
1577 union internal_auxent
*aux
,
1578 struct objfile
*objfile
)
1580 struct symbol
*sym
= allocate_symbol (objfile
);
1584 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1585 SYMBOL_SET_LANGUAGE (sym
, current_subfile
->language
,
1586 &objfile
->objfile_obstack
);
1587 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), 1, objfile
);
1589 /* default assumptions */
1590 SYMBOL_VALUE (sym
) = cs
->c_value
;
1591 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1592 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1594 if (ISFCN (cs
->c_type
))
1596 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
,
1597 SECT_OFF_TEXT (objfile
));
1599 lookup_function_type (decode_function_type (cs
, cs
->c_type
,
1602 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
1603 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1604 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1605 add_symbol_to_list (sym
, &file_symbols
);
1606 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1607 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1608 add_symbol_to_list (sym
, &global_symbols
);
1612 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
, objfile
);
1613 switch (cs
->c_sclass
)
1619 SYMBOL_ACLASS_INDEX (sym
) = LOC_LOCAL
;
1620 add_symbol_to_list (sym
, &local_symbols
);
1624 case C_THUMBEXTFUNC
:
1626 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1627 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1628 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1629 SECT_OFF_TEXT (objfile
));
1630 add_symbol_to_list (sym
, &global_symbols
);
1634 case C_THUMBSTATFUNC
:
1636 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1637 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1638 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1639 SECT_OFF_TEXT (objfile
));
1640 if (within_function
)
1642 /* Static symbol of local scope. */
1643 add_symbol_to_list (sym
, &local_symbols
);
1647 /* Static symbol at top level of file. */
1648 add_symbol_to_list (sym
, &file_symbols
);
1652 #ifdef C_GLBLREG /* AMD coff */
1656 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1657 SYMBOL_VALUE (sym
) = cs
->c_value
;
1658 add_symbol_to_list (sym
, &local_symbols
);
1666 SYMBOL_ACLASS_INDEX (sym
) = LOC_ARG
;
1667 SYMBOL_IS_ARGUMENT (sym
) = 1;
1668 add_symbol_to_list (sym
, &local_symbols
);
1672 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1673 SYMBOL_IS_ARGUMENT (sym
) = 1;
1674 SYMBOL_VALUE (sym
) = cs
->c_value
;
1675 add_symbol_to_list (sym
, &local_symbols
);
1679 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1680 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1682 /* If type has no name, give it one. */
1683 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1685 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1686 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1688 /* If we are giving a name to a type such as
1689 "pointer to foo" or "function returning foo", we
1690 better not set the TYPE_NAME. If the program
1691 contains "typedef char *caddr_t;", we don't want
1692 all variables of type char * to print as caddr_t.
1693 This is not just a consequence of GDB's type
1694 management; CC and GCC (at least through version
1695 2.4) both output variables of either type char *
1696 or caddr_t with the type refering to the C_TPDEF
1697 symbol for caddr_t. If a future compiler cleans
1698 this up it GDB is not ready for it yet, but if it
1699 becomes ready we somehow need to disable this
1700 check (without breaking the PCC/GCC2.4 case).
1704 Fortunately, this check seems not to be necessary
1705 for anything except pointers or functions. */
1709 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1710 xstrdup (SYMBOL_LINKAGE_NAME (sym
));
1713 /* Keep track of any type which points to empty structured
1714 type, so it can be filled from a definition from another
1715 file. A simple forward reference (TYPE_CODE_UNDEF) is
1716 not an empty structured type, though; the forward
1717 references work themselves out via the magic of
1718 coff_lookup_type. */
1719 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1720 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0
1721 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
)))
1724 int i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
1726 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1727 opaque_type_chain
[i
] = sym
;
1729 add_symbol_to_list (sym
, &file_symbols
);
1735 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1736 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
1738 /* Some compilers try to be helpful by inventing "fake"
1739 names for anonymous enums, structures, and unions, like
1740 "~0fake" or ".0fake". Thanks, but no thanks... */
1741 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1742 if (SYMBOL_LINKAGE_NAME (sym
) != NULL
1743 && *SYMBOL_LINKAGE_NAME (sym
) != '~'
1744 && *SYMBOL_LINKAGE_NAME (sym
) != '.')
1745 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1746 concat (SYMBOL_LINKAGE_NAME (sym
), (char *)NULL
);
1748 add_symbol_to_list (sym
, &file_symbols
);
1758 /* Decode a coff type specifier; return the type that is meant. */
1760 static struct type
*
1761 decode_type (struct coff_symbol
*cs
, unsigned int c_type
,
1762 union internal_auxent
*aux
, struct objfile
*objfile
)
1764 struct type
*type
= 0;
1765 unsigned int new_c_type
;
1767 if (c_type
& ~N_BTMASK
)
1769 new_c_type
= DECREF (c_type
);
1772 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1773 type
= lookup_pointer_type (type
);
1775 else if (ISFCN (c_type
))
1777 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1778 type
= lookup_function_type (type
);
1780 else if (ISARY (c_type
))
1783 unsigned short *dim
;
1784 struct type
*base_type
, *index_type
, *range_type
;
1786 /* Define an array type. */
1787 /* auxent refers to array, not base type. */
1788 if (aux
->x_sym
.x_tagndx
.l
== 0)
1791 /* Shift the indices down. */
1792 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1795 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1799 base_type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1800 index_type
= objfile_type (objfile
)->builtin_int
;
1802 create_range_type ((struct type
*) NULL
,
1803 index_type
, 0, n
- 1);
1805 create_array_type ((struct type
*) NULL
,
1806 base_type
, range_type
);
1811 /* Reference to existing type. This only occurs with the struct,
1812 union, and enum types. EPI a29k coff fakes us out by producing
1813 aux entries with a nonzero x_tagndx for definitions of structs,
1814 unions, and enums, so we have to check the c_sclass field. SCO
1815 3.2v4 cc gets confused with pointers to pointers to defined
1816 structs, and generates negative x_tagndx fields. */
1817 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1819 if (cs
->c_sclass
!= C_STRTAG
1820 && cs
->c_sclass
!= C_UNTAG
1821 && cs
->c_sclass
!= C_ENTAG
1822 && aux
->x_sym
.x_tagndx
.l
>= 0)
1824 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1829 complaint (&symfile_complaints
,
1830 _("Symbol table entry for %s has bad tagndx value"),
1832 /* And fall through to decode_base_type... */
1836 return decode_base_type (cs
, BTYPE (c_type
), aux
, objfile
);
1839 /* Decode a coff type specifier for function definition;
1840 return the type that the function returns. */
1842 static struct type
*
1843 decode_function_type (struct coff_symbol
*cs
,
1844 unsigned int c_type
,
1845 union internal_auxent
*aux
,
1846 struct objfile
*objfile
)
1848 if (aux
->x_sym
.x_tagndx
.l
== 0)
1849 cs
->c_naux
= 0; /* auxent refers to function, not base
1852 return decode_type (cs
, DECREF (c_type
), aux
, objfile
);
1855 /* Basic C types. */
1857 static struct type
*
1858 decode_base_type (struct coff_symbol
*cs
,
1859 unsigned int c_type
,
1860 union internal_auxent
*aux
,
1861 struct objfile
*objfile
)
1863 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1869 /* Shows up with "void (*foo)();" structure members. */
1870 return objfile_type (objfile
)->builtin_void
;
1874 /* Intel 960 COFF has this symbol and meaning. */
1875 return objfile_type (objfile
)->builtin_void
;
1879 return objfile_type (objfile
)->builtin_char
;
1882 return objfile_type (objfile
)->builtin_short
;
1885 return objfile_type (objfile
)->builtin_int
;
1888 if (cs
->c_sclass
== C_FIELD
1889 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1890 > gdbarch_long_bit (gdbarch
))
1891 return objfile_type (objfile
)->builtin_long_long
;
1893 return objfile_type (objfile
)->builtin_long
;
1896 return objfile_type (objfile
)->builtin_float
;
1899 return objfile_type (objfile
)->builtin_double
;
1902 return objfile_type (objfile
)->builtin_long_double
;
1905 if (cs
->c_naux
!= 1)
1907 /* Anonymous structure type. */
1908 type
= coff_alloc_type (cs
->c_symnum
);
1909 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1910 TYPE_NAME (type
) = NULL
;
1911 /* This used to set the tag to "<opaque>". But I think
1912 setting it to NULL is right, and the printing code can
1913 print it as "struct {...}". */
1914 TYPE_TAG_NAME (type
) = NULL
;
1915 INIT_CPLUS_SPECIFIC (type
);
1916 TYPE_LENGTH (type
) = 0;
1917 TYPE_FIELDS (type
) = 0;
1918 TYPE_NFIELDS (type
) = 0;
1922 type
= coff_read_struct_type (cs
->c_symnum
,
1923 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1924 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1930 if (cs
->c_naux
!= 1)
1932 /* Anonymous union type. */
1933 type
= coff_alloc_type (cs
->c_symnum
);
1934 TYPE_NAME (type
) = NULL
;
1935 /* This used to set the tag to "<opaque>". But I think
1936 setting it to NULL is right, and the printing code can
1937 print it as "union {...}". */
1938 TYPE_TAG_NAME (type
) = NULL
;
1939 INIT_CPLUS_SPECIFIC (type
);
1940 TYPE_LENGTH (type
) = 0;
1941 TYPE_FIELDS (type
) = 0;
1942 TYPE_NFIELDS (type
) = 0;
1946 type
= coff_read_struct_type (cs
->c_symnum
,
1947 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1948 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1951 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1955 if (cs
->c_naux
!= 1)
1957 /* Anonymous enum type. */
1958 type
= coff_alloc_type (cs
->c_symnum
);
1959 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1960 TYPE_NAME (type
) = NULL
;
1961 /* This used to set the tag to "<opaque>". But I think
1962 setting it to NULL is right, and the printing code can
1963 print it as "enum {...}". */
1964 TYPE_TAG_NAME (type
) = NULL
;
1965 TYPE_LENGTH (type
) = 0;
1966 TYPE_FIELDS (type
) = 0;
1967 TYPE_NFIELDS (type
) = 0;
1971 type
= coff_read_enum_type (cs
->c_symnum
,
1972 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1973 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1979 /* Shouldn't show up here. */
1983 return objfile_type (objfile
)->builtin_unsigned_char
;
1986 return objfile_type (objfile
)->builtin_unsigned_short
;
1989 return objfile_type (objfile
)->builtin_unsigned_int
;
1992 if (cs
->c_sclass
== C_FIELD
1993 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1994 > gdbarch_long_bit (gdbarch
))
1995 return objfile_type (objfile
)->builtin_unsigned_long_long
;
1997 return objfile_type (objfile
)->builtin_unsigned_long
;
1999 complaint (&symfile_complaints
,
2000 _("Unexpected type for symbol %s"), cs
->c_name
);
2001 return objfile_type (objfile
)->builtin_void
;
2004 /* This page contains subroutines of read_type. */
2006 /* Read the description of a structure (or union type) and return an
2007 object describing the type. */
2009 static struct type
*
2010 coff_read_struct_type (int index
, int length
, int lastsym
,
2011 struct objfile
*objfile
)
2015 struct nextfield
*next
;
2020 struct nextfield
*list
= 0;
2021 struct nextfield
*new;
2025 struct coff_symbol member_sym
;
2026 struct coff_symbol
*ms
= &member_sym
;
2027 struct internal_syment sub_sym
;
2028 union internal_auxent sub_aux
;
2031 type
= coff_alloc_type (index
);
2032 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2033 INIT_CPLUS_SPECIFIC (type
);
2034 TYPE_LENGTH (type
) = length
;
2036 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2038 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2040 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2042 switch (ms
->c_sclass
)
2047 /* Get space to record the next field's data. */
2048 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2052 /* Save the data. */
2053 list
->field
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
2054 name
, strlen (name
));
2055 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2057 SET_FIELD_BITPOS (list
->field
, 8 * ms
->c_value
);
2058 FIELD_BITSIZE (list
->field
) = 0;
2064 /* Get space to record the next field's data. */
2065 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2069 /* Save the data. */
2070 list
->field
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
2071 name
, strlen (name
));
2072 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2074 SET_FIELD_BITPOS (list
->field
, ms
->c_value
);
2075 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2084 /* Now create the vector of fields, and record how big it is. */
2086 TYPE_NFIELDS (type
) = nfields
;
2087 TYPE_FIELDS (type
) = (struct field
*)
2088 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2090 /* Copy the saved-up fields into the field vector. */
2092 for (n
= nfields
; list
; list
= list
->next
)
2093 TYPE_FIELD (type
, --n
) = list
->field
;
2098 /* Read a definition of an enumeration type,
2099 and create and return a suitable type object.
2100 Also defines the symbols that represent the values of the type. */
2102 static struct type
*
2103 coff_read_enum_type (int index
, int length
, int lastsym
,
2104 struct objfile
*objfile
)
2106 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2111 struct pending
**symlist
;
2112 struct coff_symbol member_sym
;
2113 struct coff_symbol
*ms
= &member_sym
;
2114 struct internal_syment sub_sym
;
2115 union internal_auxent sub_aux
;
2116 struct pending
*osyms
, *syms
;
2120 int unsigned_enum
= 1;
2122 type
= coff_alloc_type (index
);
2123 if (within_function
)
2124 symlist
= &local_symbols
;
2126 symlist
= &file_symbols
;
2128 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2130 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2132 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2134 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2136 switch (ms
->c_sclass
)
2139 sym
= allocate_symbol (objfile
);
2141 SYMBOL_SET_LINKAGE_NAME (sym
,
2142 obstack_copy0 (&objfile
->objfile_obstack
,
2143 name
, strlen (name
)));
2144 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
2145 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2146 SYMBOL_VALUE (sym
) = ms
->c_value
;
2147 add_symbol_to_list (sym
, symlist
);
2152 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2153 up the count of how many symbols to read. So stop
2160 /* Now fill in the fields of the type-structure. */
2163 TYPE_LENGTH (type
) = length
;
2164 else /* Assume ints. */
2165 TYPE_LENGTH (type
) = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
2166 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2167 TYPE_NFIELDS (type
) = nsyms
;
2168 TYPE_FIELDS (type
) = (struct field
*)
2169 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2171 /* Find the symbols for the values and put them into the type.
2172 The symbols can be found in the symlist that we put them on
2173 to cause them to be defined. osyms contains the old value
2174 of that symlist; everything up to there was defined by us. */
2175 /* Note that we preserve the order of the enum constants, so
2176 that in something like "enum {FOO, LAST_THING=FOO}" we print
2177 FOO, not LAST_THING. */
2179 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2185 for (; j
< syms
->nsyms
; j
++, n
++)
2187 struct symbol
*xsym
= syms
->symbol
[j
];
2189 SYMBOL_TYPE (xsym
) = type
;
2190 TYPE_FIELD_NAME (type
, n
) = SYMBOL_LINKAGE_NAME (xsym
);
2191 SET_FIELD_ENUMVAL (TYPE_FIELD (type
, n
), SYMBOL_VALUE (xsym
));
2192 if (SYMBOL_VALUE (xsym
) < 0)
2194 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2201 TYPE_UNSIGNED (type
) = 1;
2206 /* Register our ability to parse symbols for coff BFD files. */
2208 static const struct sym_fns coff_sym_fns
=
2210 bfd_target_coff_flavour
,
2211 coff_new_init
, /* sym_new_init: init anything gbl to
2213 coff_symfile_init
, /* sym_init: read initial info, setup
2215 coff_symfile_read
, /* sym_read: read a symbol file into
2217 NULL
, /* sym_read_psymbols */
2218 coff_symfile_finish
, /* sym_finish: finished with file,
2220 default_symfile_offsets
, /* sym_offsets: xlate external to
2222 default_symfile_segments
, /* sym_segments: Get segment
2223 information from a file */
2224 NULL
, /* sym_read_linetable */
2226 default_symfile_relocate
, /* sym_relocate: Relocate a debug
2228 NULL
, /* sym_probe_fns */
2232 /* Free the per-objfile COFF data. */
2235 coff_free_info (struct objfile
*objfile
, void *arg
)
2241 _initialize_coffread (void)
2243 add_symtab_fns (&coff_sym_fns
);
2245 coff_objfile_data_key
= register_objfile_data_with_cleanup (NULL
,
2249 = register_symbol_register_impl (LOC_REGISTER
, &coff_register_funcs
);