1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1986-2024 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* This module provides three functions: dbx_symfile_init,
20 which initializes to read a symbol file; dbx_new_init, which
21 discards existing cached information when all symbols are being
22 discarded; and dbx_symfile_read, which reads a symbol table
25 dbx_symfile_read only does the minimum work necessary for letting the
26 user "name" things symbolically; it does not read the entire symtab.
27 Instead, it reads the external and static symbols and puts them in partial
28 symbol tables. When more extensive information is requested of a
29 file, the corresponding partial symbol table is mutated into a full
30 fledged symbol table by going back and reading the symbols
31 for real. dbx_psymtab_to_symtab() is the function that does this */
34 #include "event-top.h"
35 #include "gdbsupport/gdb_obstack.h"
38 #include "breakpoint.h"
42 #include "filenames.h"
44 #include "buildsym-legacy.h"
45 #include "stabsread.h"
46 #include "gdb-stabs.h"
48 #include "complaints.h"
50 #include "cp-support.h"
54 #include "aout/aout64.h"
55 #include "aout/stab_gnu.h"
58 /* Key for dbx-associated data. */
60 const registry
<objfile
>::key
<dbx_symfile_info
> dbx_objfile_data_key
;
62 /* We put a pointer to this structure in the read_symtab_private field
67 /* Offset within the file symbol table of first local symbol for this
72 /* Length (in bytes) of the section of the symbol table devoted to
73 this file's symbols (actually, the section bracketed may contain
74 more than just this file's symbols). If ldsymlen is 0, the only
75 reason for this thing's existence is the dependency list. Nothing
76 else will happen when it is read in. */
80 /* The size of each symbol in the symbol file (in external form). */
84 /* Further information needed to locate the symbols if they are in
89 int file_string_offset
;
90 enum language pst_language
;
93 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
94 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
95 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
96 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
97 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
98 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
99 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
100 #define PST_LANGUAGE(p) (SYMLOC(p)->pst_language)
103 /* The objfile we are currently reading. */
105 static struct objfile
*dbxread_objfile
;
107 /* Remember what we deduced to be the source language of this psymtab. */
109 static enum language psymtab_language
= language_unknown
;
111 /* The BFD for this file -- implicit parameter to next_symbol_text. */
113 static bfd
*symfile_bfd
;
115 /* The size of each symbol in the symbol file (in external form).
116 This is set by dbx_symfile_read when building psymtabs, and by
117 dbx_psymtab_to_symtab when building symtabs. */
119 static unsigned symbol_size
;
121 /* This is the offset of the symbol table in the executable file. */
123 static unsigned symbol_table_offset
;
125 /* This is the offset of the string table in the executable file. */
127 static unsigned string_table_offset
;
129 /* For elf+stab executables, the n_strx field is not a simple index
130 into the string table. Instead, each .o file has a base offset in
131 the string table, and the associated symbols contain offsets from
132 this base. The following two variables contain the base offset for
133 the current and next .o files. */
135 static unsigned int file_string_table_offset
;
136 static unsigned int next_file_string_table_offset
;
138 /* .o and NLM files contain unrelocated addresses which are based at
139 0. When non-zero, this flag disables some of the special cases for
140 Solaris elf+stab text addresses at location 0. */
142 static int symfile_relocatable
= 0;
144 /* When set, we are processing a .o file compiled by sun acc. This is
145 misnamed; it refers to all stabs-in-elf implementations which use
146 N_UNDF the way Sun does, including Solaris gcc. Hopefully all
147 stabs-in-elf implementations ever invented will choose to be
150 static unsigned char processing_acc_compilation
;
153 /* The lowest text address we have yet encountered. This is needed
154 because in an a.out file, there is no header field which tells us
155 what address the program is actually going to be loaded at, so we
156 need to make guesses based on the symbols (which *are* relocated to
157 reflect the address it will be loaded at). */
159 static unrelocated_addr lowest_text_address
;
161 /* Non-zero if there is any line number info in the objfile. Prevents
162 dbx_end_psymtab from discarding an otherwise empty psymtab. */
164 static int has_line_numbers
;
166 /* Complaints about the symbols we have encountered. */
169 unknown_symtype_complaint (const char *arg1
)
171 complaint (_("unknown symbol type %s"), arg1
);
175 lbrac_mismatch_complaint (int arg1
)
177 complaint (_("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1
);
181 repeated_header_complaint (const char *arg1
, int arg2
)
183 complaint (_("\"repeated\" header file %s not "
184 "previously seen, at symtab pos %d"),
188 /* find_text_range --- find start and end of loadable code sections
190 The find_text_range function finds the shortest address range that
191 encloses all sections containing executable code, and stores it in
192 objfile's text_addr and text_size members.
194 dbx_symfile_read will use this to finish off the partial symbol
195 table, in some cases. */
198 find_text_range (bfd
* sym_bfd
, struct objfile
*objfile
)
205 for (sec
= sym_bfd
->sections
; sec
; sec
= sec
->next
)
206 if (bfd_section_flags (sec
) & SEC_CODE
)
208 CORE_ADDR sec_start
= bfd_section_vma (sec
);
209 CORE_ADDR sec_end
= sec_start
+ bfd_section_size (sec
);
213 if (sec_start
< start
)
228 error (_("Can't find any code sections in symbol file"));
230 DBX_TEXT_ADDR (objfile
) = start
;
231 DBX_TEXT_SIZE (objfile
) = end
- start
;
236 /* During initial symbol readin, we need to have a structure to keep
237 track of which psymtabs have which bincls in them. This structure
238 is used during readin to setup the list of dependencies within each
239 partial symbol table. */
241 struct header_file_location
243 header_file_location (const char *name_
, int instance_
,
244 legacy_psymtab
*pst_
)
246 instance (instance_
),
251 const char *name
; /* Name of header file */
252 int instance
; /* See above */
253 legacy_psymtab
*pst
; /* Partial symtab that has the
254 BINCL/EINCL defs for this file. */
257 /* The list of bincls. */
258 static std::vector
<struct header_file_location
> *bincl_list
;
260 /* Local function prototypes. */
262 static void read_ofile_symtab (struct objfile
*, legacy_psymtab
*);
264 static void dbx_read_symtab (legacy_psymtab
*self
,
265 struct objfile
*objfile
);
267 static void dbx_expand_psymtab (legacy_psymtab
*, struct objfile
*);
269 static void read_dbx_symtab (minimal_symbol_reader
&, psymtab_storage
*,
272 static legacy_psymtab
*find_corresponding_bincl_psymtab (const char *,
275 static const char *dbx_next_symbol_text (struct objfile
*);
277 static void fill_symbuf (bfd
*);
279 static void dbx_symfile_init (struct objfile
*);
281 static void dbx_new_init (struct objfile
*);
283 static void dbx_symfile_read (struct objfile
*, symfile_add_flags
);
285 static void dbx_symfile_finish (struct objfile
*);
287 static void record_minimal_symbol (minimal_symbol_reader
&,
288 const char *, unrelocated_addr
, int,
291 static void add_new_header_file (const char *, int);
293 static void add_old_header_file (const char *, int);
295 static void add_this_object_header_file (int);
297 static legacy_psymtab
*start_psymtab (psymtab_storage
*, struct objfile
*,
298 const char *, unrelocated_addr
, int);
300 /* Free up old header file tables. */
303 free_header_files (void)
305 if (this_object_header_files
)
307 xfree (this_object_header_files
);
308 this_object_header_files
= NULL
;
310 n_allocated_this_object_header_files
= 0;
313 /* Allocate new header file tables. */
316 init_header_files (void)
318 n_allocated_this_object_header_files
= 10;
319 this_object_header_files
= XNEWVEC (int, 10);
322 /* Add header file number I for this object file
323 at the next successive FILENUM. */
326 add_this_object_header_file (int i
)
328 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
330 n_allocated_this_object_header_files
*= 2;
331 this_object_header_files
332 = (int *) xrealloc ((char *) this_object_header_files
,
333 n_allocated_this_object_header_files
* sizeof (int));
336 this_object_header_files
[n_this_object_header_files
++] = i
;
339 /* Add to this file an "old" header file, one already seen in
340 a previous object file. NAME is the header file's name.
341 INSTANCE is its instance code, to select among multiple
342 symbol tables for the same header file. */
345 add_old_header_file (const char *name
, int instance
)
347 struct header_file
*p
= HEADER_FILES (dbxread_objfile
);
350 for (i
= 0; i
< N_HEADER_FILES (dbxread_objfile
); i
++)
351 if (filename_cmp (p
[i
].name
, name
) == 0 && instance
== p
[i
].instance
)
353 add_this_object_header_file (i
);
356 repeated_header_complaint (name
, symnum
);
359 /* Add to this file a "new" header file: definitions for its types follow.
360 NAME is the header file's name.
361 Most often this happens only once for each distinct header file,
362 but not necessarily. If it happens more than once, INSTANCE has
363 a different value each time, and references to the header file
364 use INSTANCE values to select among them.
366 dbx output contains "begin" and "end" markers for each new header file,
367 but at this level we just need to know which files there have been;
368 so we record the file when its "begin" is seen and ignore the "end". */
371 add_new_header_file (const char *name
, int instance
)
374 struct header_file
*hfile
;
376 /* Make sure there is room for one more header file. */
378 i
= N_ALLOCATED_HEADER_FILES (dbxread_objfile
);
380 if (N_HEADER_FILES (dbxread_objfile
) == i
)
384 N_ALLOCATED_HEADER_FILES (dbxread_objfile
) = 10;
385 HEADER_FILES (dbxread_objfile
) = (struct header_file
*)
386 xmalloc (10 * sizeof (struct header_file
));
391 N_ALLOCATED_HEADER_FILES (dbxread_objfile
) = i
;
392 HEADER_FILES (dbxread_objfile
) = (struct header_file
*)
393 xrealloc ((char *) HEADER_FILES (dbxread_objfile
),
394 (i
* sizeof (struct header_file
)));
398 /* Create an entry for this header file. */
400 i
= N_HEADER_FILES (dbxread_objfile
)++;
401 hfile
= HEADER_FILES (dbxread_objfile
) + i
;
402 hfile
->name
= xstrdup (name
);
403 hfile
->instance
= instance
;
405 hfile
->vector
= XCNEWVEC (struct type
*, 10);
407 add_this_object_header_file (i
);
411 static struct type
**
412 explicit_lookup_type (int real_filenum
, int index
)
414 struct header_file
*f
= &HEADER_FILES (dbxread_objfile
)[real_filenum
];
416 if (index
>= f
->length
)
419 f
->vector
= (struct type
**)
420 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
421 memset (&f
->vector
[f
->length
/ 2],
422 '\0', f
->length
* sizeof (struct type
*) / 2);
424 return &f
->vector
[index
];
429 record_minimal_symbol (minimal_symbol_reader
&reader
,
430 const char *name
, unrelocated_addr address
, int type
,
431 struct objfile
*objfile
)
433 enum minimal_symbol_type ms_type
;
440 section
= SECT_OFF_TEXT (objfile
);
444 section
= SECT_OFF_DATA (objfile
);
448 section
= SECT_OFF_BSS (objfile
);
457 section
= SECT_OFF_DATA (objfile
);
460 /* I don't think this type actually exists; since a N_SETV is the result
461 of going over many .o files, it doesn't make sense to have one
463 ms_type
= mst_file_data
;
464 section
= SECT_OFF_DATA (objfile
);
471 ms_type
= mst_file_text
;
472 section
= SECT_OFF_TEXT (objfile
);
475 ms_type
= mst_file_data
;
477 /* Check for __DYNAMIC, which is used by Sun shared libraries.
478 Record it as global even if it's local, not global, so
479 lookup_minimal_symbol can find it. We don't check symbol_leading_char
480 because for SunOS4 it always is '_'. */
481 if (strcmp ("__DYNAMIC", name
) == 0)
484 /* Same with virtual function tables, both global and static. */
486 const char *tempstring
= name
;
488 if (*tempstring
!= '\0'
489 && *tempstring
== bfd_get_symbol_leading_char (objfile
->obfd
.get ()))
491 if (is_vtable_name (tempstring
))
494 section
= SECT_OFF_DATA (objfile
);
497 ms_type
= mst_file_bss
;
498 section
= SECT_OFF_BSS (objfile
);
501 ms_type
= mst_unknown
;
506 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
507 && address
< lowest_text_address
)
508 lowest_text_address
= address
;
510 reader
.record_with_info (name
, address
, ms_type
, section
);
513 /* Scan and build partial symbols for a symbol file.
514 We have been initialized by a call to dbx_symfile_init, which
515 put all the relevant info into a "struct dbx_symfile_info",
516 hung off the objfile structure. */
519 dbx_symfile_read (struct objfile
*objfile
, symfile_add_flags symfile_flags
)
524 sym_bfd
= objfile
->obfd
.get ();
526 /* .o and .nlm files are relocatables with text, data and bss segs based at
527 0. This flag disables special (Solaris stabs-in-elf only) fixups for
528 symbols with a value of 0. */
530 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
532 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
534 perror_with_name (objfile_name (objfile
));
536 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
537 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
539 scoped_free_pendings free_pending
;
541 minimal_symbol_reader
reader (objfile
);
543 /* Read stabs data from executable file and define symbols. */
545 psymbol_functions
*psf
= new psymbol_functions ();
546 psymtab_storage
*partial_symtabs
= psf
->get_partial_symtabs ().get ();
547 objfile
->qf
.emplace_front (psf
);
548 read_dbx_symtab (reader
, partial_symtabs
, objfile
);
550 /* Install any minimal symbols that have been collected as the current
551 minimal symbols for this objfile. */
556 /* Initialize anything that needs initializing when a completely new
557 symbol file is specified (not just adding some symbols from another
558 file, e.g. a shared library). */
561 dbx_new_init (struct objfile
*ignore
)
563 stabsread_new_init ();
564 init_header_files ();
568 /* dbx_symfile_init ()
569 is the dbx-specific initialization routine for reading symbols.
570 It is passed a struct objfile which contains, among other things,
571 the BFD for the file whose symbols are being read, and a slot for a pointer
572 to "private data" which we fill with goodies.
574 We read the string table into malloc'd space and stash a pointer to it.
576 Since BFD doesn't know how to read debug symbols in a format-independent
577 way (and may never do so...), we have to do it ourselves. We will never
578 be called unless this is an a.out (or very similar) file.
579 FIXME, there should be a cleaner peephole into the BFD environment here. */
581 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
584 dbx_symfile_init (struct objfile
*objfile
)
587 bfd
*sym_bfd
= objfile
->obfd
.get ();
588 const char *name
= bfd_get_filename (sym_bfd
);
590 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
592 /* Allocate struct to keep track of the symfile. */
593 dbx_objfile_data_key
.emplace (objfile
);
595 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
596 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
597 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
599 /* FIXME POKING INSIDE BFD DATA STRUCTURES. */
600 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
601 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
603 /* FIXME POKING INSIDE BFD DATA STRUCTURES. */
605 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
607 error (_("Can't find .text section in symbol file"));
608 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (text_sect
);
609 DBX_TEXT_SIZE (objfile
) = bfd_section_size (text_sect
);
611 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
612 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
613 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
615 /* Read the string table and stash it away in the objfile_obstack.
616 When we blow away the objfile the string table goes away as well.
617 Note that gdb used to use the results of attempting to malloc the
618 string table, based on the size it read, as a form of sanity check
619 for botched byte swapping, on the theory that a byte swapped string
620 table size would be so totally bogus that the malloc would fail. Now
621 that we put in on the objfile_obstack, we can't do this since gdb gets
622 a fatal error (out of virtual memory) if the size is bogus. We can
623 however at least check to see if the size is less than the size of
624 the size field itself, or larger than the size of the entire file.
625 Note that all valid string tables have a size greater than zero, since
626 the bytes used to hold the size are included in the count. */
628 if (STRING_TABLE_OFFSET
== 0)
630 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
631 will never be zero, even when there is no string table. This
632 would appear to be a bug in bfd. */
633 DBX_STRINGTAB_SIZE (objfile
) = 0;
634 DBX_STRINGTAB (objfile
) = NULL
;
638 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
640 perror_with_name (name
);
642 memset (size_temp
, 0, sizeof (size_temp
));
643 val
= bfd_read (size_temp
, sizeof (size_temp
), sym_bfd
);
646 perror_with_name (name
);
650 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
651 EOF if there is no string table, and attempting to read the size
652 from EOF will read zero bytes. */
653 DBX_STRINGTAB_SIZE (objfile
) = 0;
654 DBX_STRINGTAB (objfile
) = NULL
;
658 /* Read some data that would appear to be the string table size.
659 If there really is a string table, then it is probably the right
660 size. Byteswap if necessary and validate the size. Note that
661 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
662 random data that happened to be at STRING_TABLE_OFFSET, because
663 bfd can't tell us there is no string table, the sanity checks may
664 or may not catch this. */
665 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
667 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
668 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
669 error (_("ridiculous string table size (%d bytes)."),
670 DBX_STRINGTAB_SIZE (objfile
));
672 DBX_STRINGTAB (objfile
) =
673 (char *) obstack_alloc (&objfile
->objfile_obstack
,
674 DBX_STRINGTAB_SIZE (objfile
));
675 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
677 /* Now read in the string table in one big gulp. */
679 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
681 perror_with_name (name
);
682 val
= bfd_read (DBX_STRINGTAB (objfile
),
683 DBX_STRINGTAB_SIZE (objfile
),
685 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
686 perror_with_name (name
);
691 /* Perform any local cleanups required when we are done with a particular
692 objfile. I.E, we are in the process of discarding all symbol information
693 for an objfile, freeing up all memory held for it, and unlinking the
694 objfile struct from the global list of known objfiles. */
697 dbx_symfile_finish (struct objfile
*objfile
)
699 free_header_files ();
702 dbx_symfile_info::~dbx_symfile_info ()
704 if (header_files
!= NULL
)
706 int i
= n_header_files
;
707 struct header_file
*hfiles
= header_files
;
711 xfree (hfiles
[i
].name
);
712 xfree (hfiles
[i
].vector
);
720 /* Buffer for reading the symbol table entries. */
721 static struct external_nlist symbuf
[4096];
722 static int symbuf_idx
;
723 static int symbuf_end
;
725 /* Name of last function encountered. Used in Solaris to approximate
726 object file boundaries. */
727 static const char *last_function_name
;
729 /* The address in memory of the string table of the object file we are
730 reading (which might not be the "main" object file, but might be a
731 shared library or some other dynamically loaded thing). This is
732 set by read_dbx_symtab when building psymtabs, and by
733 read_ofile_symtab when building symtabs, and is used only by
734 next_symbol_text. FIXME: If that is true, we don't need it when
735 building psymtabs, right? */
736 static char *stringtab_global
;
738 /* These variables are used to control fill_symbuf when the stabs
739 symbols are not contiguous (as may be the case when a COFF file is
740 linked using --split-by-reloc). */
741 static const std::vector
<asection
*> *symbuf_sections
;
742 static size_t sect_idx
;
743 static unsigned int symbuf_left
;
744 static unsigned int symbuf_read
;
746 /* This variable stores a global stabs buffer, if we read stabs into
747 memory in one chunk in order to process relocations. */
748 static bfd_byte
*stabs_data
;
750 /* Refill the symbol table input buffer
751 and set the variables that control fetching entries from it.
752 Reports an error if no data available.
753 This function can read past the end of the symbol table
754 (into the string table) but this does no harm. */
757 fill_symbuf (bfd
*sym_bfd
)
764 nbytes
= sizeof (symbuf
);
765 if (nbytes
> symbuf_left
)
766 nbytes
= symbuf_left
;
767 memcpy (symbuf
, stabs_data
+ symbuf_read
, nbytes
);
769 else if (symbuf_sections
== NULL
)
771 count
= sizeof (symbuf
);
772 nbytes
= bfd_read (symbuf
, count
, sym_bfd
);
776 if (symbuf_left
<= 0)
778 file_ptr filepos
= (*symbuf_sections
)[sect_idx
]->filepos
;
780 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
781 perror_with_name (bfd_get_filename (sym_bfd
));
782 symbuf_left
= bfd_section_size ((*symbuf_sections
)[sect_idx
]);
783 symbol_table_offset
= filepos
- symbuf_read
;
788 if (count
> sizeof (symbuf
))
789 count
= sizeof (symbuf
);
790 nbytes
= bfd_read (symbuf
, count
, sym_bfd
);
794 perror_with_name (bfd_get_filename (sym_bfd
));
795 else if (nbytes
== 0)
796 error (_("Premature end of file reading symbol table"));
797 symbuf_end
= nbytes
/ symbol_size
;
799 symbuf_left
-= nbytes
;
800 symbuf_read
+= nbytes
;
804 stabs_seek (int sym_offset
)
808 symbuf_read
+= sym_offset
;
809 symbuf_left
-= sym_offset
;
812 if (bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
) != 0)
813 perror_with_name (bfd_get_filename (symfile_bfd
));
816 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
818 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
819 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
820 (intern).n_other = 0; \
821 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
822 if (bfd_get_sign_extend_vma (abfd)) \
823 (intern).n_value = bfd_h_get_signed_32 (abfd, (extern)->e_value); \
825 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
828 /* Invariant: The symbol pointed to by symbuf_idx is the first one
829 that hasn't been swapped. Swap the symbol at the same time
830 that symbuf_idx is incremented. */
832 /* dbx allows the text of a symbol name to be continued into the
833 next symbol name! When such a continuation is encountered
834 (a \ at the end of the text of a name)
835 call this function to get the continuation. */
838 dbx_next_symbol_text (struct objfile
*objfile
)
840 struct internal_nlist nlist
;
842 if (symbuf_idx
== symbuf_end
)
843 fill_symbuf (symfile_bfd
);
846 INTERNALIZE_SYMBOL (nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
847 OBJSTAT (objfile
, n_stabs
++);
851 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
855 /* Given a name, value pair, find the corresponding
856 bincl in the list. Return the partial symtab associated
857 with that header_file_location. */
859 static legacy_psymtab
*
860 find_corresponding_bincl_psymtab (const char *name
, int instance
)
862 for (const header_file_location
&bincl
: *bincl_list
)
863 if (bincl
.instance
== instance
864 && strcmp (name
, bincl
.name
) == 0)
867 repeated_header_complaint (name
, symnum
);
868 return (legacy_psymtab
*) 0;
871 /* Set namestring based on nlist. If the string table index is invalid,
872 give a fake name, and print a single error message per symbol file read,
873 rather than abort the symbol reading or flood the user with messages. */
876 set_namestring (struct objfile
*objfile
, const struct internal_nlist
*nlist
)
878 const char *namestring
;
880 if (nlist
->n_strx
+ file_string_table_offset
881 >= DBX_STRINGTAB_SIZE (objfile
)
882 || nlist
->n_strx
+ file_string_table_offset
< nlist
->n_strx
)
884 complaint (_("bad string table offset in symbol %d"),
886 namestring
= "<bad string table offset>";
889 namestring
= (nlist
->n_strx
+ file_string_table_offset
890 + DBX_STRINGTAB (objfile
));
894 static struct bound_minimal_symbol
895 find_stab_function (const char *namestring
, const char *filename
,
896 struct objfile
*objfile
)
898 struct bound_minimal_symbol msym
;
901 const char *colon
= strchr (namestring
, ':');
905 n
= colon
- namestring
;
907 char *p
= (char *) alloca (n
+ 2);
908 strncpy (p
, namestring
, n
);
911 msym
= lookup_minimal_symbol (p
, filename
, objfile
);
912 if (msym
.minsym
== NULL
)
914 /* Sun Fortran appends an underscore to the minimal symbol name,
915 try again with an appended underscore if the minimal symbol
919 msym
= lookup_minimal_symbol (p
, filename
, objfile
);
922 if (msym
.minsym
== NULL
&& filename
!= NULL
)
924 /* Try again without the filename. */
926 msym
= lookup_minimal_symbol (p
, NULL
, objfile
);
928 if (msym
.minsym
== NULL
&& filename
!= NULL
)
930 /* And try again for Sun Fortran, but without the filename. */
933 msym
= lookup_minimal_symbol (p
, NULL
, objfile
);
940 function_outside_compilation_unit_complaint (const char *arg1
)
942 complaint (_("function `%s' appears to be defined "
943 "outside of all compilation units"),
947 /* Setup partial_symtab's describing each source file for which
948 debugging information is available. */
951 read_dbx_symtab (minimal_symbol_reader
&reader
,
952 psymtab_storage
*partial_symtabs
,
953 struct objfile
*objfile
)
955 struct gdbarch
*gdbarch
= objfile
->arch ();
956 struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch. */
957 struct internal_nlist nlist
;
960 const char *sym_name
;
963 const char *namestring
;
965 int past_first_source_file
= 0;
966 CORE_ADDR last_function_start
= 0;
971 /* Current partial symtab. */
974 /* List of current psymtab's include files. */
975 const char **psymtab_include_list
;
976 int includes_allocated
;
979 /* Index within current psymtab dependency list. */
980 legacy_psymtab
**dependency_list
;
981 int dependencies_used
, dependencies_allocated
;
983 text_addr
= DBX_TEXT_ADDR (objfile
);
984 text_size
= DBX_TEXT_SIZE (objfile
);
986 /* FIXME. We probably want to change stringtab_global rather than add this
987 while processing every symbol entry. FIXME. */
988 file_string_table_offset
= 0;
989 next_file_string_table_offset
= 0;
991 stringtab_global
= DBX_STRINGTAB (objfile
);
993 pst
= (legacy_psymtab
*) 0;
995 includes_allocated
= 30;
997 psymtab_include_list
= (const char **) alloca (includes_allocated
*
998 sizeof (const char *));
1000 dependencies_allocated
= 30;
1001 dependencies_used
= 0;
1003 (legacy_psymtab
**) alloca (dependencies_allocated
*
1004 sizeof (legacy_psymtab
*));
1006 /* Init bincl list */
1007 std::vector
<struct header_file_location
> bincl_storage
;
1008 scoped_restore restore_bincl_global
1009 = make_scoped_restore (&bincl_list
, &bincl_storage
);
1011 set_last_source_file (NULL
);
1013 lowest_text_address
= (unrelocated_addr
) -1;
1015 symfile_bfd
= objfile
->obfd
.get (); /* For next_text_symbol. */
1016 abfd
= objfile
->obfd
.get ();
1017 symbuf_end
= symbuf_idx
= 0;
1018 next_symbol_text_func
= dbx_next_symbol_text
;
1019 textlow_not_set
= 1;
1020 has_line_numbers
= 0;
1022 /* FIXME: jimb/2003-09-12: We don't apply the right section's offset
1023 to global and static variables. The stab for a global or static
1024 variable doesn't give us any indication of which section it's in,
1025 so we can't tell immediately which offset in
1026 objfile->section_offsets we should apply to the variable's
1029 We could certainly find out which section contains the variable
1030 by looking up the variable's unrelocated address with
1031 find_pc_section, but that would be expensive; this is the
1032 function that constructs the partial symbol tables by examining
1033 every symbol in the entire executable, and it's
1034 performance-critical. So that expense would not be welcome. I'm
1035 not sure what to do about this at the moment.
1037 What we have done for years is to simply assume that the .data
1038 section's offset is appropriate for all global and static
1039 variables. Recently, this was expanded to fall back to the .bss
1040 section's offset if there is no .data section, and then to the
1041 .rodata section's offset. */
1042 data_sect_index
= objfile
->sect_index_data
;
1043 if (data_sect_index
== -1)
1044 data_sect_index
= SECT_OFF_BSS (objfile
);
1045 if (data_sect_index
== -1)
1046 data_sect_index
= SECT_OFF_RODATA (objfile
);
1048 /* If data_sect_index is still -1, that's okay. It's perfectly fine
1049 for the file to have no .data, no .bss, and no .text at all, if
1050 it also has no global or static variables. */
1052 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1054 /* Get the symbol for this run and pull out some info. */
1055 QUIT
; /* Allow this to be interruptable. */
1056 if (symbuf_idx
== symbuf_end
)
1058 bufp
= &symbuf
[symbuf_idx
++];
1061 * Special case to speed up readin.
1063 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1065 has_line_numbers
= 1;
1069 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1070 OBJSTAT (objfile
, n_stabs
++);
1072 /* Ok. There is a lot of code duplicated in the rest of this
1073 switch statement (for efficiency reasons). Since I don't
1074 like duplicating code, I will do my penance here, and
1075 describe the code which is duplicated:
1077 *) The assignment to namestring.
1078 *) The call to strchr.
1079 *) The addition of a partial symbol the two partial
1080 symbol lists. This last is a large section of code, so
1081 I've embedded it in the following macro. */
1083 switch (nlist
.n_type
)
1086 * Standard, external, non-debugger, symbols
1089 case N_TEXT
| N_EXT
:
1090 case N_NBTEXT
| N_EXT
:
1093 case N_DATA
| N_EXT
:
1094 case N_NBDATA
| N_EXT
:
1099 case N_NBBSS
| N_EXT
:
1100 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
1105 namestring
= set_namestring (objfile
, &nlist
);
1107 record_minimal_symbol (reader
, namestring
,
1108 unrelocated_addr (nlist
.n_value
),
1109 nlist
.n_type
, objfile
); /* Always */
1112 /* Standard, local, non-debugger, symbols. */
1116 /* We need to be able to deal with both N_FN or N_TEXT,
1117 because we have no way of knowing whether the sys-supplied ld
1118 or GNU ld was used to make the executable. Sequents throw
1119 in another wrinkle -- they renumbered N_FN. */
1124 namestring
= set_namestring (objfile
, &nlist
);
1126 if ((namestring
[0] == '-' && namestring
[1] == 'l')
1127 || (namestring
[(nsl
= strlen (namestring
)) - 1] == 'o'
1128 && namestring
[nsl
- 2] == '.'))
1130 unrelocated_addr unrel_val
= unrelocated_addr (nlist
.n_value
);
1132 if (past_first_source_file
&& pst
1133 /* The gould NP1 uses low values for .o and -l symbols
1134 which are not the address. */
1135 && unrel_val
>= pst
->unrelocated_text_low ())
1137 dbx_end_psymtab (objfile
, partial_symtabs
,
1138 pst
, psymtab_include_list
,
1139 includes_used
, symnum
* symbol_size
,
1140 unrel_val
> pst
->unrelocated_text_high ()
1141 ? unrel_val
: pst
->unrelocated_text_high (),
1142 dependency_list
, dependencies_used
,
1144 pst
= (legacy_psymtab
*) 0;
1146 dependencies_used
= 0;
1147 has_line_numbers
= 0;
1150 past_first_source_file
= 1;
1159 case N_UNDF
| N_EXT
:
1160 /* The case (nlist.n_value != 0) is a "Fortran COMMON" symbol.
1161 We used to rely on the target to tell us whether it knows
1162 where the symbol has been relocated to, but none of the
1163 target implementations actually provided that operation.
1164 So we just ignore the symbol, the same way we would do if
1165 we had a target-side symbol lookup which returned no match.
1167 All other symbols (with nlist.n_value == 0), are really
1168 undefined, and so we ignore them too. */
1172 if (processing_acc_compilation
&& nlist
.n_strx
== 1)
1174 /* Deal with relative offsets in the string table
1175 used in ELF+STAB under Solaris. If we want to use the
1176 n_strx field, which contains the name of the file,
1177 we must adjust file_string_table_offset *before* calling
1178 set_namestring(). */
1179 past_first_source_file
= 1;
1180 file_string_table_offset
= next_file_string_table_offset
;
1181 next_file_string_table_offset
=
1182 file_string_table_offset
+ nlist
.n_value
;
1183 if (next_file_string_table_offset
< file_string_table_offset
)
1184 error (_("string table offset backs up at %d"), symnum
);
1185 /* FIXME -- replace error() with complaint. */
1190 /* Lots of symbol types we can just ignore. */
1197 /* Keep going . . . */
1200 * Special symbol types for GNU
1203 case N_INDR
| N_EXT
:
1205 case N_SETA
| N_EXT
:
1207 case N_SETT
| N_EXT
:
1209 case N_SETD
| N_EXT
:
1211 case N_SETB
| N_EXT
:
1222 static int prev_so_symnum
= -10;
1223 static int first_so_symnum
;
1225 static const char *dirname_nso
;
1226 int prev_textlow_not_set
;
1228 valu
= nlist
.n_value
;
1230 prev_textlow_not_set
= textlow_not_set
;
1232 /* A zero value is probably an indication for the SunPRO 3.0
1233 compiler. dbx_end_psymtab explicitly tests for zero, so
1234 don't relocate it. */
1236 if (nlist
.n_value
== 0
1237 && gdbarch_sofun_address_maybe_missing (gdbarch
))
1239 textlow_not_set
= 1;
1243 textlow_not_set
= 0;
1245 past_first_source_file
= 1;
1247 if (prev_so_symnum
!= symnum
- 1)
1248 { /* Here if prev stab wasn't N_SO. */
1249 first_so_symnum
= symnum
;
1253 unrelocated_addr unrel_value
= unrelocated_addr (valu
);
1254 dbx_end_psymtab (objfile
, partial_symtabs
,
1255 pst
, psymtab_include_list
,
1256 includes_used
, symnum
* symbol_size
,
1257 unrel_value
> pst
->unrelocated_text_high ()
1259 : pst
->unrelocated_text_high (),
1260 dependency_list
, dependencies_used
,
1261 prev_textlow_not_set
);
1262 pst
= (legacy_psymtab
*) 0;
1264 dependencies_used
= 0;
1265 has_line_numbers
= 0;
1269 prev_so_symnum
= symnum
;
1271 /* End the current partial symtab and start a new one. */
1273 namestring
= set_namestring (objfile
, &nlist
);
1275 /* Null name means end of .o file. Don't start a new one. */
1276 if (*namestring
== '\000')
1279 /* Some compilers (including gcc) emit a pair of initial N_SOs.
1280 The first one is a directory name; the second the file name.
1281 If pst exists, is empty, and has a filename ending in '/',
1282 we assume the previous N_SO was a directory name. */
1284 p
= lbasename (namestring
);
1285 if (p
!= namestring
&& *p
== '\000')
1287 /* Save the directory name SOs locally, then save it into
1288 the psymtab when it's created below. */
1289 dirname_nso
= namestring
;
1293 /* Some other compilers (C++ ones in particular) emit useless
1294 SOs for non-existant .c files. We ignore all subsequent SOs
1295 that immediately follow the first. */
1299 pst
= start_psymtab (partial_symtabs
, objfile
,
1301 unrelocated_addr (valu
),
1302 first_so_symnum
* symbol_size
);
1303 pst
->dirname
= dirname_nso
;
1311 enum language tmp_language
;
1313 /* Add this bincl to the bincl_list for future EXCLs. No
1314 need to save the string; it'll be around until
1315 read_dbx_symtab function returns. */
1317 namestring
= set_namestring (objfile
, &nlist
);
1318 tmp_language
= deduce_language_from_filename (namestring
);
1320 /* Only change the psymtab's language if we've learned
1321 something useful (eg. tmp_language is not language_unknown).
1322 In addition, to match what start_subfile does, never change
1324 if (tmp_language
!= language_unknown
1325 && (tmp_language
!= language_c
1326 || psymtab_language
!= language_cplus
))
1327 psymtab_language
= tmp_language
;
1331 /* FIXME: we should not get here without a PST to work on.
1332 Attempt to recover. */
1333 complaint (_("N_BINCL %s not in entries for "
1334 "any file, at symtab pos %d"),
1335 namestring
, symnum
);
1338 bincl_list
->emplace_back (namestring
, nlist
.n_value
, pst
);
1340 /* Mark down an include file in the current psymtab. */
1342 goto record_include_file
;
1347 enum language tmp_language
;
1349 /* Mark down an include file in the current psymtab. */
1350 namestring
= set_namestring (objfile
, &nlist
);
1351 tmp_language
= deduce_language_from_filename (namestring
);
1353 /* Only change the psymtab's language if we've learned
1354 something useful (eg. tmp_language is not language_unknown).
1355 In addition, to match what start_subfile does, never change
1357 if (tmp_language
!= language_unknown
1358 && (tmp_language
!= language_c
1359 || psymtab_language
!= language_cplus
))
1360 psymtab_language
= tmp_language
;
1362 /* In C++, one may expect the same filename to come round many
1363 times, when code is coming alternately from the main file
1364 and from inline functions in other files. So I check to see
1365 if this is a file we've seen before -- either the main
1366 source file, or a previously included file.
1368 This seems to be a lot of time to be spending on N_SOL, but
1369 things like "break c-exp.y:435" need to work (I
1370 suppose the psymtab_include_list could be hashed or put
1371 in a binary tree, if profiling shows this is a major hog). */
1372 if (pst
&& filename_cmp (namestring
, pst
->filename
) == 0)
1377 for (i
= 0; i
< includes_used
; i
++)
1378 if (filename_cmp (namestring
, psymtab_include_list
[i
]) == 0)
1387 record_include_file
:
1389 psymtab_include_list
[includes_used
++] = namestring
;
1390 if (includes_used
>= includes_allocated
)
1392 const char **orig
= psymtab_include_list
;
1394 psymtab_include_list
= (const char **)
1395 alloca ((includes_allocated
*= 2) * sizeof (const char *));
1396 memcpy (psymtab_include_list
, orig
,
1397 includes_used
* sizeof (const char *));
1401 case N_LSYM
: /* Typedef or automatic variable. */
1402 case N_STSYM
: /* Data seg var -- static. */
1403 case N_LCSYM
: /* BSS " */
1404 case N_ROSYM
: /* Read-only data seg var -- static. */
1405 case N_NBSTS
: /* Gould nobase. */
1406 case N_NBLCS
: /* symbols. */
1408 case N_GSYM
: /* Global (extern) variable; can be
1409 data or bss (sigh FIXME). */
1411 /* Following may probably be ignored; I'll leave them here
1412 for now (until I do Pascal and Modula 2 extensions). */
1414 case N_PC
: /* I may or may not need this; I
1416 case N_M2C
: /* I suspect that I can ignore this here. */
1417 case N_SCOPE
: /* Same. */
1421 namestring
= set_namestring (objfile
, &nlist
);
1423 /* See if this is an end of function stab. */
1424 if (pst
&& nlist
.n_type
== N_FUN
&& *namestring
== '\000')
1426 unrelocated_addr valu
;
1428 /* It's value is the size (in bytes) of the function for
1429 function relative stabs, or the address of the function's
1430 end for old style stabs. */
1431 valu
= unrelocated_addr (nlist
.n_value
+ last_function_start
);
1432 if (pst
->unrelocated_text_high () == unrelocated_addr (0)
1433 || valu
> pst
->unrelocated_text_high ())
1434 pst
->set_text_high (valu
);
1438 p
= (char *) strchr (namestring
, ':');
1440 continue; /* Not a debugging symbol. */
1443 sym_name
= NULL
; /* pacify "gcc -Werror" */
1444 if (psymtab_language
== language_cplus
)
1446 std::string
name (namestring
, p
- namestring
);
1447 gdb::unique_xmalloc_ptr
<char> new_name
1448 = cp_canonicalize_string (name
.c_str ());
1449 if (new_name
!= nullptr)
1451 sym_len
= strlen (new_name
.get ());
1452 sym_name
= obstack_strdup (&objfile
->objfile_obstack
,
1456 else if (psymtab_language
== language_c
)
1458 std::string
name (namestring
, p
- namestring
);
1459 gdb::unique_xmalloc_ptr
<char> new_name
1460 = c_canonicalize_name (name
.c_str ());
1461 if (new_name
!= nullptr)
1463 sym_len
= strlen (new_name
.get ());
1464 sym_name
= obstack_strdup (&objfile
->objfile_obstack
,
1471 sym_name
= namestring
;
1472 sym_len
= p
- namestring
;
1475 /* Main processing section for debugging symbols which
1476 the initial read through the symbol tables needs to worry
1477 about. If we reach this point, the symbol which we are
1478 considering is definitely one we are interested in.
1479 p must also contain the (valid) index into the namestring
1480 which indicates the debugging type symbol. */
1486 pst
->add_psymbol (std::string_view (sym_name
, sym_len
), true,
1487 VAR_DOMAIN
, LOC_STATIC
,
1489 psymbol_placement::STATIC
,
1490 unrelocated_addr (nlist
.n_value
),
1492 partial_symtabs
, objfile
);
1494 complaint (_("static `%*s' appears to be defined "
1495 "outside of all compilation units"),
1500 /* The addresses in these entries are reported to be
1501 wrong. See the code that reads 'G's for symtabs. */
1503 pst
->add_psymbol (std::string_view (sym_name
, sym_len
), true,
1504 VAR_DOMAIN
, LOC_STATIC
,
1506 psymbol_placement::GLOBAL
,
1507 unrelocated_addr (nlist
.n_value
),
1509 partial_symtabs
, objfile
);
1511 complaint (_("global `%*s' appears to be defined "
1512 "outside of all compilation units"),
1517 /* When a 'T' entry is defining an anonymous enum, it
1518 may have a name which is the empty string, or a
1519 single space. Since they're not really defining a
1520 symbol, those shouldn't go in the partial symbol
1521 table. We do pick up the elements of such enums at
1522 'check_enum:', below. */
1523 if (p
>= namestring
+ 2
1524 || (p
== namestring
+ 1
1525 && namestring
[0] != ' '))
1528 pst
->add_psymbol (std::string_view (sym_name
, sym_len
),
1529 true, STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
1530 psymbol_placement::STATIC
,
1531 unrelocated_addr (0),
1533 partial_symtabs
, objfile
);
1535 complaint (_("enum, struct, or union `%*s' appears "
1536 "to be defined outside of all "
1537 "compilation units"),
1541 /* Also a typedef with the same name. */
1543 pst
->add_psymbol (std::string_view (sym_name
, sym_len
),
1544 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
1545 psymbol_placement::STATIC
,
1546 unrelocated_addr (0),
1548 partial_symtabs
, objfile
);
1550 complaint (_("typedef `%*s' appears to be defined "
1551 "outside of all compilation units"),
1559 if (p
!= namestring
) /* a name is there, not just :T... */
1562 pst
->add_psymbol (std::string_view (sym_name
, sym_len
),
1563 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
1564 psymbol_placement::STATIC
,
1565 unrelocated_addr (0),
1567 partial_symtabs
, objfile
);
1569 complaint (_("typename `%*s' appears to be defined "
1570 "outside of all compilation units"),
1574 /* If this is an enumerated type, we need to
1575 add all the enum constants to the partial symbol
1576 table. This does not cover enums without names, e.g.
1577 "enum {a, b} c;" in C, but fortunately those are
1578 rare. There is no way for GDB to find those from the
1579 enum type without spending too much time on it. Thus
1580 to solve this problem, the compiler needs to put out the
1581 enum in a nameless type. GCC2 does this. */
1583 /* We are looking for something of the form
1584 <name> ":" ("t" | "T") [<number> "="] "e"
1585 {<constant> ":" <value> ","} ";". */
1587 /* Skip over the colon and the 't' or 'T'. */
1589 /* This type may be given a number. Also, numbers can come
1590 in pairs like (0,26). Skip over it. */
1591 while ((*p
>= '0' && *p
<= '9')
1592 || *p
== '(' || *p
== ',' || *p
== ')'
1598 /* The aix4 compiler emits extra crud before the members. */
1601 /* Skip over the type (?). */
1605 /* Skip over the colon. */
1609 /* We have found an enumerated type. */
1610 /* According to comments in read_enum_type
1611 a comma could end it instead of a semicolon.
1612 I don't know where that happens.
1614 while (*p
&& *p
!= ';' && *p
!= ',')
1618 /* Check for and handle cretinous dbx symbol name
1620 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
1621 p
= next_symbol_text (objfile
);
1623 /* Point to the character after the name
1624 of the enum constant. */
1625 for (q
= p
; *q
&& *q
!= ':'; q
++)
1627 /* Note that the value doesn't matter for
1628 enum constants in psymtabs, just in symtabs. */
1630 pst
->add_psymbol (std::string_view (p
, q
- p
), true,
1631 VAR_DOMAIN
, LOC_CONST
, -1,
1632 psymbol_placement::STATIC
,
1633 unrelocated_addr (0),
1635 partial_symtabs
, objfile
);
1637 complaint (_("enum constant `%*s' appears to be defined "
1638 "outside of all compilation units"),
1639 ((int) (q
- p
)), p
);
1640 /* Point past the name. */
1642 /* Skip over the value. */
1643 while (*p
&& *p
!= ',')
1645 /* Advance past the comma. */
1653 /* Constant, e.g. from "const" in Pascal. */
1655 pst
->add_psymbol (std::string_view (sym_name
, sym_len
), true,
1656 VAR_DOMAIN
, LOC_CONST
, -1,
1657 psymbol_placement::STATIC
,
1658 unrelocated_addr (0),
1660 partial_symtabs
, objfile
);
1662 complaint (_("constant `%*s' appears to be defined "
1663 "outside of all compilation units"),
1671 std::string
name (namestring
, (p
- namestring
));
1672 function_outside_compilation_unit_complaint (name
.c_str ());
1674 /* Kludges for ELF/STABS with Sun ACC. */
1675 last_function_name
= namestring
;
1676 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1677 value for the bottom of the text seg in those cases. */
1678 if (nlist
.n_value
== 0
1679 && gdbarch_sofun_address_maybe_missing (gdbarch
))
1681 struct bound_minimal_symbol minsym
1682 = find_stab_function (namestring
,
1683 pst
? pst
->filename
: NULL
,
1685 if (minsym
.minsym
!= NULL
)
1687 = CORE_ADDR (minsym
.minsym
->unrelocated_address ());
1689 if (pst
&& textlow_not_set
1690 && gdbarch_sofun_address_maybe_missing (gdbarch
))
1692 pst
->set_text_low (unrelocated_addr (nlist
.n_value
));
1693 textlow_not_set
= 0;
1697 /* Keep track of the start of the last function so we
1698 can handle end of function symbols. */
1699 last_function_start
= nlist
.n_value
;
1701 /* In reordered executables this function may lie outside
1702 the bounds created by N_SO symbols. If that's the case
1703 use the address of this function as the low bound for
1704 the partial symbol table. */
1707 || (unrelocated_addr (nlist
.n_value
)
1708 < pst
->unrelocated_text_low ()
1709 && (nlist
.n_value
!= 0))))
1711 pst
->set_text_low (unrelocated_addr (nlist
.n_value
));
1712 textlow_not_set
= 0;
1715 pst
->add_psymbol (std::string_view (sym_name
, sym_len
), true,
1716 VAR_DOMAIN
, LOC_BLOCK
,
1717 SECT_OFF_TEXT (objfile
),
1718 psymbol_placement::STATIC
,
1719 unrelocated_addr (nlist
.n_value
),
1721 partial_symtabs
, objfile
);
1724 /* Global functions were ignored here, but now they
1725 are put into the global psymtab like one would expect.
1726 They're also in the minimal symbol table. */
1730 std::string
name (namestring
, (p
- namestring
));
1731 function_outside_compilation_unit_complaint (name
.c_str ());
1733 /* Kludges for ELF/STABS with Sun ACC. */
1734 last_function_name
= namestring
;
1735 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1736 value for the bottom of the text seg in those cases. */
1737 if (nlist
.n_value
== 0
1738 && gdbarch_sofun_address_maybe_missing (gdbarch
))
1740 struct bound_minimal_symbol minsym
1741 = find_stab_function (namestring
,
1742 pst
? pst
->filename
: NULL
,
1744 if (minsym
.minsym
!= NULL
)
1746 = CORE_ADDR (minsym
.minsym
->unrelocated_address ());
1748 if (pst
&& textlow_not_set
1749 && gdbarch_sofun_address_maybe_missing (gdbarch
))
1751 pst
->set_text_low (unrelocated_addr (nlist
.n_value
));
1752 textlow_not_set
= 0;
1756 /* Keep track of the start of the last function so we
1757 can handle end of function symbols. */
1758 last_function_start
= nlist
.n_value
;
1760 /* In reordered executables this function may lie outside
1761 the bounds created by N_SO symbols. If that's the case
1762 use the address of this function as the low bound for
1763 the partial symbol table. */
1766 || (unrelocated_addr (nlist
.n_value
)
1767 < pst
->unrelocated_text_low ()
1768 && (nlist
.n_value
!= 0))))
1770 pst
->set_text_low (unrelocated_addr (nlist
.n_value
));
1771 textlow_not_set
= 0;
1774 pst
->add_psymbol (std::string_view (sym_name
, sym_len
), true,
1775 VAR_DOMAIN
, LOC_BLOCK
,
1776 SECT_OFF_TEXT (objfile
),
1777 psymbol_placement::GLOBAL
,
1778 unrelocated_addr (nlist
.n_value
),
1780 partial_symtabs
, objfile
);
1783 /* Two things show up here (hopefully); static symbols of
1784 local scope (static used inside braces) or extensions
1785 of structure symbols. We can ignore both. */
1799 case '#': /* For symbol identification (used in live ranges). */
1803 /* It is a C++ nested symbol. We don't need to record it
1804 (I don't think); if we try to look up foo::bar::baz,
1805 then symbols for the symtab containing foo should get
1806 read in, I think. */
1807 /* Someone says sun cc puts out symbols like
1808 /foo/baz/maclib::/usr/local/bin/maclib,
1809 which would get here with a symbol type of ':'. */
1813 /* Unexpected symbol descriptor. The second and subsequent stabs
1814 of a continued stab can show up here. The question is
1815 whether they ever can mimic a normal stab--it would be
1816 nice if not, since we certainly don't want to spend the
1817 time searching to the end of every string looking for
1820 complaint (_("unknown symbol descriptor `%c'"),
1823 /* Ignore it; perhaps it is an extension that we don't
1831 namestring
= set_namestring (objfile
, &nlist
);
1833 /* Find the corresponding bincl and mark that psymtab on the
1834 psymtab dependency list. */
1836 legacy_psymtab
*needed_pst
=
1837 find_corresponding_bincl_psymtab (namestring
, nlist
.n_value
);
1839 /* If this include file was defined earlier in this file,
1841 if (needed_pst
== pst
)
1849 for (i
= 0; i
< dependencies_used
; i
++)
1850 if (dependency_list
[i
] == needed_pst
)
1856 /* If it's already in the list, skip the rest. */
1860 dependency_list
[dependencies_used
++] = needed_pst
;
1861 if (dependencies_used
>= dependencies_allocated
)
1863 legacy_psymtab
**orig
= dependency_list
;
1867 alloca ((dependencies_allocated
*= 2)
1868 * sizeof (legacy_psymtab
*));
1869 memcpy (dependency_list
, orig
,
1871 * sizeof (legacy_psymtab
*)));
1873 gdb_printf (gdb_stderr
,
1874 "Had to reallocate "
1875 "dependency list.\n");
1876 gdb_printf (gdb_stderr
,
1877 "New dependencies allocated: %d\n",
1878 dependencies_allocated
);
1886 /* Solaris 2 end of module, finish current partial symbol
1887 table. dbx_end_psymtab will set the high text address of
1888 PST to the proper value, which is necessary if a module
1889 compiled without debugging info follows this module. */
1890 if (pst
&& gdbarch_sofun_address_maybe_missing (gdbarch
))
1892 dbx_end_psymtab (objfile
, partial_symtabs
, pst
,
1893 psymtab_include_list
, includes_used
,
1894 symnum
* symbol_size
,
1895 (unrelocated_addr
) 0, dependency_list
,
1896 dependencies_used
, textlow_not_set
);
1897 pst
= (legacy_psymtab
*) 0;
1899 dependencies_used
= 0;
1900 has_line_numbers
= 0;
1906 HANDLE_RBRAC (nlist
.n_value
);
1912 case N_SSYM
: /* Claim: Structure or union element.
1913 Hopefully, I can ignore this. */
1914 case N_ENTRY
: /* Alternate entry point; can ignore. */
1915 case N_MAIN
: /* Can definitely ignore this. */
1916 case N_CATCH
: /* These are GNU C++ extensions */
1917 case N_EHDECL
: /* that can safely be ignored here. */
1929 case N_NSYMS
: /* Ultrix 4.0: symbol count */
1930 case N_DEFD
: /* GNU Modula-2 */
1931 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
1933 case N_OBJ
: /* Useless types from Solaris. */
1936 /* These symbols aren't interesting; don't worry about them. */
1940 /* If we haven't found it yet, ignore it. It's probably some
1941 new type we don't know about yet. */
1942 unknown_symtype_complaint (hex_string (nlist
.n_type
));
1947 /* If there's stuff to be cleaned up, clean it up. */
1950 /* Don't set high text address of PST lower than it already
1952 unrelocated_addr text_end
1954 ((lowest_text_address
== (unrelocated_addr
) -1
1956 : CORE_ADDR (lowest_text_address
))
1959 dbx_end_psymtab (objfile
, partial_symtabs
,
1960 pst
, psymtab_include_list
, includes_used
,
1961 symnum
* symbol_size
,
1962 (text_end
> pst
->unrelocated_text_high ()
1963 ? text_end
: pst
->unrelocated_text_high ()),
1964 dependency_list
, dependencies_used
, textlow_not_set
);
1968 /* Allocate and partially fill a partial symtab. It will be
1969 completely filled at the end of the symbol list.
1971 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1972 is the address relative to which its symbols are (incremental) or 0
1975 static legacy_psymtab
*
1976 start_psymtab (psymtab_storage
*partial_symtabs
, struct objfile
*objfile
,
1977 const char *filename
, unrelocated_addr textlow
, int ldsymoff
)
1979 legacy_psymtab
*result
= new legacy_psymtab (filename
, partial_symtabs
,
1980 objfile
->per_bfd
, textlow
);
1982 result
->read_symtab_private
=
1983 XOBNEW (&objfile
->objfile_obstack
, struct symloc
);
1984 LDSYMOFF (result
) = ldsymoff
;
1985 result
->legacy_read_symtab
= dbx_read_symtab
;
1986 result
->legacy_expand_psymtab
= dbx_expand_psymtab
;
1987 SYMBOL_SIZE (result
) = symbol_size
;
1988 SYMBOL_OFFSET (result
) = symbol_table_offset
;
1989 STRING_OFFSET (result
) = string_table_offset
;
1990 FILE_STRING_OFFSET (result
) = file_string_table_offset
;
1992 /* Deduce the source language from the filename for this psymtab. */
1993 psymtab_language
= deduce_language_from_filename (filename
);
1994 PST_LANGUAGE (result
) = psymtab_language
;
1999 /* Close off the current usage of PST.
2000 Returns PST or NULL if the partial symtab was empty and thrown away.
2002 FIXME: List variables and peculiarities of same. */
2005 dbx_end_psymtab (struct objfile
*objfile
, psymtab_storage
*partial_symtabs
,
2006 legacy_psymtab
*pst
,
2007 const char **include_list
, int num_includes
,
2008 int capping_symbol_offset
, unrelocated_addr capping_text
,
2009 legacy_psymtab
**dependency_list
,
2010 int number_dependencies
,
2011 int textlow_not_set
)
2014 struct gdbarch
*gdbarch
= objfile
->arch ();
2016 if (capping_symbol_offset
!= -1)
2017 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
2018 pst
->set_text_high (capping_text
);
2020 /* Under Solaris, the N_SO symbols always have a value of 0,
2021 instead of the usual address of the .o file. Therefore,
2022 we have to do some tricks to fill in texthigh and textlow.
2023 The first trick is: if we see a static
2024 or global function, and the textlow for the current pst
2025 is not set (ie: textlow_not_set), then we use that function's
2026 address for the textlow of the pst. */
2028 /* Now, to fill in texthigh, we remember the last function seen
2029 in the .o file. Also, there's a hack in
2030 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
2031 to here via the misc_info field. Therefore, we can fill in
2032 a reliable texthigh by taking the address plus size of the
2033 last function in the file. */
2035 if (!pst
->text_high_valid
&& last_function_name
2036 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2039 struct bound_minimal_symbol minsym
;
2041 const char *colon
= strchr (last_function_name
, ':');
2045 n
= colon
- last_function_name
;
2046 char *p
= (char *) alloca (n
+ 2);
2047 strncpy (p
, last_function_name
, n
);
2050 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
2051 if (minsym
.minsym
== NULL
)
2053 /* Sun Fortran appends an underscore to the minimal symbol name,
2054 try again with an appended underscore if the minimal symbol
2058 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
2063 (unrelocated_addr (CORE_ADDR (minsym
.minsym
->unrelocated_address ())
2064 + minsym
.minsym
->size ()));
2066 last_function_name
= NULL
;
2069 if (!gdbarch_sofun_address_maybe_missing (gdbarch
))
2071 /* This test will be true if the last .o file is only data. */
2072 else if (textlow_not_set
)
2073 pst
->set_text_low (pst
->unrelocated_text_high ());
2076 /* If we know our own starting text address, then walk through all other
2077 psymtabs for this objfile, and if any didn't know their ending text
2078 address, set it to our starting address. Take care to not set our
2079 own ending address to our starting address. */
2081 for (partial_symtab
*p1
: partial_symtabs
->range ())
2082 if (!p1
->text_high_valid
&& p1
->text_low_valid
&& p1
!= pst
)
2083 p1
->set_text_high (pst
->unrelocated_text_low ());
2086 /* End of kludge for patching Solaris textlow and texthigh. */
2090 pst
->number_of_dependencies
= number_dependencies
;
2091 if (number_dependencies
)
2094 = partial_symtabs
->allocate_dependencies (number_dependencies
);
2095 memcpy (pst
->dependencies
, dependency_list
,
2096 number_dependencies
* sizeof (legacy_psymtab
*));
2099 pst
->dependencies
= 0;
2101 for (i
= 0; i
< num_includes
; i
++)
2103 legacy_psymtab
*subpst
=
2104 new legacy_psymtab (include_list
[i
], partial_symtabs
, objfile
->per_bfd
);
2106 subpst
->read_symtab_private
=
2107 XOBNEW (&objfile
->objfile_obstack
, struct symloc
);
2109 LDSYMLEN (subpst
) = 0;
2111 /* We could save slight bits of space by only making one of these,
2112 shared by the entire set of include files. FIXME-someday. */
2113 subpst
->dependencies
=
2114 partial_symtabs
->allocate_dependencies (1);
2115 subpst
->dependencies
[0] = pst
;
2116 subpst
->number_of_dependencies
= 1;
2118 subpst
->legacy_read_symtab
= pst
->legacy_read_symtab
;
2119 subpst
->legacy_expand_psymtab
= pst
->legacy_expand_psymtab
;
2122 if (num_includes
== 0
2123 && number_dependencies
== 0
2125 && has_line_numbers
== 0)
2127 /* Throw away this psymtab, it's empty. */
2128 /* Empty psymtabs happen as a result of header files which don't have
2129 any symbols in them. There can be a lot of them. But this check
2130 is wrong, in that a psymtab with N_SLINE entries but nothing else
2131 is not empty, but we don't realize that. Fixing that without slowing
2132 things down might be tricky. */
2134 partial_symtabs
->discard_psymtab (pst
);
2136 /* Indicate that psymtab was thrown away. */
2143 dbx_expand_psymtab (legacy_psymtab
*pst
, struct objfile
*objfile
)
2145 gdb_assert (!pst
->readin
);
2147 /* Read in all partial symtabs on which this one is dependent. */
2148 pst
->expand_dependencies (objfile
);
2150 if (LDSYMLEN (pst
)) /* Otherwise it's a dummy. */
2152 /* Init stuff necessary for reading in symbols */
2154 scoped_free_pendings free_pending
;
2155 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
2156 symbol_size
= SYMBOL_SIZE (pst
);
2158 /* Read in this file's symbols. */
2159 if (bfd_seek (objfile
->obfd
.get (), SYMBOL_OFFSET (pst
), SEEK_SET
) == 0)
2160 read_ofile_symtab (objfile
, pst
);
2166 /* Read in all of the symbols for a given psymtab for real.
2167 Be verbose about it if the user wants that. SELF is not NULL. */
2170 dbx_read_symtab (legacy_psymtab
*self
, struct objfile
*objfile
)
2172 gdb_assert (!self
->readin
);
2174 if (LDSYMLEN (self
) || self
->number_of_dependencies
)
2176 next_symbol_text_func
= dbx_next_symbol_text
;
2179 scoped_restore restore_stabs_data
= make_scoped_restore (&stabs_data
);
2180 gdb::unique_xmalloc_ptr
<gdb_byte
> data_holder
;
2181 if (DBX_STAB_SECTION (objfile
))
2184 = symfile_relocate_debug_section (objfile
,
2185 DBX_STAB_SECTION (objfile
),
2187 data_holder
.reset (stabs_data
);
2190 self
->expand_psymtab (objfile
);
2193 /* Match with global symbols. This only needs to be done once,
2194 after all of the symtabs and dependencies have been read in. */
2195 scan_file_globals (objfile
);
2199 /* Read in a defined section of a specific object file's symbols. */
2202 read_ofile_symtab (struct objfile
*objfile
, legacy_psymtab
*pst
)
2204 const char *namestring
;
2205 struct external_nlist
*bufp
;
2206 struct internal_nlist nlist
;
2208 unsigned max_symnum
;
2210 int sym_offset
; /* Offset to start of symbols to read */
2211 int sym_size
; /* Size of symbols to read */
2212 CORE_ADDR text_offset
; /* Start of text segment for symbols */
2213 int text_size
; /* Size of text segment for symbols */
2215 sym_offset
= LDSYMOFF (pst
);
2216 sym_size
= LDSYMLEN (pst
);
2217 text_offset
= pst
->text_low (objfile
);
2218 text_size
= pst
->text_high (objfile
) - pst
->text_low (objfile
);
2219 const section_offsets
§ion_offsets
= objfile
->section_offsets
;
2221 dbxread_objfile
= objfile
;
2223 stringtab_global
= DBX_STRINGTAB (objfile
);
2224 set_last_source_file (NULL
);
2226 abfd
= objfile
->obfd
.get ();
2227 symfile_bfd
= objfile
->obfd
.get (); /* Implicit param to next_text_symbol. */
2228 symbuf_end
= symbuf_idx
= 0;
2230 symbuf_left
= sym_offset
+ sym_size
;
2232 /* It is necessary to actually read one symbol *before* the start
2233 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2234 occurs before the N_SO symbol.
2236 Detecting this in read_dbx_symtab
2237 would slow down initial readin, so we look for it here instead. */
2238 if (!processing_acc_compilation
&& sym_offset
>= (int) symbol_size
)
2240 stabs_seek (sym_offset
- symbol_size
);
2242 bufp
= &symbuf
[symbuf_idx
++];
2243 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
2244 OBJSTAT (objfile
, n_stabs
++);
2246 namestring
= set_namestring (objfile
, &nlist
);
2248 processing_gcc_compilation
= 0;
2249 if (nlist
.n_type
== N_TEXT
)
2251 const char *tempstring
= namestring
;
2253 if (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0)
2254 processing_gcc_compilation
= 1;
2255 else if (strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
2256 processing_gcc_compilation
= 2;
2257 if (*tempstring
!= '\0'
2258 && *tempstring
== bfd_get_symbol_leading_char (symfile_bfd
))
2260 if (startswith (tempstring
, "__gnu_compiled"))
2261 processing_gcc_compilation
= 2;
2266 /* The N_SO starting this symtab is the first symbol, so we
2267 better not check the symbol before it. I'm not this can
2268 happen, but it doesn't hurt to check for it. */
2269 stabs_seek (sym_offset
);
2270 processing_gcc_compilation
= 0;
2273 if (symbuf_idx
== symbuf_end
)
2275 bufp
= &symbuf
[symbuf_idx
];
2276 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
2277 error (_("First symbol in segment of executable not a source symbol"));
2279 max_symnum
= sym_size
/ symbol_size
;
2282 symnum
< max_symnum
;
2285 QUIT
; /* Allow this to be interruptable. */
2286 if (symbuf_idx
== symbuf_end
)
2288 bufp
= &symbuf
[symbuf_idx
++];
2289 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
2290 OBJSTAT (objfile
, n_stabs
++);
2292 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
2294 namestring
= set_namestring (objfile
, &nlist
);
2298 if (sizeof (nlist
.n_value
) > 4
2299 /* We are a 64-bit debugger debugging a 32-bit program. */
2300 && (type
== N_LSYM
|| type
== N_PSYM
))
2301 /* We have to be careful with the n_value in the case of N_LSYM
2302 and N_PSYM entries, because they are signed offsets from frame
2303 pointer, but we actually read them as unsigned 32-bit values.
2304 This is not a problem for 32-bit debuggers, for which negative
2305 values end up being interpreted correctly (as negative
2306 offsets) due to integer overflow.
2307 But we need to sign-extend the value for 64-bit debuggers,
2308 or we'll end up interpreting negative values as very large
2309 positive offsets. */
2310 nlist
.n_value
= (nlist
.n_value
^ 0x80000000) - 0x80000000;
2311 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
2312 namestring
, section_offsets
, objfile
,
2313 PST_LANGUAGE (pst
));
2315 /* We skip checking for a new .o or -l file; that should never
2316 happen in this routine. */
2317 else if (type
== N_TEXT
)
2319 /* I don't think this code will ever be executed, because
2320 the GCC_COMPILED_FLAG_SYMBOL usually is right before
2321 the N_SO symbol which starts this source file.
2322 However, there is no reason not to accept
2323 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
2325 if (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0)
2326 processing_gcc_compilation
= 1;
2327 else if (strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
2328 processing_gcc_compilation
= 2;
2330 else if (type
& N_EXT
|| type
== (unsigned char) N_TEXT
2331 || type
== (unsigned char) N_NBTEXT
)
2333 /* Global symbol: see if we came across a dbx definition for
2334 a corresponding symbol. If so, store the value. Remove
2335 syms from the chain when their values are stored, but
2336 search the whole chain, as there may be several syms from
2337 different files with the same name. */
2338 /* This is probably not true. Since the files will be read
2339 in one at a time, each reference to a global symbol will
2340 be satisfied in each file as it appears. So we skip this
2346 /* In a Solaris elf file, this variable, which comes from the value
2347 of the N_SO symbol, will still be 0. Luckily, text_offset, which
2348 comes from low text address of PST, is correct. */
2349 if (get_last_source_start_addr () == 0)
2350 set_last_source_start_addr (text_offset
);
2352 /* In reordered executables last_source_start_addr may not be the
2353 lower bound for this symtab, instead use text_offset which comes
2354 from the low text address of PST, which is correct. */
2355 if (get_last_source_start_addr () > text_offset
)
2356 set_last_source_start_addr (text_offset
);
2358 pst
->compunit_symtab
= end_compunit_symtab (text_offset
+ text_size
);
2362 dbxread_objfile
= NULL
;
2366 /* Record the namespace that the function defined by SYMBOL was
2367 defined in, if necessary. BLOCK is the associated block; use
2368 OBSTACK for allocation. */
2371 cp_set_block_scope (const struct symbol
*symbol
,
2372 struct block
*block
,
2373 struct obstack
*obstack
)
2375 if (symbol
->demangled_name () != NULL
)
2377 /* Try to figure out the appropriate namespace from the
2380 /* FIXME: carlton/2003-04-15: If the function in question is
2381 a method of a class, the name will actually include the
2382 name of the class as well. This should be harmless, but
2383 is a little unfortunate. */
2385 const char *name
= symbol
->demangled_name ();
2386 unsigned int prefix_len
= cp_entire_prefix_len (name
);
2388 block
->set_scope (obstack_strndup (obstack
, name
, prefix_len
),
2393 /* This handles a single symbol from the symbol-file, building symbols
2394 into a GDB symtab. It takes these arguments and an implicit argument.
2396 TYPE is the type field of the ".stab" symbol entry.
2397 DESC is the desc field of the ".stab" entry.
2398 VALU is the value field of the ".stab" entry.
2399 NAME is the symbol name, in our address space.
2400 SECTION_OFFSETS is a set of amounts by which the sections of this
2401 object file were relocated when it was loaded into memory. Note
2402 that these section_offsets are not the objfile->section_offsets but
2403 the pst->section_offsets. All symbols that refer to memory
2404 locations need to be offset by these amounts.
2405 OBJFILE is the object file from which we are reading symbols. It
2406 is used in end_compunit_symtab.
2407 LANGUAGE is the language of the symtab.
2411 process_one_symbol (int type
, int desc
, CORE_ADDR valu
, const char *name
,
2412 const section_offsets
§ion_offsets
,
2413 struct objfile
*objfile
, enum language language
)
2415 struct gdbarch
*gdbarch
= objfile
->arch ();
2416 struct context_stack
*newobj
;
2417 struct context_stack cstk
;
2418 /* This remembers the address of the start of a function. It is
2419 used because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries
2420 are relative to the current function's start address. On systems
2421 other than Solaris 2, this just holds the SECT_OFF_TEXT value,
2422 and is used to relocate these symbol types rather than
2424 static CORE_ADDR function_start_offset
;
2426 /* This holds the address of the start of a function, without the
2427 system peculiarities of function_start_offset. */
2428 static CORE_ADDR last_function_start
;
2430 /* If this is nonzero, we've seen an N_SLINE since the start of the
2431 current function. We use this to tell us to move the first sline
2432 to the beginning of the function regardless of what its given
2434 static int sline_found_in_function
= 1;
2436 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this
2437 source file. Used to detect the SunPRO solaris compiler. */
2438 static int n_opt_found
;
2440 /* The section index for this symbol. */
2441 int section_index
= -1;
2443 /* Something is wrong if we see real data before seeing a source
2446 if (get_last_source_file () == NULL
&& type
!= (unsigned char) N_SO
)
2448 /* Ignore any symbols which appear before an N_SO symbol.
2449 Currently no one puts symbols there, but we should deal
2450 gracefully with the case. A complain()t might be in order,
2451 but this should not be an error (). */
2460 if (*name
== '\000')
2462 /* This N_FUN marks the end of a function. This closes off
2463 the current block. */
2464 struct block
*block
;
2466 if (outermost_context_p ())
2468 lbrac_mismatch_complaint (symnum
);
2472 /* The following check is added before recording line 0 at
2473 end of function so as to handle hand-generated stabs
2474 which may have an N_FUN stabs at the end of the function,
2475 but no N_SLINE stabs. */
2476 if (sline_found_in_function
)
2478 CORE_ADDR addr
= last_function_start
+ valu
;
2481 (get_current_subfile (), 0,
2482 unrelocated_addr (gdbarch_addr_bits_remove (gdbarch
, addr
)
2483 - objfile
->text_section_offset ()));
2486 within_function
= 0;
2487 cstk
= pop_context ();
2489 /* Make a block for the local symbols within. */
2490 block
= finish_block (cstk
.name
,
2491 cstk
.old_blocks
, NULL
,
2492 cstk
.start_addr
, cstk
.start_addr
+ valu
);
2494 /* For C++, set the block's scope. */
2495 if (cstk
.name
->language () == language_cplus
)
2496 cp_set_block_scope (cstk
.name
, block
, &objfile
->objfile_obstack
);
2498 /* May be switching to an assembler file which may not be using
2499 block relative stabs, so reset the offset. */
2500 function_start_offset
= 0;
2505 sline_found_in_function
= 0;
2507 /* Relocate for dynamic loading. */
2508 section_index
= SECT_OFF_TEXT (objfile
);
2509 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2510 valu
= gdbarch_addr_bits_remove (gdbarch
, valu
);
2511 last_function_start
= valu
;
2513 goto define_a_symbol
;
2516 /* This "symbol" just indicates the start of an inner lexical
2517 context within a function. */
2519 /* Ignore extra outermost context from SunPRO cc and acc. */
2520 if (n_opt_found
&& desc
== 1)
2523 valu
+= function_start_offset
;
2525 push_context (desc
, valu
);
2529 /* This "symbol" just indicates the end of an inner lexical
2530 context that was started with N_LBRAC. */
2532 /* Ignore extra outermost context from SunPRO cc and acc. */
2533 if (n_opt_found
&& desc
== 1)
2536 valu
+= function_start_offset
;
2538 if (outermost_context_p ())
2540 lbrac_mismatch_complaint (symnum
);
2544 cstk
= pop_context ();
2545 if (desc
!= cstk
.depth
)
2546 lbrac_mismatch_complaint (symnum
);
2548 if (*get_local_symbols () != NULL
)
2550 /* GCC development snapshots from March to December of
2551 2000 would output N_LSYM entries after N_LBRAC
2552 entries. As a consequence, these symbols are simply
2553 discarded. Complain if this is the case. */
2554 complaint (_("misplaced N_LBRAC entry; discarding local "
2555 "symbols which have no enclosing block"));
2557 *get_local_symbols () = cstk
.locals
;
2559 if (get_context_stack_depth () > 1)
2561 /* This is not the outermost LBRAC...RBRAC pair in the
2562 function, its local symbols preceded it, and are the ones
2563 just recovered from the context stack. Define the block
2564 for them (but don't bother if the block contains no
2565 symbols. Should we complain on blocks without symbols?
2566 I can't think of any useful purpose for them). */
2567 if (*get_local_symbols () != NULL
)
2569 /* Muzzle a compiler bug that makes end < start.
2571 ??? Which compilers? Is this ever harmful?. */
2572 if (cstk
.start_addr
> valu
)
2574 complaint (_("block start larger than block end"));
2575 cstk
.start_addr
= valu
;
2577 /* Make a block for the local symbols within. */
2578 finish_block (0, cstk
.old_blocks
, NULL
,
2579 cstk
.start_addr
, valu
);
2584 /* This is the outermost LBRAC...RBRAC pair. There is no
2585 need to do anything; leave the symbols that preceded it
2586 to be attached to the function's own block. We need to
2587 indicate that we just moved outside of the function. */
2588 within_function
= 0;
2595 /* This kind of symbol indicates the start of an object file.
2596 Relocate for dynamic loading. */
2597 section_index
= SECT_OFF_TEXT (objfile
);
2598 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2602 /* This type of symbol indicates the start of data for one
2603 source file. Finish the symbol table of the previous source
2604 file (if any) and start accumulating a new symbol table.
2605 Relocate for dynamic loading. */
2606 section_index
= SECT_OFF_TEXT (objfile
);
2607 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2611 if (get_last_source_file ())
2613 /* Check if previous symbol was also an N_SO (with some
2614 sanity checks). If so, that one was actually the
2615 directory name, and the current one is the real file
2616 name. Patch things up. */
2617 if (previous_stab_code
== (unsigned char) N_SO
)
2619 patch_subfile_names (get_current_subfile (), name
);
2620 break; /* Ignore repeated SOs. */
2622 end_compunit_symtab (valu
);
2626 /* Null name means this just marks the end of text for this .o
2627 file. Don't start a new symtab in this case. */
2628 if (*name
== '\000')
2631 function_start_offset
= 0;
2634 start_compunit_symtab (objfile
, name
, NULL
, valu
, language
);
2635 record_debugformat ("stabs");
2639 /* This type of symbol indicates the start of data for a
2640 sub-source-file, one whose contents were copied or included
2641 in the compilation of the main source file (whose name was
2642 given in the N_SO symbol). Relocate for dynamic loading. */
2643 section_index
= SECT_OFF_TEXT (objfile
);
2644 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2645 start_subfile (name
);
2650 add_new_header_file (name
, valu
);
2651 start_subfile (name
);
2655 start_subfile (pop_subfile ());
2659 add_old_header_file (name
, valu
);
2663 /* This type of "symbol" really just records one line-number --
2664 core-address correspondence. Enter it in the line list for
2665 this symbol table. */
2667 /* Relocate for dynamic loading and for ELF acc
2668 function-relative symbols. */
2669 valu
+= function_start_offset
;
2671 /* GCC 2.95.3 emits the first N_SLINE stab somewhere in the
2672 middle of the prologue instead of right at the start of the
2673 function. To deal with this we record the address for the
2674 first N_SLINE stab to be the start of the function instead of
2675 the listed location. We really shouldn't to this. When
2676 compiling with optimization, this first N_SLINE stab might be
2677 optimized away. Other (non-GCC) compilers don't emit this
2678 stab at all. There is no real harm in having an extra
2679 numbered line, although it can be a bit annoying for the
2680 user. However, it totally screws up our testsuite.
2682 So for now, keep adjusting the address of the first N_SLINE
2683 stab, but only for code compiled with GCC. */
2685 if (within_function
&& sline_found_in_function
== 0)
2687 CORE_ADDR addr
= processing_gcc_compilation
== 2 ?
2688 last_function_start
: valu
;
2691 (get_current_subfile (), desc
,
2692 unrelocated_addr (gdbarch_addr_bits_remove (gdbarch
, addr
)
2693 - objfile
->text_section_offset ()));
2694 sline_found_in_function
= 1;
2698 (get_current_subfile (), desc
,
2699 unrelocated_addr (gdbarch_addr_bits_remove (gdbarch
, valu
)
2700 - objfile
->text_section_offset ()));
2704 common_block_start (name
, objfile
);
2708 common_block_end (objfile
);
2711 /* The following symbol types need to have the appropriate
2712 offset added to their value; then we process symbol
2713 definitions in the name. */
2715 case N_STSYM
: /* Static symbol in data segment. */
2716 case N_LCSYM
: /* Static symbol in BSS segment. */
2717 case N_ROSYM
: /* Static symbol in read-only data segment. */
2718 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2719 Solaris 2's stabs-in-elf makes *most* symbols relative but
2720 leaves a few absolute (at least for Solaris 2.1 and version
2721 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on
2722 the fence. .stab "foo:S...",N_STSYM is absolute (ld
2723 relocates it) .stab "foo:V...",N_STSYM is relative (section
2724 base subtracted). This leaves us no choice but to search for
2725 the 'S' or 'V'... (or pass the whole section_offsets stuff
2726 down ONE MORE function call level, which we really don't want
2731 /* Normal object file and NLMs have non-zero text seg offsets,
2732 but don't need their static syms offset in this fashion.
2733 XXX - This is really a crock that should be fixed in the
2734 solib handling code so that I don't have to work around it
2737 if (!symfile_relocatable
)
2739 p
= strchr (name
, ':');
2740 if (p
!= 0 && p
[1] == 'S')
2742 /* The linker relocated it. We don't want to add a
2743 Sun-stabs Tfoo.foo-like offset, but we *do*
2744 want to add whatever solib.c passed to
2745 symbol_file_add as addr (this is known to affect
2746 SunOS 4, and I suspect ELF too). Since there is no
2747 Ttext.text symbol, we can get addr from the text offset. */
2748 section_index
= SECT_OFF_TEXT (objfile
);
2749 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2750 goto define_a_symbol
;
2753 /* Since it's not the kludge case, re-dispatch to the right
2764 internal_error (_("failed internal consistency check"));
2768 case_N_STSYM
: /* Static symbol in data segment. */
2769 case N_DSLINE
: /* Source line number, data segment. */
2770 section_index
= SECT_OFF_DATA (objfile
);
2771 valu
+= section_offsets
[SECT_OFF_DATA (objfile
)];
2772 goto define_a_symbol
;
2774 case_N_LCSYM
: /* Static symbol in BSS segment. */
2775 case N_BSLINE
: /* Source line number, BSS segment. */
2776 /* N_BROWS: overlaps with N_BSLINE. */
2777 section_index
= SECT_OFF_BSS (objfile
);
2778 valu
+= section_offsets
[SECT_OFF_BSS (objfile
)];
2779 goto define_a_symbol
;
2781 case_N_ROSYM
: /* Static symbol in read-only data segment. */
2782 section_index
= SECT_OFF_RODATA (objfile
);
2783 valu
+= section_offsets
[SECT_OFF_RODATA (objfile
)];
2784 goto define_a_symbol
;
2786 case N_ENTRY
: /* Alternate entry point. */
2787 /* Relocate for dynamic loading. */
2788 section_index
= SECT_OFF_TEXT (objfile
);
2789 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
2790 goto define_a_symbol
;
2792 /* The following symbol types we don't know how to process.
2793 Handle them in a "default" way, but complain to people who
2796 case N_CATCH
: /* Exception handler catcher. */
2797 case N_EHDECL
: /* Exception handler name. */
2798 case N_PC
: /* Global symbol in Pascal. */
2799 case N_M2C
: /* Modula-2 compilation unit. */
2800 /* N_MOD2: overlaps with N_EHDECL. */
2801 case N_SCOPE
: /* Modula-2 scope information. */
2802 case N_ECOML
: /* End common (local name). */
2803 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2808 unknown_symtype_complaint (hex_string (type
));
2812 /* These symbol types don't need the address field relocated,
2813 since it is either unused, or is absolute. */
2814 case N_GSYM
: /* Global variable. */
2815 case N_NSYMS
: /* Number of symbols (Ultrix). */
2816 case N_NOMAP
: /* No map? (Ultrix). */
2817 case N_RSYM
: /* Register variable. */
2818 case N_DEFD
: /* Modula-2 GNU module dependency. */
2819 case N_SSYM
: /* Struct or union element. */
2820 case N_LSYM
: /* Local symbol in stack. */
2821 case N_PSYM
: /* Parameter variable. */
2822 case N_LENG
: /* Length of preceding symbol type. */
2826 const char *colon_pos
= strchr (name
, ':');
2828 if (colon_pos
== NULL
)
2831 deftype
= colon_pos
[1];
2837 /* Deal with the SunPRO 3.0 compiler which omits the
2838 address from N_FUN symbols. */
2840 && valu
== section_offsets
[SECT_OFF_TEXT (objfile
)]
2841 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2843 struct bound_minimal_symbol minsym
2844 = find_stab_function (name
, get_last_source_file (),
2846 if (minsym
.minsym
!= NULL
)
2847 valu
= minsym
.value_address ();
2850 /* These addresses are absolute. */
2851 function_start_offset
= valu
;
2853 within_function
= 1;
2855 if (get_context_stack_depth () > 1)
2857 complaint (_("unmatched N_LBRAC before symtab pos %d"),
2862 if (!outermost_context_p ())
2864 struct block
*block
;
2866 cstk
= pop_context ();
2867 /* Make a block for the local symbols within. */
2868 block
= finish_block (cstk
.name
,
2869 cstk
.old_blocks
, NULL
,
2870 cstk
.start_addr
, valu
);
2872 /* For C++, set the block's scope. */
2873 if (cstk
.name
->language () == language_cplus
)
2874 cp_set_block_scope (cstk
.name
, block
,
2875 &objfile
->objfile_obstack
);
2878 newobj
= push_context (0, valu
);
2879 newobj
->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2880 if (newobj
->name
!= nullptr)
2881 newobj
->name
->set_section_index (section_index
);
2886 struct symbol
*sym
= define_symbol (valu
, name
, desc
, type
,
2889 sym
->set_section_index (section_index
);
2896 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2897 for a bunch of other flags, too. Someday we may parse their
2898 flags; for now we ignore theirs and hope they'll ignore ours. */
2899 case N_OPT
: /* Solaris 2: Compiler options. */
2902 if (strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
2904 processing_gcc_compilation
= 2;
2911 case N_MAIN
: /* Name of main routine. */
2912 /* FIXME: If one has a symbol file with N_MAIN and then replaces
2913 it with a symbol file with "main" and without N_MAIN. I'm
2914 not sure exactly what rule to follow but probably something
2915 like: N_MAIN takes precedence over "main" no matter what
2916 objfile it is in; If there is more than one N_MAIN, choose
2917 the one in the symfile_objfile; If there is more than one
2918 N_MAIN within a given objfile, complain() and choose
2919 arbitrarily. (kingdon) */
2921 set_objfile_main_name (objfile
, name
, language_unknown
);
2924 /* The following symbol types can be ignored. */
2925 case N_OBJ
: /* Solaris 2: Object file dir and name. */
2926 case N_PATCH
: /* Solaris 2: Patch Run Time Checker. */
2927 /* N_UNDF: Solaris 2: File separator mark. */
2928 /* N_UNDF: -- we will never encounter it, since we only process
2929 one file's symbols at once. */
2930 case N_ENDM
: /* Solaris 2: End of module. */
2931 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2935 /* '#' is a GNU C extension to allow one symbol to refer to another
2938 Generally this is used so that an alias can refer to its main
2943 /* Initialize symbol reference names and determine if this is a
2944 definition. If a symbol reference is being defined, go ahead
2945 and add it. Otherwise, just return. */
2947 const char *s
= name
;
2950 /* If this stab defines a new reference ID that is not on the
2951 reference list, then put it on the reference list.
2953 We go ahead and advance NAME past the reference, even though
2954 it is not strictly necessary at this time. */
2955 refnum
= symbol_reference_defined (&s
);
2957 if (!ref_search (refnum
))
2958 ref_add (refnum
, 0, name
, valu
);
2962 previous_stab_code
= type
;
2965 /* FIXME: The only difference between this and elfstab_build_psymtabs
2966 is the call to install_minimal_symbols for elf, and the support for
2967 split sections. If the differences are really that small, the code
2968 should be shared. */
2970 /* Scan and build partial symbols for an coff symbol file.
2971 The coff file has already been processed to get its minimal symbols.
2973 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2976 OBJFILE is the object file we are reading symbols from.
2977 ADDR is the address relative to which the symbols are (e.g.
2978 the base address of the text segment).
2979 TEXTADDR is the address of the text section.
2980 TEXTSIZE is the size of the text section.
2981 STABSECTS is the list of .stab sections in OBJFILE.
2982 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2983 .stabstr section exists.
2985 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2986 adjusted for coff details. */
2989 coffstab_build_psymtabs (struct objfile
*objfile
,
2990 CORE_ADDR textaddr
, unsigned int textsize
,
2991 const std::vector
<asection
*> &stabsects
,
2992 file_ptr stabstroffset
, unsigned int stabstrsize
)
2995 bfd
*sym_bfd
= objfile
->obfd
.get ();
2996 const char *name
= bfd_get_filename (sym_bfd
);
2997 unsigned int stabsize
;
2999 /* Allocate struct to keep track of stab reading. */
3000 dbx_objfile_data_key
.emplace (objfile
);
3002 DBX_TEXT_ADDR (objfile
) = textaddr
;
3003 DBX_TEXT_SIZE (objfile
) = textsize
;
3005 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
3006 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
3007 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
3009 if (stabstrsize
> bfd_get_size (sym_bfd
))
3010 error (_("ridiculous string table size: %d bytes"), stabstrsize
);
3011 DBX_STRINGTAB (objfile
) = (char *)
3012 obstack_alloc (&objfile
->objfile_obstack
, stabstrsize
+ 1);
3013 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
3015 /* Now read in the string table in one big gulp. */
3017 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
3019 perror_with_name (name
);
3020 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, sym_bfd
);
3021 if (val
!= stabstrsize
)
3022 perror_with_name (name
);
3024 stabsread_new_init ();
3025 free_header_files ();
3026 init_header_files ();
3028 processing_acc_compilation
= 1;
3030 /* In a coff file, we've already installed the minimal symbols that came
3031 from the coff (non-stab) symbol table, so always act like an
3032 incremental load here. */
3033 scoped_restore save_symbuf_sections
3034 = make_scoped_restore (&symbuf_sections
);
3035 if (stabsects
.size () == 1)
3037 stabsize
= bfd_section_size (stabsects
[0]);
3038 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
3039 DBX_SYMTAB_OFFSET (objfile
) = stabsects
[0]->filepos
;
3043 DBX_SYMCOUNT (objfile
) = 0;
3044 for (asection
*section
: stabsects
)
3046 stabsize
= bfd_section_size (section
);
3047 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
3050 DBX_SYMTAB_OFFSET (objfile
) = stabsects
[0]->filepos
;
3053 symbuf_sections
= &stabsects
;
3054 symbuf_left
= bfd_section_size (stabsects
[0]);
3058 dbx_symfile_read (objfile
, 0);
3061 /* Scan and build partial symbols for an ELF symbol file.
3062 This ELF file has already been processed to get its minimal symbols.
3064 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3067 OBJFILE is the object file we are reading symbols from.
3068 ADDR is the address relative to which the symbols are (e.g.
3069 the base address of the text segment).
3070 STABSECT is the BFD section information for the .stab section.
3071 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
3072 .stabstr section exists.
3074 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
3075 adjusted for elf details. */
3078 elfstab_build_psymtabs (struct objfile
*objfile
, asection
*stabsect
,
3079 file_ptr stabstroffset
, unsigned int stabstrsize
)
3082 bfd
*sym_bfd
= objfile
->obfd
.get ();
3083 const char *name
= bfd_get_filename (sym_bfd
);
3085 stabsread_new_init ();
3087 /* Allocate struct to keep track of stab reading. */
3088 dbx_objfile_data_key
.emplace (objfile
);
3090 /* Find the first and last text address. dbx_symfile_read seems to
3092 find_text_range (sym_bfd
, objfile
);
3094 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
3095 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
3096 DBX_SYMCOUNT (objfile
)
3097 = bfd_section_size (stabsect
) / DBX_SYMBOL_SIZE (objfile
);
3098 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
3099 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
;
3100 DBX_STAB_SECTION (objfile
) = stabsect
;
3102 if (stabstrsize
> bfd_get_size (sym_bfd
))
3103 error (_("ridiculous string table size: %d bytes"), stabstrsize
);
3104 DBX_STRINGTAB (objfile
) = (char *)
3105 obstack_alloc (&objfile
->objfile_obstack
, stabstrsize
+ 1);
3106 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
3108 /* Now read in the string table in one big gulp. */
3110 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
3112 perror_with_name (name
);
3113 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, sym_bfd
);
3114 if (val
!= stabstrsize
)
3115 perror_with_name (name
);
3117 stabsread_new_init ();
3118 free_header_files ();
3119 init_header_files ();
3121 processing_acc_compilation
= 1;
3124 symbuf_left
= bfd_section_size (stabsect
);
3126 scoped_restore restore_stabs_data
= make_scoped_restore (&stabs_data
);
3127 gdb::unique_xmalloc_ptr
<gdb_byte
> data_holder
;
3129 stabs_data
= symfile_relocate_debug_section (objfile
, stabsect
, NULL
);
3131 data_holder
.reset (stabs_data
);
3133 /* In an elf file, we've already installed the minimal symbols that came
3134 from the elf (non-stab) symbol table, so always act like an
3135 incremental load here. dbx_symfile_read should not generate any new
3136 minimal symbols, since we will have already read the ELF dynamic symbol
3137 table and normal symbol entries won't be in the ".stab" section; but in
3138 case it does, it will install them itself. */
3139 dbx_symfile_read (objfile
, 0);
3142 /* Scan and build partial symbols for a file with special sections for stabs
3143 and stabstrings. The file has already been processed to get its minimal
3144 symbols, and any other symbols that might be necessary to resolve GSYMs.
3146 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3149 OBJFILE is the object file we are reading symbols from.
3150 ADDR is the address relative to which the symbols are (e.g. the base address
3151 of the text segment).
3152 STAB_NAME is the name of the section that contains the stabs.
3153 STABSTR_NAME is the name of the section that contains the stab strings.
3155 This routine is mostly copied from dbx_symfile_init and
3156 dbx_symfile_read. */
3159 stabsect_build_psymtabs (struct objfile
*objfile
, char *stab_name
,
3160 char *stabstr_name
, char *text_name
)
3163 bfd
*sym_bfd
= objfile
->obfd
.get ();
3164 const char *name
= bfd_get_filename (sym_bfd
);
3166 asection
*stabstrsect
;
3167 asection
*text_sect
;
3169 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
3170 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
3176 error (_("stabsect_build_psymtabs: Found stabs (%s), "
3177 "but not string section (%s)"),
3178 stab_name
, stabstr_name
);
3180 dbx_objfile_data_key
.emplace (objfile
);
3182 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
3184 error (_("Can't find %s section in symbol file"), text_name
);
3185 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (text_sect
);
3186 DBX_TEXT_SIZE (objfile
) = bfd_section_size (text_sect
);
3188 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
3189 DBX_SYMCOUNT (objfile
) = bfd_section_size (stabsect
)
3190 / DBX_SYMBOL_SIZE (objfile
);
3191 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (stabstrsect
);
3192 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING
3196 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
3197 error (_("ridiculous string table size: %d bytes"),
3198 DBX_STRINGTAB_SIZE (objfile
));
3199 DBX_STRINGTAB (objfile
) = (char *)
3200 obstack_alloc (&objfile
->objfile_obstack
,
3201 DBX_STRINGTAB_SIZE (objfile
) + 1);
3202 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
3204 /* Now read in the string table in one big gulp. */
3206 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
3207 stabstrsect
, /* bfd section */
3208 DBX_STRINGTAB (objfile
), /* input buffer */
3209 0, /* offset into section */
3210 DBX_STRINGTAB_SIZE (objfile
)); /* amount to
3214 perror_with_name (name
);
3216 stabsread_new_init ();
3217 free_header_files ();
3218 init_header_files ();
3220 /* Now, do an incremental load. */
3222 processing_acc_compilation
= 1;
3223 dbx_symfile_read (objfile
, 0);
3226 static const struct sym_fns aout_sym_fns
=
3228 dbx_new_init
, /* init anything gbl to entire symtab */
3229 dbx_symfile_init
, /* read initial info, setup for sym_read() */
3230 dbx_symfile_read
, /* read a symbol file into symtab */
3231 dbx_symfile_finish
, /* finished with file, cleanup */
3232 default_symfile_offsets
, /* parse user's offsets to internal form */
3233 default_symfile_segments
, /* Get segment information from a file. */
3235 default_symfile_relocate
, /* Relocate a debug section. */
3236 NULL
, /* sym_probe_fns */
3239 void _initialize_dbxread ();
3241 _initialize_dbxread ()
3243 add_symtab_fns (bfd_target_aout_flavour
, &aout_sym_fns
);