1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
3 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "breakpoint.h"
27 #include "gdb_obstack.h"
30 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
31 #include "libcoff.h" /* FIXME secret internal data from BFD */
34 #include "gdb-stabs.h"
35 #include "stabsread.h"
36 #include "complaints.h"
39 #include "dictionary.h"
41 #include "coff-pe-read.h"
45 extern void _initialize_coffread (void);
47 /* Key for COFF-associated data. */
49 static const struct objfile_data
*coff_objfile_data_key
;
51 /* The objfile we are currently reading. */
53 static struct objfile
*coffread_objfile
;
55 struct coff_symfile_info
57 file_ptr min_lineno_offset
; /* Where in file lowest line#s are. */
58 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file. */
60 CORE_ADDR textaddr
; /* Addr of .text section. */
61 unsigned int textsize
; /* Size of .text section. */
62 struct stab_section_list
*stabsects
; /* .stab sections. */
63 asection
*stabstrsect
; /* Section pointer for .stab section. */
67 /* Translate an external name string into a user-visible name. */
68 #define EXTERNAL_NAME(string, abfd) \
69 (string[0] == bfd_get_symbol_leading_char (abfd) \
70 ? string + 1 : string)
72 /* To be an sdb debug type, type must have at least a basic or primary
73 derived type. Using this rather than checking against T_NULL is
74 said to prevent core dumps if we try to operate on Michael Bloom
77 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
79 /* Core address of start and end of text of current source file.
80 This comes from a ".text" symbol where x_nlinno > 0. */
82 static CORE_ADDR current_source_start_addr
;
83 static CORE_ADDR current_source_end_addr
;
85 /* The addresses of the symbol table stream and number of symbols
86 of the object file we are reading (as copied into core). */
88 static bfd
*nlist_bfd_global
;
89 static int nlist_nsyms_global
;
92 /* Pointers to scratch storage, used for reading raw symbols and
95 static char *temp_sym
;
96 static char *temp_aux
;
98 /* Local variables that hold the shift and mask values for the
99 COFF file that we are currently reading. These come back to us
100 from BFD, and are referenced by their macro names, as well as
101 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
102 macros from include/coff/internal.h . */
104 static unsigned local_n_btmask
;
105 static unsigned local_n_btshft
;
106 static unsigned local_n_tmask
;
107 static unsigned local_n_tshift
;
109 #define N_BTMASK local_n_btmask
110 #define N_BTSHFT local_n_btshft
111 #define N_TMASK local_n_tmask
112 #define N_TSHIFT local_n_tshift
114 /* Local variables that hold the sizes in the file of various COFF
115 structures. (We only need to know this to read them from the file
116 -- BFD will then translate the data in them, into `internal_xxx'
117 structs in the right byte order, alignment, etc.) */
119 static unsigned local_linesz
;
120 static unsigned local_symesz
;
121 static unsigned local_auxesz
;
123 /* This is set if this is a PE format file. */
127 /* Chain of typedefs of pointers to empty struct/union types.
128 They are chained thru the SYMBOL_VALUE_CHAIN. */
130 static struct symbol
*opaque_type_chain
[HASHSIZE
];
132 /* Simplified internal version of coff symbol table information. */
137 int c_symnum
; /* Symbol number of this entry. */
138 int c_naux
; /* 0 if syment only, 1 if syment +
146 /* Vector of types defined so far, indexed by their type numbers. */
148 static struct type
**type_vector
;
150 /* Number of elements allocated for type_vector currently. */
152 static int type_vector_length
;
154 /* Initial size of type vector. Is realloc'd larger if needed, and
155 realloc'd down to the size actually used, when completed. */
157 #define INITIAL_TYPE_VECTOR_LENGTH 160
159 extern void stabsread_clear_cache (void);
161 static struct type
*coff_read_struct_type (int, int, int,
164 static struct type
*decode_base_type (struct coff_symbol
*,
166 union internal_auxent
*,
169 static struct type
*decode_type (struct coff_symbol
*, unsigned int,
170 union internal_auxent
*,
173 static struct type
*decode_function_type (struct coff_symbol
*,
175 union internal_auxent
*,
178 static struct type
*coff_read_enum_type (int, int, int,
181 static struct symbol
*process_coff_symbol (struct coff_symbol
*,
182 union internal_auxent
*,
185 static void patch_opaque_types (struct symtab
*);
187 static void enter_linenos (long, int, int, struct objfile
*);
189 static void free_linetab (void);
191 static void free_linetab_cleanup (void *ignore
);
193 static int init_lineno (bfd
*, long, int);
195 static char *getsymname (struct internal_syment
*);
197 static const char *coff_getfilename (union internal_auxent
*);
199 static void free_stringtab (void);
201 static void free_stringtab_cleanup (void *ignore
);
203 static int init_stringtab (bfd
*, long);
205 static void read_one_sym (struct coff_symbol
*,
206 struct internal_syment
*,
207 union internal_auxent
*);
209 static void coff_symtab_read (long, unsigned int, struct objfile
*);
211 /* We are called once per section from coff_symfile_read. We
212 need to examine each section we are passed, check to see
213 if it is something we are interested in processing, and
214 if so, stash away some access information for the section.
216 FIXME: The section names should not be hardwired strings (what
217 should they be? I don't think most object file formats have enough
218 section flags to specify what kind of debug section it is
222 coff_locate_sections (bfd
*abfd
, asection
*sectp
, void *csip
)
224 struct coff_symfile_info
*csi
;
227 csi
= (struct coff_symfile_info
*) csip
;
228 name
= bfd_get_section_name (abfd
, sectp
);
229 if (strcmp (name
, ".text") == 0)
231 csi
->textaddr
= bfd_section_vma (abfd
, sectp
);
232 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
234 else if (strncmp (name
, ".text", sizeof ".text" - 1) == 0)
236 csi
->textsize
+= bfd_section_size (abfd
, sectp
);
238 else if (strcmp (name
, ".stabstr") == 0)
240 csi
->stabstrsect
= sectp
;
242 else if (strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
246 /* We can have multiple .stab sections if linked with
248 for (s
= name
+ sizeof ".stab" - 1; *s
!= '\0'; s
++)
253 struct stab_section_list
*n
, **pn
;
255 n
= ((struct stab_section_list
*)
256 xmalloc (sizeof (struct stab_section_list
)));
259 for (pn
= &csi
->stabsects
; *pn
!= NULL
; pn
= &(*pn
)->next
)
263 /* This will be run after coffstab_build_psymtabs is called
264 in coff_symfile_read, at which point we no longer need
266 make_cleanup (xfree
, n
);
271 /* Return the section_offsets* that CS points to. */
272 static int cs_to_section (struct coff_symbol
*, struct objfile
*);
274 struct find_targ_sec_arg
281 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
283 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
285 if (sect
->target_index
== args
->targ_index
)
286 *args
->resultp
= sect
;
289 /* Return the bfd_section that CS points to. */
290 static struct bfd_section
*
291 cs_to_bfd_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
293 asection
*sect
= NULL
;
294 struct find_targ_sec_arg args
;
296 args
.targ_index
= cs
->c_secnum
;
297 args
.resultp
= §
;
298 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
302 /* Return the section number (SECT_OFF_*) that CS points to. */
304 cs_to_section (struct coff_symbol
*cs
, struct objfile
*objfile
)
306 asection
*sect
= cs_to_bfd_section (cs
, objfile
);
309 return SECT_OFF_TEXT (objfile
);
310 return gdb_bfd_section_index (objfile
->obfd
, sect
);
313 /* Return the address of the section of a COFF symbol. */
315 static CORE_ADDR
cs_section_address (struct coff_symbol
*, bfd
*);
318 cs_section_address (struct coff_symbol
*cs
, bfd
*abfd
)
320 asection
*sect
= NULL
;
321 struct find_targ_sec_arg args
;
324 args
.targ_index
= cs
->c_secnum
;
325 args
.resultp
= §
;
326 bfd_map_over_sections (abfd
, find_targ_sec
, &args
);
328 addr
= bfd_get_section_vma (abfd
, sect
);
332 /* Look up a coff type-number index. Return the address of the slot
333 where the type for that index is stored.
334 The type-number is in INDEX.
336 This can be used for finding the type associated with that index
337 or for associating a new type with the index. */
339 static struct type
**
340 coff_lookup_type (int index
)
342 if (index
>= type_vector_length
)
344 int old_vector_length
= type_vector_length
;
346 type_vector_length
*= 2;
347 if (index
/* is still */ >= type_vector_length
)
348 type_vector_length
= index
* 2;
350 type_vector
= (struct type
**)
351 xrealloc ((char *) type_vector
,
352 type_vector_length
* sizeof (struct type
*));
353 memset (&type_vector
[old_vector_length
], 0,
354 (type_vector_length
- old_vector_length
) * sizeof (struct type
*));
356 return &type_vector
[index
];
359 /* Make sure there is a type allocated for type number index
360 and return the type object.
361 This can create an empty (zeroed) type object. */
364 coff_alloc_type (int index
)
366 struct type
**type_addr
= coff_lookup_type (index
);
367 struct type
*type
= *type_addr
;
369 /* If we are referring to a type not known at all yet,
370 allocate an empty type for it.
371 We will fill it in later if we find out how. */
374 type
= alloc_type (coffread_objfile
);
380 /* Start a new symtab for a new source file.
381 This is called when a COFF ".file" symbol is seen;
382 it indicates the start of data for one original source file. */
385 coff_start_symtab (struct objfile
*objfile
, const char *name
)
387 start_symtab (objfile
,
388 /* We fill in the filename later. start_symtab puts this pointer
389 into last_source_file and we put it in subfiles->name, which
390 end_symtab frees; that's why it must be malloc'd. */
392 /* We never know the directory name for COFF. */
394 /* The start address is irrelevant, since we set
395 last_source_start_addr in coff_end_symtab. */
397 record_debugformat ("COFF");
400 /* Save the vital information from when starting to read a file,
401 for use when closing off the current file.
402 NAME is the file name the symbols came from, START_ADDR is the
403 first text address for the file, and SIZE is the number of bytes of
407 complete_symtab (const char *name
, CORE_ADDR start_addr
, unsigned int size
)
409 set_last_source_file (name
);
410 current_source_start_addr
= start_addr
;
411 current_source_end_addr
= start_addr
+ size
;
414 /* Finish the symbol definitions for one main source file, close off
415 all the lexical contexts for that file (creating struct block's for
416 them), then make the struct symtab for that file and put it in the
420 coff_end_symtab (struct objfile
*objfile
)
422 last_source_start_addr
= current_source_start_addr
;
424 end_symtab (current_source_end_addr
, SECT_OFF_TEXT (objfile
));
426 /* Reinitialize for beginning of new file. */
427 set_last_source_file (NULL
);
430 /* The linker sometimes generates some non-function symbols inside
431 functions referencing variables imported from another DLL.
432 Return nonzero if the given symbol corresponds to one of them. */
435 is_import_fixup_symbol (struct coff_symbol
*cs
,
436 enum minimal_symbol_type type
)
438 /* The following is a bit of a heuristic using the characterictics
439 of these fixup symbols, but should work well in practice... */
442 /* Must be a non-static text symbol. */
443 if (type
!= mst_text
)
446 /* Must be a non-function symbol. */
447 if (ISFCN (cs
->c_type
))
450 /* The name must start with "__fu<digits>__". */
451 if (strncmp (cs
->c_name
, "__fu", 4) != 0)
453 if (! isdigit (cs
->c_name
[4]))
455 for (i
= 5; cs
->c_name
[i
] != '\0' && isdigit (cs
->c_name
[i
]); i
++)
456 /* Nothing, just incrementing index past all digits. */;
457 if (cs
->c_name
[i
] != '_' || cs
->c_name
[i
+ 1] != '_')
463 static struct minimal_symbol
*
464 record_minimal_symbol (struct coff_symbol
*cs
, CORE_ADDR address
,
465 enum minimal_symbol_type type
, int section
,
466 struct objfile
*objfile
)
468 /* We don't want TDESC entry points in the minimal symbol table. */
469 if (cs
->c_name
[0] == '@')
472 if (is_import_fixup_symbol (cs
, type
))
474 /* Because the value of these symbols is within a function code
475 range, these symbols interfere with the symbol-from-address
476 reverse lookup; this manifests itselfs in backtraces, or any
477 other commands that prints symbolic addresses. Just pretend
478 these symbols do not exist. */
482 return prim_record_minimal_symbol_and_info (cs
->c_name
, address
,
483 type
, section
, objfile
);
486 /* coff_symfile_init ()
487 is the coff-specific initialization routine for reading symbols.
488 It is passed a struct objfile which contains, among other things,
489 the BFD for the file whose symbols are being read, and a slot for
490 a pointer to "private data" which we fill with cookies and other
491 treats for coff_symfile_read ().
493 We will only be called if this is a COFF or COFF-like file. BFD
494 handles figuring out the format of the file, and code in symtab.c
495 uses BFD's determination to vector to us.
497 The ultimate result is a new symtab (or, FIXME, eventually a
501 coff_symfile_init (struct objfile
*objfile
)
503 struct dbx_symfile_info
*dbx
;
504 struct coff_symfile_info
*coff
;
506 /* Allocate struct to keep track of stab reading. */
507 dbx
= XCNEW (struct dbx_symfile_info
);
508 set_objfile_data (objfile
, dbx_objfile_data_key
, dbx
);
510 /* Allocate struct to keep track of the symfile. */
511 coff
= XCNEW (struct coff_symfile_info
);
512 set_objfile_data (objfile
, coff_objfile_data_key
, coff
);
514 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
515 find this causes a significant slowdown in gdb then we could
516 set it in the debug symbol readers only when necessary. */
517 objfile
->flags
|= OBJF_REORDERED
;
520 /* This function is called for every section; it finds the outer
521 limits of the line table (minimum and maximum file offset) so that
522 the mainline code can read the whole thing for efficiency. */
525 find_linenos (bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
527 struct coff_symfile_info
*info
;
529 file_ptr offset
, maxoff
;
531 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
532 count
= asect
->lineno_count
;
533 /* End of warning. */
537 size
= count
* local_linesz
;
539 info
= (struct coff_symfile_info
*) vpinfo
;
540 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
541 offset
= asect
->line_filepos
;
542 /* End of warning. */
544 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
545 info
->min_lineno_offset
= offset
;
547 maxoff
= offset
+ size
;
548 if (maxoff
> info
->max_lineno_offset
)
549 info
->max_lineno_offset
= maxoff
;
553 /* The BFD for this file -- only good while we're actively reading
554 symbols into a psymtab or a symtab. */
556 static bfd
*symfile_bfd
;
558 /* Read a symbol file, after initialization by coff_symfile_init. */
561 coff_symfile_read (struct objfile
*objfile
, int symfile_flags
)
563 struct coff_symfile_info
*info
;
564 struct dbx_symfile_info
*dbxinfo
;
565 bfd
*abfd
= objfile
->obfd
;
566 coff_data_type
*cdata
= coff_data (abfd
);
567 char *name
= bfd_get_filename (abfd
);
569 unsigned int num_symbols
;
571 int stringtab_offset
;
572 struct cleanup
*back_to
, *cleanup_minimal_symbols
;
575 info
= objfile_data (objfile
, coff_objfile_data_key
);
576 dbxinfo
= DBX_SYMFILE_INFO (objfile
);
577 symfile_bfd
= abfd
; /* Kludge for swap routines. */
579 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
580 num_symbols
= bfd_get_symcount (abfd
); /* How many syms */
581 symtab_offset
= cdata
->sym_filepos
; /* Symbol table file offset */
582 stringtab_offset
= symtab_offset
+ /* String table file offset */
583 num_symbols
* cdata
->local_symesz
;
585 /* Set a few file-statics that give us specific information about
586 the particular COFF file format we're reading. */
587 local_n_btmask
= cdata
->local_n_btmask
;
588 local_n_btshft
= cdata
->local_n_btshft
;
589 local_n_tmask
= cdata
->local_n_tmask
;
590 local_n_tshift
= cdata
->local_n_tshift
;
591 local_linesz
= cdata
->local_linesz
;
592 local_symesz
= cdata
->local_symesz
;
593 local_auxesz
= cdata
->local_auxesz
;
595 /* Allocate space for raw symbol and aux entries, based on their
596 space requirements as reported by BFD. */
597 temp_sym
= (char *) xmalloc
598 (cdata
->local_symesz
+ cdata
->local_auxesz
);
599 temp_aux
= temp_sym
+ cdata
->local_symesz
;
600 back_to
= make_cleanup (free_current_contents
, &temp_sym
);
602 /* We need to know whether this is a PE file, because in PE files,
603 unlike standard COFF files, symbol values are stored as offsets
604 from the section address, rather than as absolute addresses.
605 FIXME: We should use BFD to read the symbol table, and thus avoid
608 strncmp (bfd_get_target (objfile
->obfd
), "pe", 2) == 0
609 || strncmp (bfd_get_target (objfile
->obfd
), "epoc-pe", 7) == 0;
611 /* End of warning. */
613 info
->min_lineno_offset
= 0;
614 info
->max_lineno_offset
= 0;
616 /* Only read line number information if we have symbols.
618 On Windows NT, some of the system's DLL's have sections with
619 PointerToLinenumbers fields that are non-zero, but point at
620 random places within the image file. (In the case I found,
621 KERNEL32.DLL's .text section has a line number info pointer that
622 points into the middle of the string `lib\\i386\kernel32.dll'.)
624 However, these DLL's also have no symbols. The line number
625 tables are meaningless without symbols. And in fact, GDB never
626 uses the line number information unless there are symbols. So we
627 can avoid spurious error messages (and maybe run a little
628 faster!) by not even reading the line number table unless we have
632 /* Read the line number table, all at once. */
633 bfd_map_over_sections (abfd
, find_linenos
, (void *) info
);
635 make_cleanup (free_linetab_cleanup
, 0 /*ignore*/);
636 val
= init_lineno (abfd
, info
->min_lineno_offset
,
637 info
->max_lineno_offset
- info
->min_lineno_offset
);
639 error (_("\"%s\": error reading line numbers."), name
);
642 /* Now read the string table, all at once. */
644 make_cleanup (free_stringtab_cleanup
, 0 /*ignore*/);
645 val
= init_stringtab (abfd
, stringtab_offset
);
647 error (_("\"%s\": can't get string table"), name
);
649 init_minimal_symbol_collection ();
650 cleanup_minimal_symbols
= make_cleanup_discard_minimal_symbols ();
652 /* Now that the executable file is positioned at symbol table,
653 process it and define symbols accordingly. */
655 coff_symtab_read ((long) symtab_offset
, num_symbols
, objfile
);
657 /* Install any minimal symbols that have been collected as the
658 current minimal symbols for this objfile. */
660 install_minimal_symbols (objfile
);
664 struct minimal_symbol
*msym
;
666 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
668 const char *name
= MSYMBOL_LINKAGE_NAME (msym
);
670 /* If the minimal symbols whose name are prefixed by "__imp_"
671 or "_imp_", get rid of the prefix, and search the minimal
672 symbol in OBJFILE. Note that 'maintenance print msymbols'
673 shows that type of these "_imp_XXXX" symbols is mst_data. */
674 if (MSYMBOL_TYPE (msym
) == mst_data
675 && (strncmp (name
, "__imp_", 6) == 0
676 || strncmp (name
, "_imp_", 5) == 0))
678 const char *name1
= (name
[1] == '_' ? &name
[7] : &name
[6]);
679 struct bound_minimal_symbol found
;
681 found
= lookup_minimal_symbol (name1
, NULL
, objfile
);
682 /* If found, there are symbols named "_imp_foo" and "foo"
683 respectively in OBJFILE. Set the type of symbol "foo"
684 as 'mst_solib_trampoline'. */
685 if (found
.minsym
!= NULL
686 && MSYMBOL_TYPE (found
.minsym
) == mst_text
)
687 MSYMBOL_TYPE (found
.minsym
) = mst_solib_trampoline
;
692 /* Free the installed minimal symbol data. */
693 do_cleanups (cleanup_minimal_symbols
);
695 bfd_map_over_sections (abfd
, coff_locate_sections
, (void *) info
);
699 if (!info
->stabstrsect
)
701 error (_("The debugging information in `%s' is corrupted.\nThe "
702 "file has a `.stabs' section, but no `.stabstr' section."),
706 /* FIXME: dubious. Why can't we use something normal like
707 bfd_get_section_contents? */
708 bfd_seek (abfd
, abfd
->where
, 0);
710 stabstrsize
= bfd_section_size (abfd
, info
->stabstrsect
);
712 coffstab_build_psymtabs (objfile
,
713 info
->textaddr
, info
->textsize
,
715 info
->stabstrsect
->filepos
, stabstrsize
);
717 if (dwarf2_has_info (objfile
, NULL
))
719 /* DWARF2 sections. */
720 dwarf2_build_psymtabs (objfile
);
723 dwarf2_build_frame_info (objfile
);
725 /* Try to add separate debug file if no symbols table found. */
726 if (!objfile_has_partial_symbols (objfile
))
730 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
731 make_cleanup (xfree
, debugfile
);
735 bfd
*abfd
= symfile_bfd_open (debugfile
);
737 make_cleanup_bfd_unref (abfd
);
738 symbol_file_add_separate (abfd
, debugfile
, symfile_flags
, objfile
);
742 do_cleanups (back_to
);
746 coff_new_init (struct objfile
*ignore
)
750 /* Perform any local cleanups required when we are done with a
751 particular objfile. I.E, we are in the process of discarding all
752 symbol information for an objfile, freeing up all memory held for
753 it, and unlinking the objfile struct from the global list of known
757 coff_symfile_finish (struct objfile
*objfile
)
759 /* Let stabs reader clean up. */
760 stabsread_clear_cache ();
762 dwarf2_free_objfile (objfile
);
766 /* Given pointers to a symbol table in coff style exec file,
767 analyze them and create struct symtab's describing the symbols.
768 NSYMS is the number of symbols in the symbol table.
769 We read them one at a time using read_one_sym (). */
772 coff_symtab_read (long symtab_offset
, unsigned int nsyms
,
773 struct objfile
*objfile
)
775 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
776 struct context_stack
*new;
777 struct coff_symbol coff_symbol
;
778 struct coff_symbol
*cs
= &coff_symbol
;
779 static struct internal_syment main_sym
;
780 static union internal_auxent main_aux
;
781 struct coff_symbol fcn_cs_saved
;
782 static struct internal_syment fcn_sym_saved
;
783 static union internal_auxent fcn_aux_saved
;
785 /* A .file is open. */
786 int in_source_file
= 0;
787 int next_file_symnum
= -1;
788 /* Name of the current file. */
789 const char *filestring
= "";
791 int fcn_first_line
= 0;
792 CORE_ADDR fcn_first_line_addr
= 0;
793 int fcn_last_line
= 0;
794 int fcn_start_addr
= 0;
795 long fcn_line_ptr
= 0;
798 struct minimal_symbol
*msym
;
800 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
801 it's hard to know I've really worked around it. The fix should
802 be harmless, anyway). The symptom of the bug is that the first
803 fread (in read_one_sym), will (in my example) actually get data
804 from file offset 268, when the fseek was to 264 (and ftell shows
805 264). This causes all hell to break loose. I was unable to
806 reproduce this on a short test program which operated on the same
807 file, performing (I think) the same sequence of operations.
809 It stopped happening when I put in this (former) rewind().
811 FIXME: Find out if this has been reported to Sun, whether it has
812 been fixed in a later release, etc. */
814 bfd_seek (objfile
->obfd
, 0, 0);
816 /* Position to read the symbol table. */
817 val
= bfd_seek (objfile
->obfd
, (long) symtab_offset
, 0);
819 perror_with_name (objfile_name (objfile
));
821 coffread_objfile
= objfile
;
822 nlist_bfd_global
= objfile
->obfd
;
823 nlist_nsyms_global
= nsyms
;
824 set_last_source_file (NULL
);
825 memset (opaque_type_chain
, 0, sizeof opaque_type_chain
);
827 if (type_vector
) /* Get rid of previous one. */
829 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
830 type_vector
= (struct type
**)
831 xmalloc (type_vector_length
* sizeof (struct type
*));
832 memset (type_vector
, 0, type_vector_length
* sizeof (struct type
*));
834 coff_start_symtab (objfile
, "");
837 while (symnum
< nsyms
)
839 QUIT
; /* Make this command interruptable. */
841 read_one_sym (cs
, &main_sym
, &main_aux
);
843 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
845 if (get_last_source_file ())
846 coff_end_symtab (objfile
);
848 coff_start_symtab (objfile
, "_globals_");
849 /* coff_start_symtab will set the language of this symtab to
850 language_unknown, since such a ``file name'' is not
851 recognized. Override that with the minimal language to
852 allow printing values in this symtab. */
853 current_subfile
->language
= language_minimal
;
854 complete_symtab ("_globals_", 0, 0);
855 /* Done with all files, everything from here on out is
859 /* Special case for file with type declarations only, no
861 if (!get_last_source_file () && SDB_TYPE (cs
->c_type
)
862 && cs
->c_secnum
== N_DEBUG
)
863 complete_symtab (filestring
, 0, 0);
865 /* Typedefs should not be treated as symbol definitions. */
866 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
868 /* Record all functions -- external and static -- in
870 int section
= cs_to_section (cs
, objfile
);
872 tmpaddr
= cs
->c_value
;
873 record_minimal_symbol (cs
, tmpaddr
, mst_text
,
876 fcn_line_ptr
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
877 fcn_start_addr
= tmpaddr
;
879 fcn_sym_saved
= main_sym
;
880 fcn_aux_saved
= main_aux
;
884 switch (cs
->c_sclass
)
893 complaint (&symfile_complaints
,
894 _("Bad n_sclass for symbol %s"),
899 /* c_value field contains symnum of next .file entry in
900 table or symnum of first global after last .file. */
901 next_file_symnum
= cs
->c_value
;
903 filestring
= coff_getfilename (&main_aux
);
907 /* Complete symbol table for last object file
908 containing debugging information. */
909 if (get_last_source_file ())
911 coff_end_symtab (objfile
);
912 coff_start_symtab (objfile
, filestring
);
917 /* C_LABEL is used for labels and static functions.
918 Including it here allows gdb to see static functions when
919 no debug info is available. */
921 /* However, labels within a function can make weird
922 backtraces, so filter them out (from phdm@macqel.be). */
928 case C_THUMBSTATFUNC
:
929 if (cs
->c_name
[0] == '.')
931 if (strcmp (cs
->c_name
, ".text") == 0)
933 /* FIXME: don't wire in ".text" as section name or
935 /* Check for in_source_file deals with case of a
936 file with debugging symbols followed by a later
937 file with no symbols. */
939 complete_symtab (filestring
,
940 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
941 SECT_OFF_TEXT (objfile
)),
942 main_aux
.x_scn
.x_scnlen
);
945 /* Flush rest of '.' symbols. */
948 else if (!SDB_TYPE (cs
->c_type
)
949 && cs
->c_name
[0] == 'L'
950 && (strncmp (cs
->c_name
, "LI%", 3) == 0
951 || strncmp (cs
->c_name
, "LF%", 3) == 0
952 || strncmp (cs
->c_name
, "LC%", 3) == 0
953 || strncmp (cs
->c_name
, "LP%", 3) == 0
954 || strncmp (cs
->c_name
, "LPB%", 4) == 0
955 || strncmp (cs
->c_name
, "LBB%", 4) == 0
956 || strncmp (cs
->c_name
, "LBE%", 4) == 0
957 || strncmp (cs
->c_name
, "LPBX%", 5) == 0))
958 /* At least on a 3b1, gcc generates swbeg and string labels
959 that look like this. Ignore them. */
961 /* Fall in for static symbols that don't start with '.' */
966 /* Record it in the minimal symbols regardless of
967 SDB_TYPE. This parallels what we do for other debug
968 formats, and probably is needed to make
969 print_address_symbolic work right without the (now
970 gone) "set fast-symbolic-addr off" kludge. */
972 enum minimal_symbol_type ms_type
;
974 CORE_ADDR offset
= 0;
976 if (cs
->c_secnum
== N_UNDEF
)
978 /* This is a common symbol. We used to rely on
979 the target to tell us whether it knows where
980 the symbol has been relocated to, but none of
981 the target implementations actually provided
982 that operation. So we just ignore the symbol,
983 the same way we would do if we had a target-side
984 symbol lookup which returned no match. */
987 else if (cs
->c_secnum
== N_ABS
)
989 /* Use the correct minimal symbol type (and don't
990 relocate) for absolute values. */
992 sec
= cs_to_section (cs
, objfile
);
993 tmpaddr
= cs
->c_value
;
997 asection
*bfd_section
= cs_to_bfd_section (cs
, objfile
);
999 sec
= cs_to_section (cs
, objfile
);
1000 tmpaddr
= cs
->c_value
;
1001 /* Statics in a PE file also get relocated. */
1002 if (cs
->c_sclass
== C_EXT
1003 || cs
->c_sclass
== C_THUMBEXTFUNC
1004 || cs
->c_sclass
== C_THUMBEXT
1005 || (pe_file
&& (cs
->c_sclass
== C_STAT
)))
1006 offset
= ANOFFSET (objfile
->section_offsets
, sec
);
1008 if (bfd_section
->flags
& SEC_CODE
)
1011 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXTFUNC
1012 || cs
->c_sclass
== C_THUMBEXT
?
1013 mst_text
: mst_file_text
;
1014 tmpaddr
= gdbarch_addr_bits_remove (gdbarch
, tmpaddr
);
1016 else if (bfd_section
->flags
& SEC_ALLOC
1017 && bfd_section
->flags
& SEC_LOAD
)
1020 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1021 ? mst_data
: mst_file_data
;
1023 else if (bfd_section
->flags
& SEC_ALLOC
)
1026 cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1027 ? mst_bss
: mst_file_bss
;
1030 ms_type
= mst_unknown
;
1033 msym
= record_minimal_symbol (cs
, tmpaddr
, ms_type
,
1036 gdbarch_coff_make_msymbol_special (gdbarch
,
1037 cs
->c_sclass
, msym
);
1039 if (SDB_TYPE (cs
->c_type
))
1043 sym
= process_coff_symbol
1044 (cs
, &main_aux
, objfile
);
1045 SYMBOL_VALUE (sym
) = tmpaddr
+ offset
;
1046 SYMBOL_SECTION (sym
) = sec
;
1052 if (strcmp (cs
->c_name
, ".bf") == 0)
1054 within_function
= 1;
1056 /* Value contains address of first non-init type
1058 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1059 contains line number of '{' }. */
1060 if (cs
->c_naux
!= 1)
1061 complaint (&symfile_complaints
,
1062 _("`.bf' symbol %d has no aux entry"),
1064 fcn_first_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1065 fcn_first_line_addr
= cs
->c_value
;
1067 /* Might want to check that locals are 0 and
1068 context_stack_depth is zero, and complain if not. */
1071 new = push_context (depth
, fcn_start_addr
);
1072 fcn_cs_saved
.c_name
= getsymname (&fcn_sym_saved
);
1074 process_coff_symbol (&fcn_cs_saved
,
1075 &fcn_aux_saved
, objfile
);
1077 else if (strcmp (cs
->c_name
, ".ef") == 0)
1079 if (!within_function
)
1080 error (_("Bad coff function information."));
1081 /* The value of .ef is the address of epilogue code;
1082 not useful for gdb. */
1083 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1084 contains number of lines to '}' */
1086 if (context_stack_depth
<= 0)
1087 { /* We attempted to pop an empty context stack. */
1088 complaint (&symfile_complaints
,
1089 _("`.ef' symbol without matching `.bf' "
1090 "symbol ignored starting at symnum %d"),
1092 within_function
= 0;
1096 new = pop_context ();
1097 /* Stack must be empty now. */
1098 if (context_stack_depth
> 0 || new == NULL
)
1100 complaint (&symfile_complaints
,
1101 _("Unmatched .ef symbol(s) ignored "
1102 "starting at symnum %d"),
1104 within_function
= 0;
1107 if (cs
->c_naux
!= 1)
1109 complaint (&symfile_complaints
,
1110 _("`.ef' symbol %d has no aux entry"),
1112 fcn_last_line
= 0x7FFFFFFF;
1116 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1118 /* fcn_first_line is the line number of the opening '{'.
1119 Do not record it - because it would affect gdb's idea
1120 of the line number of the first statement of the
1121 function - except for one-line functions, for which
1122 it is also the line number of all the statements and
1123 of the closing '}', and for which we do not have any
1124 other statement-line-number. */
1125 if (fcn_last_line
== 1)
1126 record_line (current_subfile
, fcn_first_line
,
1127 gdbarch_addr_bits_remove (gdbarch
,
1128 fcn_first_line_addr
));
1130 enter_linenos (fcn_line_ptr
, fcn_first_line
,
1131 fcn_last_line
, objfile
);
1133 finish_block (new->name
, &local_symbols
,
1134 new->old_blocks
, new->start_addr
,
1135 fcn_cs_saved
.c_value
1136 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1137 + ANOFFSET (objfile
->section_offsets
,
1138 SECT_OFF_TEXT (objfile
)));
1139 within_function
= 0;
1144 if (strcmp (cs
->c_name
, ".bb") == 0)
1146 tmpaddr
= cs
->c_value
;
1147 tmpaddr
+= ANOFFSET (objfile
->section_offsets
,
1148 SECT_OFF_TEXT (objfile
));
1149 push_context (++depth
, tmpaddr
);
1151 else if (strcmp (cs
->c_name
, ".eb") == 0)
1153 if (context_stack_depth
<= 0)
1154 { /* We attempted to pop an empty context stack. */
1155 complaint (&symfile_complaints
,
1156 _("`.eb' symbol without matching `.bb' "
1157 "symbol ignored starting at symnum %d"),
1162 new = pop_context ();
1163 if (depth
-- != new->depth
)
1165 complaint (&symfile_complaints
,
1166 _("Mismatched .eb symbol ignored "
1167 "starting at symnum %d"),
1171 if (local_symbols
&& context_stack_depth
> 0)
1174 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
1175 SECT_OFF_TEXT (objfile
));
1176 /* Make a block for the local symbols within. */
1177 finish_block (0, &local_symbols
, new->old_blocks
,
1178 new->start_addr
, tmpaddr
);
1180 /* Now pop locals of block just finished. */
1181 local_symbols
= new->locals
;
1186 process_coff_symbol (cs
, &main_aux
, objfile
);
1191 if ((nsyms
== 0) && (pe_file
))
1193 /* We've got no debugging symbols, but it's a portable
1194 executable, so try to read the export table. */
1195 read_pe_exported_syms (objfile
);
1198 if (get_last_source_file ())
1199 coff_end_symtab (objfile
);
1201 /* Patch up any opaque types (references to types that are not defined
1202 in the file where they are referenced, e.g. "struct foo *bar"). */
1203 ALL_OBJFILE_SYMTABS (objfile
, s
)
1204 patch_opaque_types (s
);
1206 coffread_objfile
= NULL
;
1209 /* Routines for reading headers and symbols from executable. */
1211 /* Read the next symbol, swap it, and return it in both
1212 internal_syment form, and coff_symbol form. Also return its first
1213 auxent, if any, in internal_auxent form, and skip any other
1217 read_one_sym (struct coff_symbol
*cs
,
1218 struct internal_syment
*sym
,
1219 union internal_auxent
*aux
)
1222 bfd_size_type bytes
;
1224 cs
->c_symnum
= symnum
;
1225 bytes
= bfd_bread (temp_sym
, local_symesz
, nlist_bfd_global
);
1226 if (bytes
!= local_symesz
)
1227 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1228 bfd_coff_swap_sym_in (symfile_bfd
, temp_sym
, (char *) sym
);
1229 cs
->c_naux
= sym
->n_numaux
& 0xff;
1230 if (cs
->c_naux
>= 1)
1232 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1233 if (bytes
!= local_auxesz
)
1234 error (_("%s: error reading symbols"), objfile_name (coffread_objfile
));
1235 bfd_coff_swap_aux_in (symfile_bfd
, temp_aux
,
1236 sym
->n_type
, sym
->n_sclass
,
1237 0, cs
->c_naux
, (char *) aux
);
1238 /* If more than one aux entry, read past it (only the first aux
1240 for (i
= 1; i
< cs
->c_naux
; i
++)
1242 bytes
= bfd_bread (temp_aux
, local_auxesz
, nlist_bfd_global
);
1243 if (bytes
!= local_auxesz
)
1244 error (_("%s: error reading symbols"),
1245 objfile_name (coffread_objfile
));
1248 cs
->c_name
= getsymname (sym
);
1249 cs
->c_value
= sym
->n_value
;
1250 cs
->c_sclass
= (sym
->n_sclass
& 0xff);
1251 cs
->c_secnum
= sym
->n_scnum
;
1252 cs
->c_type
= (unsigned) sym
->n_type
;
1253 if (!SDB_TYPE (cs
->c_type
))
1257 if (cs
->c_sclass
& 128)
1258 printf (_("thumb symbol %s, class 0x%x\n"), cs
->c_name
, cs
->c_sclass
);
1261 symnum
+= 1 + cs
->c_naux
;
1263 /* The PE file format stores symbol values as offsets within the
1264 section, rather than as absolute addresses. We correct that
1265 here, if the symbol has an appropriate storage class. FIXME: We
1266 should use BFD to read the symbols, rather than duplicating the
1270 switch (cs
->c_sclass
)
1274 case C_THUMBEXTFUNC
:
1279 case C_THUMBSTATFUNC
:
1285 if (cs
->c_secnum
!= 0)
1286 cs
->c_value
+= cs_section_address (cs
, symfile_bfd
);
1292 /* Support for string table handling. */
1294 static char *stringtab
= NULL
;
1297 init_stringtab (bfd
*abfd
, long offset
)
1301 unsigned char lengthbuf
[4];
1305 /* If the file is stripped, the offset might be zero, indicating no
1306 string table. Just return with `stringtab' set to null. */
1310 if (bfd_seek (abfd
, offset
, 0) < 0)
1313 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1314 length
= bfd_h_get_32 (symfile_bfd
, lengthbuf
);
1316 /* If no string table is needed, then the file may end immediately
1317 after the symbols. Just return with `stringtab' set to null. */
1318 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1321 stringtab
= (char *) xmalloc (length
);
1322 /* This is in target format (probably not very useful, and not
1323 currently used), not host format. */
1324 memcpy (stringtab
, lengthbuf
, sizeof lengthbuf
);
1325 if (length
== sizeof length
) /* Empty table -- just the count. */
1328 val
= bfd_bread (stringtab
+ sizeof lengthbuf
,
1329 length
- sizeof lengthbuf
, abfd
);
1330 if (val
!= length
- sizeof lengthbuf
|| stringtab
[length
- 1] != '\0')
1337 free_stringtab (void)
1345 free_stringtab_cleanup (void *ignore
)
1351 getsymname (struct internal_syment
*symbol_entry
)
1353 static char buffer
[SYMNMLEN
+ 1];
1356 if (symbol_entry
->_n
._n_n
._n_zeroes
== 0)
1358 /* FIXME: Probably should be detecting corrupt symbol files by
1359 seeing whether offset points to within the stringtab. */
1360 result
= stringtab
+ symbol_entry
->_n
._n_n
._n_offset
;
1364 strncpy (buffer
, symbol_entry
->_n
._n_name
, SYMNMLEN
);
1365 buffer
[SYMNMLEN
] = '\0';
1371 /* Extract the file name from the aux entry of a C_FILE symbol.
1372 Return only the last component of the name. Result is in static
1373 storage and is only good for temporary use. */
1376 coff_getfilename (union internal_auxent
*aux_entry
)
1378 static char buffer
[BUFSIZ
];
1381 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1383 if (strlen (stringtab
+ aux_entry
->x_file
.x_n
.x_offset
) >= BUFSIZ
)
1384 internal_error (__FILE__
, __LINE__
, _("coff file name too long"));
1385 strcpy (buffer
, stringtab
+ aux_entry
->x_file
.x_n
.x_offset
);
1389 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1390 buffer
[FILNMLEN
] = '\0';
1394 /* FIXME: We should not be throwing away the information about what
1395 directory. It should go into dirname of the symtab, or some such
1397 result
= lbasename (result
);
1401 /* Support for line number handling. */
1403 static char *linetab
= NULL
;
1404 static long linetab_offset
;
1405 static unsigned long linetab_size
;
1407 /* Read in all the line numbers for fast lookups later. Leave them in
1408 external (unswapped) format in memory; we'll swap them as we enter
1409 them into GDB's data structures. */
1412 init_lineno (bfd
*abfd
, long offset
, int size
)
1416 linetab_offset
= offset
;
1417 linetab_size
= size
;
1424 if (bfd_seek (abfd
, offset
, 0) < 0)
1427 /* Allocate the desired table, plus a sentinel. */
1428 linetab
= (char *) xmalloc (size
+ local_linesz
);
1430 val
= bfd_bread (linetab
, size
, abfd
);
1434 /* Terminate it with an all-zero sentinel record. */
1435 memset (linetab
+ size
, 0, local_linesz
);
1449 free_linetab_cleanup (void *ignore
)
1454 #if !defined (L_LNNO32)
1455 #define L_LNNO32(lp) ((lp)->l_lnno)
1459 enter_linenos (long file_offset
, int first_line
,
1460 int last_line
, struct objfile
*objfile
)
1462 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1464 struct internal_lineno lptr
;
1468 if (file_offset
< linetab_offset
)
1470 complaint (&symfile_complaints
,
1471 _("Line number pointer %ld lower than start of line numbers"),
1473 if (file_offset
> linetab_size
) /* Too big to be an offset? */
1475 file_offset
+= linetab_offset
; /* Try reading at that linetab
1479 rawptr
= &linetab
[file_offset
- linetab_offset
];
1481 /* Skip first line entry for each function. */
1482 rawptr
+= local_linesz
;
1483 /* Line numbers start at one for the first line of the function. */
1486 /* If the line number table is full (e.g. 64K lines in COFF debug
1487 info), the next function's L_LNNO32 might not be zero, so don't
1488 overstep the table's end in any case. */
1489 while (rawptr
<= &linetab
[0] + linetab_size
)
1491 bfd_coff_swap_lineno_in (symfile_bfd
, rawptr
, &lptr
);
1492 rawptr
+= local_linesz
;
1493 /* The next function, or the sentinel, will have L_LNNO32 zero;
1495 if (L_LNNO32 (&lptr
) && L_LNNO32 (&lptr
) <= last_line
)
1497 CORE_ADDR addr
= lptr
.l_addr
.l_paddr
;
1498 addr
+= ANOFFSET (objfile
->section_offsets
,
1499 SECT_OFF_TEXT (objfile
));
1500 record_line (current_subfile
,
1501 first_line
+ L_LNNO32 (&lptr
),
1502 gdbarch_addr_bits_remove (gdbarch
, addr
));
1510 patch_type (struct type
*type
, struct type
*real_type
)
1512 struct type
*target
= TYPE_TARGET_TYPE (type
);
1513 struct type
*real_target
= TYPE_TARGET_TYPE (real_type
);
1514 int field_size
= TYPE_NFIELDS (real_target
) * sizeof (struct field
);
1516 TYPE_LENGTH (target
) = TYPE_LENGTH (real_target
);
1517 TYPE_NFIELDS (target
) = TYPE_NFIELDS (real_target
);
1518 TYPE_FIELDS (target
) = (struct field
*) TYPE_ALLOC (target
,
1521 memcpy (TYPE_FIELDS (target
),
1522 TYPE_FIELDS (real_target
),
1525 if (TYPE_NAME (real_target
))
1527 /* The previous copy of TYPE_NAME is allocated by
1528 process_coff_symbol. */
1529 if (TYPE_NAME (target
))
1530 xfree ((char*) TYPE_NAME (target
));
1531 TYPE_NAME (target
) = xstrdup (TYPE_NAME (real_target
));
1535 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1536 so that they can be used to print out opaque data structures
1540 patch_opaque_types (struct symtab
*s
)
1543 struct block_iterator iter
;
1544 struct symbol
*real_sym
;
1546 /* Go through the per-file symbols only. */
1547 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1548 ALL_BLOCK_SYMBOLS (b
, iter
, real_sym
)
1550 /* Find completed typedefs to use to fix opaque ones.
1551 Remove syms from the chain when their types are stored,
1552 but search the whole chain, as there may be several syms
1553 from different files with the same name. */
1554 if (SYMBOL_CLASS (real_sym
) == LOC_TYPEDEF
1555 && SYMBOL_DOMAIN (real_sym
) == VAR_DOMAIN
1556 && TYPE_CODE (SYMBOL_TYPE (real_sym
)) == TYPE_CODE_PTR
1557 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym
))) != 0)
1559 const char *name
= SYMBOL_LINKAGE_NAME (real_sym
);
1560 int hash
= hashname (name
);
1561 struct symbol
*sym
, *prev
;
1564 for (sym
= opaque_type_chain
[hash
]; sym
;)
1566 if (name
[0] == SYMBOL_LINKAGE_NAME (sym
)[0]
1567 && strcmp (name
+ 1, SYMBOL_LINKAGE_NAME (sym
) + 1) == 0)
1571 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1575 opaque_type_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1578 patch_type (SYMBOL_TYPE (sym
), SYMBOL_TYPE (real_sym
));
1582 sym
= SYMBOL_VALUE_CHAIN (prev
);
1586 sym
= opaque_type_chain
[hash
];
1592 sym
= SYMBOL_VALUE_CHAIN (sym
);
1600 coff_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
1602 return gdbarch_sdb_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
1605 static const struct symbol_register_ops coff_register_funcs
= {
1609 /* The "aclass" index for computed COFF symbols. */
1611 static int coff_register_index
;
1613 static struct symbol
*
1614 process_coff_symbol (struct coff_symbol
*cs
,
1615 union internal_auxent
*aux
,
1616 struct objfile
*objfile
)
1618 struct symbol
*sym
= allocate_symbol (objfile
);
1622 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
1623 SYMBOL_SET_LANGUAGE (sym
, current_subfile
->language
,
1624 &objfile
->objfile_obstack
);
1625 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), 1, objfile
);
1627 /* default assumptions */
1628 SYMBOL_VALUE (sym
) = cs
->c_value
;
1629 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1630 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1632 if (ISFCN (cs
->c_type
))
1634 SYMBOL_VALUE (sym
) += ANOFFSET (objfile
->section_offsets
,
1635 SECT_OFF_TEXT (objfile
));
1637 lookup_function_type (decode_function_type (cs
, cs
->c_type
,
1640 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
1641 if (cs
->c_sclass
== C_STAT
|| cs
->c_sclass
== C_THUMBSTAT
1642 || cs
->c_sclass
== C_THUMBSTATFUNC
)
1643 add_symbol_to_list (sym
, &file_symbols
);
1644 else if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_THUMBEXT
1645 || cs
->c_sclass
== C_THUMBEXTFUNC
)
1646 add_symbol_to_list (sym
, &global_symbols
);
1650 SYMBOL_TYPE (sym
) = decode_type (cs
, cs
->c_type
, aux
, objfile
);
1651 switch (cs
->c_sclass
)
1657 SYMBOL_ACLASS_INDEX (sym
) = LOC_LOCAL
;
1658 add_symbol_to_list (sym
, &local_symbols
);
1662 case C_THUMBEXTFUNC
:
1664 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1665 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1666 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1667 SECT_OFF_TEXT (objfile
));
1668 add_symbol_to_list (sym
, &global_symbols
);
1672 case C_THUMBSTATFUNC
:
1674 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
1675 SYMBOL_VALUE_ADDRESS (sym
) = (CORE_ADDR
) cs
->c_value
;
1676 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
1677 SECT_OFF_TEXT (objfile
));
1678 if (within_function
)
1680 /* Static symbol of local scope. */
1681 add_symbol_to_list (sym
, &local_symbols
);
1685 /* Static symbol at top level of file. */
1686 add_symbol_to_list (sym
, &file_symbols
);
1690 #ifdef C_GLBLREG /* AMD coff */
1694 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1695 SYMBOL_VALUE (sym
) = cs
->c_value
;
1696 add_symbol_to_list (sym
, &local_symbols
);
1704 SYMBOL_ACLASS_INDEX (sym
) = LOC_ARG
;
1705 SYMBOL_IS_ARGUMENT (sym
) = 1;
1706 add_symbol_to_list (sym
, &local_symbols
);
1710 SYMBOL_ACLASS_INDEX (sym
) = coff_register_index
;
1711 SYMBOL_IS_ARGUMENT (sym
) = 1;
1712 SYMBOL_VALUE (sym
) = cs
->c_value
;
1713 add_symbol_to_list (sym
, &local_symbols
);
1717 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1718 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1720 /* If type has no name, give it one. */
1721 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1723 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1724 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1726 /* If we are giving a name to a type such as
1727 "pointer to foo" or "function returning foo", we
1728 better not set the TYPE_NAME. If the program
1729 contains "typedef char *caddr_t;", we don't want
1730 all variables of type char * to print as caddr_t.
1731 This is not just a consequence of GDB's type
1732 management; CC and GCC (at least through version
1733 2.4) both output variables of either type char *
1734 or caddr_t with the type refering to the C_TPDEF
1735 symbol for caddr_t. If a future compiler cleans
1736 this up it GDB is not ready for it yet, but if it
1737 becomes ready we somehow need to disable this
1738 check (without breaking the PCC/GCC2.4 case).
1742 Fortunately, this check seems not to be necessary
1743 for anything except pointers or functions. */
1747 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1748 xstrdup (SYMBOL_LINKAGE_NAME (sym
));
1751 /* Keep track of any type which points to empty structured
1752 type, so it can be filled from a definition from another
1753 file. A simple forward reference (TYPE_CODE_UNDEF) is
1754 not an empty structured type, though; the forward
1755 references work themselves out via the magic of
1756 coff_lookup_type. */
1757 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1758 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
))) == 0
1759 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
)))
1762 int i
= hashname (SYMBOL_LINKAGE_NAME (sym
));
1764 SYMBOL_VALUE_CHAIN (sym
) = opaque_type_chain
[i
];
1765 opaque_type_chain
[i
] = sym
;
1767 add_symbol_to_list (sym
, &file_symbols
);
1773 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
1774 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
1776 /* Some compilers try to be helpful by inventing "fake"
1777 names for anonymous enums, structures, and unions, like
1778 "~0fake" or ".0fake". Thanks, but no thanks... */
1779 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1780 if (SYMBOL_LINKAGE_NAME (sym
) != NULL
1781 && *SYMBOL_LINKAGE_NAME (sym
) != '~'
1782 && *SYMBOL_LINKAGE_NAME (sym
) != '.')
1783 TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) =
1784 concat (SYMBOL_LINKAGE_NAME (sym
), (char *)NULL
);
1786 add_symbol_to_list (sym
, &file_symbols
);
1796 /* Decode a coff type specifier; return the type that is meant. */
1798 static struct type
*
1799 decode_type (struct coff_symbol
*cs
, unsigned int c_type
,
1800 union internal_auxent
*aux
, struct objfile
*objfile
)
1802 struct type
*type
= 0;
1803 unsigned int new_c_type
;
1805 if (c_type
& ~N_BTMASK
)
1807 new_c_type
= DECREF (c_type
);
1810 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1811 type
= lookup_pointer_type (type
);
1813 else if (ISFCN (c_type
))
1815 type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1816 type
= lookup_function_type (type
);
1818 else if (ISARY (c_type
))
1821 unsigned short *dim
;
1822 struct type
*base_type
, *index_type
, *range_type
;
1824 /* Define an array type. */
1825 /* auxent refers to array, not base type. */
1826 if (aux
->x_sym
.x_tagndx
.l
== 0)
1829 /* Shift the indices down. */
1830 dim
= &aux
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0];
1833 for (i
= 0; *dim
&& i
< DIMNUM
- 1; i
++, dim
++)
1837 base_type
= decode_type (cs
, new_c_type
, aux
, objfile
);
1838 index_type
= objfile_type (objfile
)->builtin_int
;
1840 = create_static_range_type ((struct type
*) NULL
,
1841 index_type
, 0, n
- 1);
1843 create_array_type ((struct type
*) NULL
,
1844 base_type
, range_type
);
1849 /* Reference to existing type. This only occurs with the struct,
1850 union, and enum types. EPI a29k coff fakes us out by producing
1851 aux entries with a nonzero x_tagndx for definitions of structs,
1852 unions, and enums, so we have to check the c_sclass field. SCO
1853 3.2v4 cc gets confused with pointers to pointers to defined
1854 structs, and generates negative x_tagndx fields. */
1855 if (cs
->c_naux
> 0 && aux
->x_sym
.x_tagndx
.l
!= 0)
1857 if (cs
->c_sclass
!= C_STRTAG
1858 && cs
->c_sclass
!= C_UNTAG
1859 && cs
->c_sclass
!= C_ENTAG
1860 && aux
->x_sym
.x_tagndx
.l
>= 0)
1862 type
= coff_alloc_type (aux
->x_sym
.x_tagndx
.l
);
1867 complaint (&symfile_complaints
,
1868 _("Symbol table entry for %s has bad tagndx value"),
1870 /* And fall through to decode_base_type... */
1874 return decode_base_type (cs
, BTYPE (c_type
), aux
, objfile
);
1877 /* Decode a coff type specifier for function definition;
1878 return the type that the function returns. */
1880 static struct type
*
1881 decode_function_type (struct coff_symbol
*cs
,
1882 unsigned int c_type
,
1883 union internal_auxent
*aux
,
1884 struct objfile
*objfile
)
1886 if (aux
->x_sym
.x_tagndx
.l
== 0)
1887 cs
->c_naux
= 0; /* auxent refers to function, not base
1890 return decode_type (cs
, DECREF (c_type
), aux
, objfile
);
1893 /* Basic C types. */
1895 static struct type
*
1896 decode_base_type (struct coff_symbol
*cs
,
1897 unsigned int c_type
,
1898 union internal_auxent
*aux
,
1899 struct objfile
*objfile
)
1901 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1907 /* Shows up with "void (*foo)();" structure members. */
1908 return objfile_type (objfile
)->builtin_void
;
1912 /* Intel 960 COFF has this symbol and meaning. */
1913 return objfile_type (objfile
)->builtin_void
;
1917 return objfile_type (objfile
)->builtin_char
;
1920 return objfile_type (objfile
)->builtin_short
;
1923 return objfile_type (objfile
)->builtin_int
;
1926 if (cs
->c_sclass
== C_FIELD
1927 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
1928 > gdbarch_long_bit (gdbarch
))
1929 return objfile_type (objfile
)->builtin_long_long
;
1931 return objfile_type (objfile
)->builtin_long
;
1934 return objfile_type (objfile
)->builtin_float
;
1937 return objfile_type (objfile
)->builtin_double
;
1940 return objfile_type (objfile
)->builtin_long_double
;
1943 if (cs
->c_naux
!= 1)
1945 /* Anonymous structure type. */
1946 type
= coff_alloc_type (cs
->c_symnum
);
1947 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1948 TYPE_NAME (type
) = NULL
;
1949 /* This used to set the tag to "<opaque>". But I think
1950 setting it to NULL is right, and the printing code can
1951 print it as "struct {...}". */
1952 TYPE_TAG_NAME (type
) = NULL
;
1953 INIT_CPLUS_SPECIFIC (type
);
1954 TYPE_LENGTH (type
) = 0;
1955 TYPE_FIELDS (type
) = 0;
1956 TYPE_NFIELDS (type
) = 0;
1960 type
= coff_read_struct_type (cs
->c_symnum
,
1961 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1962 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1968 if (cs
->c_naux
!= 1)
1970 /* Anonymous union type. */
1971 type
= coff_alloc_type (cs
->c_symnum
);
1972 TYPE_NAME (type
) = NULL
;
1973 /* This used to set the tag to "<opaque>". But I think
1974 setting it to NULL is right, and the printing code can
1975 print it as "union {...}". */
1976 TYPE_TAG_NAME (type
) = NULL
;
1977 INIT_CPLUS_SPECIFIC (type
);
1978 TYPE_LENGTH (type
) = 0;
1979 TYPE_FIELDS (type
) = 0;
1980 TYPE_NFIELDS (type
) = 0;
1984 type
= coff_read_struct_type (cs
->c_symnum
,
1985 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
1986 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
1989 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1993 if (cs
->c_naux
!= 1)
1995 /* Anonymous enum type. */
1996 type
= coff_alloc_type (cs
->c_symnum
);
1997 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1998 TYPE_NAME (type
) = NULL
;
1999 /* This used to set the tag to "<opaque>". But I think
2000 setting it to NULL is right, and the printing code can
2001 print it as "enum {...}". */
2002 TYPE_TAG_NAME (type
) = NULL
;
2003 TYPE_LENGTH (type
) = 0;
2004 TYPE_FIELDS (type
) = 0;
2005 TYPE_NFIELDS (type
) = 0;
2009 type
= coff_read_enum_type (cs
->c_symnum
,
2010 aux
->x_sym
.x_misc
.x_lnsz
.x_size
,
2011 aux
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
,
2017 /* Shouldn't show up here. */
2021 return objfile_type (objfile
)->builtin_unsigned_char
;
2024 return objfile_type (objfile
)->builtin_unsigned_short
;
2027 return objfile_type (objfile
)->builtin_unsigned_int
;
2030 if (cs
->c_sclass
== C_FIELD
2031 && aux
->x_sym
.x_misc
.x_lnsz
.x_size
2032 > gdbarch_long_bit (gdbarch
))
2033 return objfile_type (objfile
)->builtin_unsigned_long_long
;
2035 return objfile_type (objfile
)->builtin_unsigned_long
;
2037 complaint (&symfile_complaints
,
2038 _("Unexpected type for symbol %s"), cs
->c_name
);
2039 return objfile_type (objfile
)->builtin_void
;
2042 /* This page contains subroutines of read_type. */
2044 /* Read the description of a structure (or union type) and return an
2045 object describing the type. */
2047 static struct type
*
2048 coff_read_struct_type (int index
, int length
, int lastsym
,
2049 struct objfile
*objfile
)
2053 struct nextfield
*next
;
2058 struct nextfield
*list
= 0;
2059 struct nextfield
*new;
2063 struct coff_symbol member_sym
;
2064 struct coff_symbol
*ms
= &member_sym
;
2065 struct internal_syment sub_sym
;
2066 union internal_auxent sub_aux
;
2069 type
= coff_alloc_type (index
);
2070 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2071 INIT_CPLUS_SPECIFIC (type
);
2072 TYPE_LENGTH (type
) = length
;
2074 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2076 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2078 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2080 switch (ms
->c_sclass
)
2085 /* Get space to record the next field's data. */
2086 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2090 /* Save the data. */
2091 list
->field
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
2092 name
, strlen (name
));
2093 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2095 SET_FIELD_BITPOS (list
->field
, 8 * ms
->c_value
);
2096 FIELD_BITSIZE (list
->field
) = 0;
2102 /* Get space to record the next field's data. */
2103 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2107 /* Save the data. */
2108 list
->field
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
2109 name
, strlen (name
));
2110 FIELD_TYPE (list
->field
) = decode_type (ms
, ms
->c_type
,
2112 SET_FIELD_BITPOS (list
->field
, ms
->c_value
);
2113 FIELD_BITSIZE (list
->field
) = sub_aux
.x_sym
.x_misc
.x_lnsz
.x_size
;
2122 /* Now create the vector of fields, and record how big it is. */
2124 TYPE_NFIELDS (type
) = nfields
;
2125 TYPE_FIELDS (type
) = (struct field
*)
2126 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2128 /* Copy the saved-up fields into the field vector. */
2130 for (n
= nfields
; list
; list
= list
->next
)
2131 TYPE_FIELD (type
, --n
) = list
->field
;
2136 /* Read a definition of an enumeration type,
2137 and create and return a suitable type object.
2138 Also defines the symbols that represent the values of the type. */
2140 static struct type
*
2141 coff_read_enum_type (int index
, int length
, int lastsym
,
2142 struct objfile
*objfile
)
2144 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2149 struct pending
**symlist
;
2150 struct coff_symbol member_sym
;
2151 struct coff_symbol
*ms
= &member_sym
;
2152 struct internal_syment sub_sym
;
2153 union internal_auxent sub_aux
;
2154 struct pending
*osyms
, *syms
;
2158 int unsigned_enum
= 1;
2160 type
= coff_alloc_type (index
);
2161 if (within_function
)
2162 symlist
= &local_symbols
;
2164 symlist
= &file_symbols
;
2166 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2168 while (!done
&& symnum
< lastsym
&& symnum
< nlist_nsyms_global
)
2170 read_one_sym (ms
, &sub_sym
, &sub_aux
);
2172 name
= EXTERNAL_NAME (name
, objfile
->obfd
);
2174 switch (ms
->c_sclass
)
2177 sym
= allocate_symbol (objfile
);
2179 SYMBOL_SET_LINKAGE_NAME (sym
,
2180 obstack_copy0 (&objfile
->objfile_obstack
,
2181 name
, strlen (name
)));
2182 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
2183 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
2184 SYMBOL_VALUE (sym
) = ms
->c_value
;
2185 add_symbol_to_list (sym
, symlist
);
2190 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2191 up the count of how many symbols to read. So stop
2198 /* Now fill in the fields of the type-structure. */
2201 TYPE_LENGTH (type
) = length
;
2202 else /* Assume ints. */
2203 TYPE_LENGTH (type
) = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
2204 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2205 TYPE_NFIELDS (type
) = nsyms
;
2206 TYPE_FIELDS (type
) = (struct field
*)
2207 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2209 /* Find the symbols for the values and put them into the type.
2210 The symbols can be found in the symlist that we put them on
2211 to cause them to be defined. osyms contains the old value
2212 of that symlist; everything up to there was defined by us. */
2213 /* Note that we preserve the order of the enum constants, so
2214 that in something like "enum {FOO, LAST_THING=FOO}" we print
2215 FOO, not LAST_THING. */
2217 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2223 for (; j
< syms
->nsyms
; j
++, n
++)
2225 struct symbol
*xsym
= syms
->symbol
[j
];
2227 SYMBOL_TYPE (xsym
) = type
;
2228 TYPE_FIELD_NAME (type
, n
) = SYMBOL_LINKAGE_NAME (xsym
);
2229 SET_FIELD_ENUMVAL (TYPE_FIELD (type
, n
), SYMBOL_VALUE (xsym
));
2230 if (SYMBOL_VALUE (xsym
) < 0)
2232 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2239 TYPE_UNSIGNED (type
) = 1;
2244 /* Register our ability to parse symbols for coff BFD files. */
2246 static const struct sym_fns coff_sym_fns
=
2248 coff_new_init
, /* sym_new_init: init anything gbl to
2250 coff_symfile_init
, /* sym_init: read initial info, setup
2252 coff_symfile_read
, /* sym_read: read a symbol file into
2254 NULL
, /* sym_read_psymbols */
2255 coff_symfile_finish
, /* sym_finish: finished with file,
2257 default_symfile_offsets
, /* sym_offsets: xlate external to
2259 default_symfile_segments
, /* sym_segments: Get segment
2260 information from a file */
2261 NULL
, /* sym_read_linetable */
2263 default_symfile_relocate
, /* sym_relocate: Relocate a debug
2265 NULL
, /* sym_probe_fns */
2269 /* Free the per-objfile COFF data. */
2272 coff_free_info (struct objfile
*objfile
, void *arg
)
2278 _initialize_coffread (void)
2280 add_symtab_fns (bfd_target_coff_flavour
, &coff_sym_fns
);
2282 coff_objfile_data_key
= register_objfile_data_with_cleanup (NULL
,
2286 = register_symbol_register_impl (LOC_REGISTER
, &coff_register_funcs
);