Remove some unneeded psymtab initializations
[deliverable/binutils-gdb.git] / gdb / dbxread.c
1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1986-2019 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
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
23 from a file.
24
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 */
32
33 #include "defs.h"
34 #if defined(__CYGNUSCLIB__)
35 #include <sys/types.h>
36 #include <fcntl.h>
37 #endif
38
39 #include "gdb_obstack.h"
40 #include <sys/stat.h>
41 #include "symtab.h"
42 #include "breakpoint.h"
43 #include "target.h"
44 #include "gdbcore.h" /* for bfd stuff */
45 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
46 #include "filenames.h"
47 #include "objfiles.h"
48 #include "buildsym-legacy.h"
49 #include "stabsread.h"
50 #include "gdb-stabs.h"
51 #include "demangle.h"
52 #include "complaints.h"
53 #include "cp-abi.h"
54 #include "cp-support.h"
55 #include "psympriv.h"
56 #include "block.h"
57 #include "aout/aout64.h"
58 #include "aout/stab_gnu.h" /* We always use GNU stabs, not
59 native, now. */
60 \f
61
62 /* Key for dbx-associated data. */
63
64 const struct objfile_data *dbx_objfile_data_key;
65
66 /* We put a pointer to this structure in the read_symtab_private field
67 of the psymtab. */
68
69 struct symloc
70 {
71 /* Offset within the file symbol table of first local symbol for this
72 file. */
73
74 int ldsymoff;
75
76 /* Length (in bytes) of the section of the symbol table devoted to
77 this file's symbols (actually, the section bracketed may contain
78 more than just this file's symbols). If ldsymlen is 0, the only
79 reason for this thing's existence is the dependency list. Nothing
80 else will happen when it is read in. */
81
82 int ldsymlen;
83
84 /* The size of each symbol in the symbol file (in external form). */
85
86 int symbol_size;
87
88 /* Further information needed to locate the symbols if they are in
89 an ELF file. */
90
91 int symbol_offset;
92 int string_offset;
93 int file_string_offset;
94 enum language pst_language;
95 };
96
97 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
98 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
99 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
100 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
101 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
102 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
103 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
104 #define PST_LANGUAGE(p) (SYMLOC(p)->pst_language)
105 \f
106
107 /* The objfile we are currently reading. */
108
109 static struct objfile *dbxread_objfile;
110
111 /* Remember what we deduced to be the source language of this psymtab. */
112
113 static enum language psymtab_language = language_unknown;
114
115 /* The BFD for this file -- implicit parameter to next_symbol_text. */
116
117 static bfd *symfile_bfd;
118
119 /* The size of each symbol in the symbol file (in external form).
120 This is set by dbx_symfile_read when building psymtabs, and by
121 dbx_psymtab_to_symtab when building symtabs. */
122
123 static unsigned symbol_size;
124
125 /* This is the offset of the symbol table in the executable file. */
126
127 static unsigned symbol_table_offset;
128
129 /* This is the offset of the string table in the executable file. */
130
131 static unsigned string_table_offset;
132
133 /* For elf+stab executables, the n_strx field is not a simple index
134 into the string table. Instead, each .o file has a base offset in
135 the string table, and the associated symbols contain offsets from
136 this base. The following two variables contain the base offset for
137 the current and next .o files. */
138
139 static unsigned int file_string_table_offset;
140 static unsigned int next_file_string_table_offset;
141
142 /* .o and NLM files contain unrelocated addresses which are based at
143 0. When non-zero, this flag disables some of the special cases for
144 Solaris elf+stab text addresses at location 0. */
145
146 static int symfile_relocatable = 0;
147
148 /* When set, we are processing a .o file compiled by sun acc. This is
149 misnamed; it refers to all stabs-in-elf implementations which use
150 N_UNDF the way Sun does, including Solaris gcc. Hopefully all
151 stabs-in-elf implementations ever invented will choose to be
152 compatible. */
153
154 static unsigned char processing_acc_compilation;
155
156 \f
157 /* The lowest text address we have yet encountered. This is needed
158 because in an a.out file, there is no header field which tells us
159 what address the program is actually going to be loaded at, so we
160 need to make guesses based on the symbols (which *are* relocated to
161 reflect the address it will be loaded at). */
162
163 static CORE_ADDR lowest_text_address;
164
165 /* Non-zero if there is any line number info in the objfile. Prevents
166 dbx_end_psymtab from discarding an otherwise empty psymtab. */
167
168 static int has_line_numbers;
169
170 /* Complaints about the symbols we have encountered. */
171
172 static void
173 unknown_symtype_complaint (const char *arg1)
174 {
175 complaint (_("unknown symbol type %s"), arg1);
176 }
177
178 static void
179 lbrac_mismatch_complaint (int arg1)
180 {
181 complaint (_("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
182 }
183
184 static void
185 repeated_header_complaint (const char *arg1, int arg2)
186 {
187 complaint (_("\"repeated\" header file %s not "
188 "previously seen, at symtab pos %d"),
189 arg1, arg2);
190 }
191
192 /* find_text_range --- find start and end of loadable code sections
193
194 The find_text_range function finds the shortest address range that
195 encloses all sections containing executable code, and stores it in
196 objfile's text_addr and text_size members.
197
198 dbx_symfile_read will use this to finish off the partial symbol
199 table, in some cases. */
200
201 static void
202 find_text_range (bfd * sym_bfd, struct objfile *objfile)
203 {
204 asection *sec;
205 int found_any = 0;
206 CORE_ADDR start = 0;
207 CORE_ADDR end = 0;
208
209 for (sec = sym_bfd->sections; sec; sec = sec->next)
210 if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
211 {
212 CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
213 CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
214
215 if (found_any)
216 {
217 if (sec_start < start)
218 start = sec_start;
219 if (sec_end > end)
220 end = sec_end;
221 }
222 else
223 {
224 start = sec_start;
225 end = sec_end;
226 }
227
228 found_any = 1;
229 }
230
231 if (!found_any)
232 error (_("Can't find any code sections in symbol file"));
233
234 DBX_TEXT_ADDR (objfile) = start;
235 DBX_TEXT_SIZE (objfile) = end - start;
236 }
237 \f
238
239
240 /* During initial symbol readin, we need to have a structure to keep
241 track of which psymtabs have which bincls in them. This structure
242 is used during readin to setup the list of dependencies within each
243 partial symbol table. */
244
245 struct header_file_location
246 {
247 header_file_location (const char *name_, int instance_,
248 struct partial_symtab *pst_)
249 : name (name_),
250 instance (instance_),
251 pst (pst_)
252 {
253 }
254
255 const char *name; /* Name of header file */
256 int instance; /* See above */
257 struct partial_symtab *pst; /* Partial symtab that has the
258 BINCL/EINCL defs for this file. */
259 };
260
261 /* The list of bincls. */
262 static std::vector<struct header_file_location> *bincl_list;
263
264 /* Local function prototypes. */
265
266 static void read_ofile_symtab (struct objfile *, struct partial_symtab *);
267
268 static void dbx_read_symtab (struct partial_symtab *self,
269 struct objfile *objfile);
270
271 static void dbx_psymtab_to_symtab_1 (struct objfile *, struct partial_symtab *);
272
273 static void read_dbx_symtab (minimal_symbol_reader &, struct objfile *);
274
275 static struct partial_symtab *find_corresponding_bincl_psymtab (const char *,
276 int);
277
278 static const char *dbx_next_symbol_text (struct objfile *);
279
280 static void fill_symbuf (bfd *);
281
282 static void dbx_symfile_init (struct objfile *);
283
284 static void dbx_new_init (struct objfile *);
285
286 static void dbx_symfile_read (struct objfile *, symfile_add_flags);
287
288 static void dbx_symfile_finish (struct objfile *);
289
290 static void record_minimal_symbol (minimal_symbol_reader &,
291 const char *, CORE_ADDR, int,
292 struct objfile *);
293
294 static void add_new_header_file (const char *, int);
295
296 static void add_old_header_file (const char *, int);
297
298 static void add_this_object_header_file (int);
299
300 static struct partial_symtab *start_psymtab (struct objfile *, const char *,
301 CORE_ADDR, int,
302 std::vector<partial_symbol *> &,
303 std::vector<partial_symbol *> &);
304
305 /* Free up old header file tables. */
306
307 void
308 free_header_files (void)
309 {
310 if (this_object_header_files)
311 {
312 xfree (this_object_header_files);
313 this_object_header_files = NULL;
314 }
315 n_allocated_this_object_header_files = 0;
316 }
317
318 /* Allocate new header file tables. */
319
320 void
321 init_header_files (void)
322 {
323 n_allocated_this_object_header_files = 10;
324 this_object_header_files = XNEWVEC (int, 10);
325 }
326
327 /* Add header file number I for this object file
328 at the next successive FILENUM. */
329
330 static void
331 add_this_object_header_file (int i)
332 {
333 if (n_this_object_header_files == n_allocated_this_object_header_files)
334 {
335 n_allocated_this_object_header_files *= 2;
336 this_object_header_files
337 = (int *) xrealloc ((char *) this_object_header_files,
338 n_allocated_this_object_header_files * sizeof (int));
339 }
340
341 this_object_header_files[n_this_object_header_files++] = i;
342 }
343
344 /* Add to this file an "old" header file, one already seen in
345 a previous object file. NAME is the header file's name.
346 INSTANCE is its instance code, to select among multiple
347 symbol tables for the same header file. */
348
349 static void
350 add_old_header_file (const char *name, int instance)
351 {
352 struct header_file *p = HEADER_FILES (dbxread_objfile);
353 int i;
354
355 for (i = 0; i < N_HEADER_FILES (dbxread_objfile); i++)
356 if (filename_cmp (p[i].name, name) == 0 && instance == p[i].instance)
357 {
358 add_this_object_header_file (i);
359 return;
360 }
361 repeated_header_complaint (name, symnum);
362 }
363
364 /* Add to this file a "new" header file: definitions for its types follow.
365 NAME is the header file's name.
366 Most often this happens only once for each distinct header file,
367 but not necessarily. If it happens more than once, INSTANCE has
368 a different value each time, and references to the header file
369 use INSTANCE values to select among them.
370
371 dbx output contains "begin" and "end" markers for each new header file,
372 but at this level we just need to know which files there have been;
373 so we record the file when its "begin" is seen and ignore the "end". */
374
375 static void
376 add_new_header_file (const char *name, int instance)
377 {
378 int i;
379 struct header_file *hfile;
380
381 /* Make sure there is room for one more header file. */
382
383 i = N_ALLOCATED_HEADER_FILES (dbxread_objfile);
384
385 if (N_HEADER_FILES (dbxread_objfile) == i)
386 {
387 if (i == 0)
388 {
389 N_ALLOCATED_HEADER_FILES (dbxread_objfile) = 10;
390 HEADER_FILES (dbxread_objfile) = (struct header_file *)
391 xmalloc (10 * sizeof (struct header_file));
392 }
393 else
394 {
395 i *= 2;
396 N_ALLOCATED_HEADER_FILES (dbxread_objfile) = i;
397 HEADER_FILES (dbxread_objfile) = (struct header_file *)
398 xrealloc ((char *) HEADER_FILES (dbxread_objfile),
399 (i * sizeof (struct header_file)));
400 }
401 }
402
403 /* Create an entry for this header file. */
404
405 i = N_HEADER_FILES (dbxread_objfile)++;
406 hfile = HEADER_FILES (dbxread_objfile) + i;
407 hfile->name = xstrdup (name);
408 hfile->instance = instance;
409 hfile->length = 10;
410 hfile->vector = XCNEWVEC (struct type *, 10);
411
412 add_this_object_header_file (i);
413 }
414
415 #if 0
416 static struct type **
417 explicit_lookup_type (int real_filenum, int index)
418 {
419 struct header_file *f = &HEADER_FILES (dbxread_objfile)[real_filenum];
420
421 if (index >= f->length)
422 {
423 f->length *= 2;
424 f->vector = (struct type **)
425 xrealloc (f->vector, f->length * sizeof (struct type *));
426 memset (&f->vector[f->length / 2],
427 '\0', f->length * sizeof (struct type *) / 2);
428 }
429 return &f->vector[index];
430 }
431 #endif
432 \f
433 static void
434 record_minimal_symbol (minimal_symbol_reader &reader,
435 const char *name, CORE_ADDR address, int type,
436 struct objfile *objfile)
437 {
438 enum minimal_symbol_type ms_type;
439 int section;
440
441 switch (type)
442 {
443 case N_TEXT | N_EXT:
444 ms_type = mst_text;
445 section = SECT_OFF_TEXT (objfile);
446 break;
447 case N_DATA | N_EXT:
448 ms_type = mst_data;
449 section = SECT_OFF_DATA (objfile);
450 break;
451 case N_BSS | N_EXT:
452 ms_type = mst_bss;
453 section = SECT_OFF_BSS (objfile);
454 break;
455 case N_ABS | N_EXT:
456 ms_type = mst_abs;
457 section = -1;
458 break;
459 #ifdef N_SETV
460 case N_SETV | N_EXT:
461 ms_type = mst_data;
462 section = SECT_OFF_DATA (objfile);
463 break;
464 case N_SETV:
465 /* I don't think this type actually exists; since a N_SETV is the result
466 of going over many .o files, it doesn't make sense to have one
467 file local. */
468 ms_type = mst_file_data;
469 section = SECT_OFF_DATA (objfile);
470 break;
471 #endif
472 case N_TEXT:
473 case N_NBTEXT:
474 case N_FN:
475 case N_FN_SEQ:
476 ms_type = mst_file_text;
477 section = SECT_OFF_TEXT (objfile);
478 break;
479 case N_DATA:
480 ms_type = mst_file_data;
481
482 /* Check for __DYNAMIC, which is used by Sun shared libraries.
483 Record it as global even if it's local, not global, so
484 lookup_minimal_symbol can find it. We don't check symbol_leading_char
485 because for SunOS4 it always is '_'. */
486 if (name[8] == 'C' && strcmp ("__DYNAMIC", name) == 0)
487 ms_type = mst_data;
488
489 /* Same with virtual function tables, both global and static. */
490 {
491 const char *tempstring = name;
492
493 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
494 ++tempstring;
495 if (is_vtable_name (tempstring))
496 ms_type = mst_data;
497 }
498 section = SECT_OFF_DATA (objfile);
499 break;
500 case N_BSS:
501 ms_type = mst_file_bss;
502 section = SECT_OFF_BSS (objfile);
503 break;
504 default:
505 ms_type = mst_unknown;
506 section = -1;
507 break;
508 }
509
510 if ((ms_type == mst_file_text || ms_type == mst_text)
511 && address < lowest_text_address)
512 lowest_text_address = address;
513
514 reader.record_with_info (name, address, ms_type, section);
515 }
516 \f
517 /* Scan and build partial symbols for a symbol file.
518 We have been initialized by a call to dbx_symfile_init, which
519 put all the relevant info into a "struct dbx_symfile_info",
520 hung off the objfile structure. */
521
522 static void
523 dbx_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
524 {
525 bfd *sym_bfd;
526 int val;
527
528 sym_bfd = objfile->obfd;
529
530 /* .o and .nlm files are relocatables with text, data and bss segs based at
531 0. This flag disables special (Solaris stabs-in-elf only) fixups for
532 symbols with a value of 0. */
533
534 symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
535
536 val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
537 if (val < 0)
538 perror_with_name (objfile_name (objfile));
539
540 /* Size the symbol table. */
541 if (objfile->global_psymbols.capacity () == 0
542 && objfile->static_psymbols.capacity () == 0)
543 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
544
545 symbol_size = DBX_SYMBOL_SIZE (objfile);
546 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
547
548 scoped_free_pendings free_pending;
549
550 minimal_symbol_reader reader (objfile);
551
552 /* Read stabs data from executable file and define symbols. */
553
554 read_dbx_symtab (reader, objfile);
555
556 /* Install any minimal symbols that have been collected as the current
557 minimal symbols for this objfile. */
558
559 reader.install ();
560 }
561
562 /* Initialize anything that needs initializing when a completely new
563 symbol file is specified (not just adding some symbols from another
564 file, e.g. a shared library). */
565
566 static void
567 dbx_new_init (struct objfile *ignore)
568 {
569 stabsread_new_init ();
570 init_header_files ();
571 }
572
573
574 /* dbx_symfile_init ()
575 is the dbx-specific initialization routine for reading symbols.
576 It is passed a struct objfile which contains, among other things,
577 the BFD for the file whose symbols are being read, and a slot for a pointer
578 to "private data" which we fill with goodies.
579
580 We read the string table into malloc'd space and stash a pointer to it.
581
582 Since BFD doesn't know how to read debug symbols in a format-independent
583 way (and may never do so...), we have to do it ourselves. We will never
584 be called unless this is an a.out (or very similar) file.
585 FIXME, there should be a cleaner peephole into the BFD environment here. */
586
587 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
588
589 static void
590 dbx_symfile_init (struct objfile *objfile)
591 {
592 int val;
593 bfd *sym_bfd = objfile->obfd;
594 char *name = bfd_get_filename (sym_bfd);
595 asection *text_sect;
596 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
597 struct dbx_symfile_info *dbx;
598
599 /* Allocate struct to keep track of the symfile. */
600 dbx = XCNEW (struct dbx_symfile_info);
601 set_objfile_data (objfile, dbx_objfile_data_key, dbx);
602
603 DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
604 DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
605 DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss");
606
607 /* FIXME POKING INSIDE BFD DATA STRUCTURES. */
608 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
609 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
610
611 /* FIXME POKING INSIDE BFD DATA STRUCTURES. */
612
613 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
614 if (!text_sect)
615 error (_("Can't find .text section in symbol file"));
616 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
617 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
618
619 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
620 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
621 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
622
623 /* Read the string table and stash it away in the objfile_obstack.
624 When we blow away the objfile the string table goes away as well.
625 Note that gdb used to use the results of attempting to malloc the
626 string table, based on the size it read, as a form of sanity check
627 for botched byte swapping, on the theory that a byte swapped string
628 table size would be so totally bogus that the malloc would fail. Now
629 that we put in on the objfile_obstack, we can't do this since gdb gets
630 a fatal error (out of virtual memory) if the size is bogus. We can
631 however at least check to see if the size is less than the size of
632 the size field itself, or larger than the size of the entire file.
633 Note that all valid string tables have a size greater than zero, since
634 the bytes used to hold the size are included in the count. */
635
636 if (STRING_TABLE_OFFSET == 0)
637 {
638 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
639 will never be zero, even when there is no string table. This
640 would appear to be a bug in bfd. */
641 DBX_STRINGTAB_SIZE (objfile) = 0;
642 DBX_STRINGTAB (objfile) = NULL;
643 }
644 else
645 {
646 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
647 if (val < 0)
648 perror_with_name (name);
649
650 memset (size_temp, 0, sizeof (size_temp));
651 val = bfd_bread (size_temp, sizeof (size_temp), sym_bfd);
652 if (val < 0)
653 {
654 perror_with_name (name);
655 }
656 else if (val == 0)
657 {
658 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
659 EOF if there is no string table, and attempting to read the size
660 from EOF will read zero bytes. */
661 DBX_STRINGTAB_SIZE (objfile) = 0;
662 DBX_STRINGTAB (objfile) = NULL;
663 }
664 else
665 {
666 /* Read some data that would appear to be the string table size.
667 If there really is a string table, then it is probably the right
668 size. Byteswap if necessary and validate the size. Note that
669 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
670 random data that happened to be at STRING_TABLE_OFFSET, because
671 bfd can't tell us there is no string table, the sanity checks may
672 or may not catch this. */
673 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
674
675 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
676 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
677 error (_("ridiculous string table size (%d bytes)."),
678 DBX_STRINGTAB_SIZE (objfile));
679
680 DBX_STRINGTAB (objfile) =
681 (char *) obstack_alloc (&objfile->objfile_obstack,
682 DBX_STRINGTAB_SIZE (objfile));
683 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
684
685 /* Now read in the string table in one big gulp. */
686
687 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
688 if (val < 0)
689 perror_with_name (name);
690 val = bfd_bread (DBX_STRINGTAB (objfile),
691 DBX_STRINGTAB_SIZE (objfile),
692 sym_bfd);
693 if (val != DBX_STRINGTAB_SIZE (objfile))
694 perror_with_name (name);
695 }
696 }
697 }
698
699 /* Perform any local cleanups required when we are done with a particular
700 objfile. I.E, we are in the process of discarding all symbol information
701 for an objfile, freeing up all memory held for it, and unlinking the
702 objfile struct from the global list of known objfiles. */
703
704 static void
705 dbx_symfile_finish (struct objfile *objfile)
706 {
707 free_header_files ();
708 }
709
710 static void
711 dbx_free_symfile_info (struct objfile *objfile, void *arg)
712 {
713 struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) arg;
714
715 if (dbx->header_files != NULL)
716 {
717 int i = dbx->n_header_files;
718 struct header_file *hfiles = dbx->header_files;
719
720 while (--i >= 0)
721 {
722 xfree (hfiles[i].name);
723 xfree (hfiles[i].vector);
724 }
725 xfree (hfiles);
726 }
727
728 xfree (dbx);
729 }
730
731 \f
732
733 /* Buffer for reading the symbol table entries. */
734 static struct external_nlist symbuf[4096];
735 static int symbuf_idx;
736 static int symbuf_end;
737
738 /* Name of last function encountered. Used in Solaris to approximate
739 object file boundaries. */
740 static const char *last_function_name;
741
742 /* The address in memory of the string table of the object file we are
743 reading (which might not be the "main" object file, but might be a
744 shared library or some other dynamically loaded thing). This is
745 set by read_dbx_symtab when building psymtabs, and by
746 read_ofile_symtab when building symtabs, and is used only by
747 next_symbol_text. FIXME: If that is true, we don't need it when
748 building psymtabs, right? */
749 static char *stringtab_global;
750
751 /* These variables are used to control fill_symbuf when the stabs
752 symbols are not contiguous (as may be the case when a COFF file is
753 linked using --split-by-reloc). */
754 static struct stab_section_list *symbuf_sections;
755 static unsigned int symbuf_left;
756 static unsigned int symbuf_read;
757
758 /* This variable stores a global stabs buffer, if we read stabs into
759 memory in one chunk in order to process relocations. */
760 static bfd_byte *stabs_data;
761
762 /* Refill the symbol table input buffer
763 and set the variables that control fetching entries from it.
764 Reports an error if no data available.
765 This function can read past the end of the symbol table
766 (into the string table) but this does no harm. */
767
768 static void
769 fill_symbuf (bfd *sym_bfd)
770 {
771 unsigned int count;
772 int nbytes;
773
774 if (stabs_data)
775 {
776 nbytes = sizeof (symbuf);
777 if (nbytes > symbuf_left)
778 nbytes = symbuf_left;
779 memcpy (symbuf, stabs_data + symbuf_read, nbytes);
780 }
781 else if (symbuf_sections == NULL)
782 {
783 count = sizeof (symbuf);
784 nbytes = bfd_bread (symbuf, count, sym_bfd);
785 }
786 else
787 {
788 if (symbuf_left <= 0)
789 {
790 file_ptr filepos = symbuf_sections->section->filepos;
791
792 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
793 perror_with_name (bfd_get_filename (sym_bfd));
794 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
795 symbol_table_offset = filepos - symbuf_read;
796 symbuf_sections = symbuf_sections->next;
797 }
798
799 count = symbuf_left;
800 if (count > sizeof (symbuf))
801 count = sizeof (symbuf);
802 nbytes = bfd_bread (symbuf, count, sym_bfd);
803 }
804
805 if (nbytes < 0)
806 perror_with_name (bfd_get_filename (sym_bfd));
807 else if (nbytes == 0)
808 error (_("Premature end of file reading symbol table"));
809 symbuf_end = nbytes / symbol_size;
810 symbuf_idx = 0;
811 symbuf_left -= nbytes;
812 symbuf_read += nbytes;
813 }
814
815 static void
816 stabs_seek (int sym_offset)
817 {
818 if (stabs_data)
819 {
820 symbuf_read += sym_offset;
821 symbuf_left -= sym_offset;
822 }
823 else
824 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
825 }
826
827 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
828 { \
829 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
830 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
831 (intern).n_other = 0; \
832 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
833 if (bfd_get_sign_extend_vma (abfd)) \
834 (intern).n_value = bfd_h_get_signed_32 (abfd, (extern)->e_value); \
835 else \
836 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
837 }
838
839 /* Invariant: The symbol pointed to by symbuf_idx is the first one
840 that hasn't been swapped. Swap the symbol at the same time
841 that symbuf_idx is incremented. */
842
843 /* dbx allows the text of a symbol name to be continued into the
844 next symbol name! When such a continuation is encountered
845 (a \ at the end of the text of a name)
846 call this function to get the continuation. */
847
848 static const char *
849 dbx_next_symbol_text (struct objfile *objfile)
850 {
851 struct internal_nlist nlist;
852
853 if (symbuf_idx == symbuf_end)
854 fill_symbuf (symfile_bfd);
855
856 symnum++;
857 INTERNALIZE_SYMBOL (nlist, &symbuf[symbuf_idx], symfile_bfd);
858 OBJSTAT (objfile, n_stabs++);
859
860 symbuf_idx++;
861
862 return nlist.n_strx + stringtab_global + file_string_table_offset;
863 }
864 \f
865
866 /* Given a name, value pair, find the corresponding
867 bincl in the list. Return the partial symtab associated
868 with that header_file_location. */
869
870 static struct partial_symtab *
871 find_corresponding_bincl_psymtab (const char *name, int instance)
872 {
873 for (const header_file_location &bincl : *bincl_list)
874 if (bincl.instance == instance
875 && strcmp (name, bincl.name) == 0)
876 return bincl.pst;
877
878 repeated_header_complaint (name, symnum);
879 return (struct partial_symtab *) 0;
880 }
881
882 /* Set namestring based on nlist. If the string table index is invalid,
883 give a fake name, and print a single error message per symbol file read,
884 rather than abort the symbol reading or flood the user with messages. */
885
886 static const char *
887 set_namestring (struct objfile *objfile, const struct internal_nlist *nlist)
888 {
889 const char *namestring;
890
891 if (nlist->n_strx + file_string_table_offset
892 >= DBX_STRINGTAB_SIZE (objfile)
893 || nlist->n_strx + file_string_table_offset < nlist->n_strx)
894 {
895 complaint (_("bad string table offset in symbol %d"),
896 symnum);
897 namestring = "<bad string table offset>";
898 }
899 else
900 namestring = (nlist->n_strx + file_string_table_offset
901 + DBX_STRINGTAB (objfile));
902 return namestring;
903 }
904
905 static struct bound_minimal_symbol
906 find_stab_function (const char *namestring, const char *filename,
907 struct objfile *objfile)
908 {
909 struct bound_minimal_symbol msym;
910 int n;
911
912 const char *colon = strchr (namestring, ':');
913 if (colon == NULL)
914 n = 0;
915 else
916 n = colon - namestring;
917
918 char *p = (char *) alloca (n + 2);
919 strncpy (p, namestring, n);
920 p[n] = 0;
921
922 msym = lookup_minimal_symbol (p, filename, objfile);
923 if (msym.minsym == NULL)
924 {
925 /* Sun Fortran appends an underscore to the minimal symbol name,
926 try again with an appended underscore if the minimal symbol
927 was not found. */
928 p[n] = '_';
929 p[n + 1] = 0;
930 msym = lookup_minimal_symbol (p, filename, objfile);
931 }
932
933 if (msym.minsym == NULL && filename != NULL)
934 {
935 /* Try again without the filename. */
936 p[n] = 0;
937 msym = lookup_minimal_symbol (p, NULL, objfile);
938 }
939 if (msym.minsym == NULL && filename != NULL)
940 {
941 /* And try again for Sun Fortran, but without the filename. */
942 p[n] = '_';
943 p[n + 1] = 0;
944 msym = lookup_minimal_symbol (p, NULL, objfile);
945 }
946
947 return msym;
948 }
949
950 static void
951 function_outside_compilation_unit_complaint (const char *arg1)
952 {
953 complaint (_("function `%s' appears to be defined "
954 "outside of all compilation units"),
955 arg1);
956 }
957
958 /* Setup partial_symtab's describing each source file for which
959 debugging information is available. */
960
961 static void
962 read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile)
963 {
964 struct gdbarch *gdbarch = get_objfile_arch (objfile);
965 struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch. */
966 struct internal_nlist nlist;
967 CORE_ADDR text_addr;
968 int text_size;
969 const char *sym_name;
970 int sym_len;
971
972 const char *namestring;
973 int nsl;
974 int past_first_source_file = 0;
975 CORE_ADDR last_function_start = 0;
976 bfd *abfd;
977 int textlow_not_set;
978 int data_sect_index;
979
980 /* Current partial symtab. */
981 struct partial_symtab *pst;
982
983 /* List of current psymtab's include files. */
984 const char **psymtab_include_list;
985 int includes_allocated;
986 int includes_used;
987
988 /* Index within current psymtab dependency list. */
989 struct partial_symtab **dependency_list;
990 int dependencies_used, dependencies_allocated;
991
992 text_addr = DBX_TEXT_ADDR (objfile);
993 text_size = DBX_TEXT_SIZE (objfile);
994
995 /* FIXME. We probably want to change stringtab_global rather than add this
996 while processing every symbol entry. FIXME. */
997 file_string_table_offset = 0;
998 next_file_string_table_offset = 0;
999
1000 stringtab_global = DBX_STRINGTAB (objfile);
1001
1002 pst = (struct partial_symtab *) 0;
1003
1004 includes_allocated = 30;
1005 includes_used = 0;
1006 psymtab_include_list = (const char **) alloca (includes_allocated *
1007 sizeof (const char *));
1008
1009 dependencies_allocated = 30;
1010 dependencies_used = 0;
1011 dependency_list =
1012 (struct partial_symtab **) alloca (dependencies_allocated *
1013 sizeof (struct partial_symtab *));
1014
1015 /* Init bincl list */
1016 std::vector<struct header_file_location> bincl_storage;
1017 scoped_restore restore_bincl_global
1018 = make_scoped_restore (&bincl_list, &bincl_storage);
1019
1020 set_last_source_file (NULL);
1021
1022 lowest_text_address = (CORE_ADDR) -1;
1023
1024 symfile_bfd = objfile->obfd; /* For next_text_symbol. */
1025 abfd = objfile->obfd;
1026 symbuf_end = symbuf_idx = 0;
1027 next_symbol_text_func = dbx_next_symbol_text;
1028 textlow_not_set = 1;
1029 has_line_numbers = 0;
1030
1031 /* FIXME: jimb/2003-09-12: We don't apply the right section's offset
1032 to global and static variables. The stab for a global or static
1033 variable doesn't give us any indication of which section it's in,
1034 so we can't tell immediately which offset in
1035 objfile->section_offsets we should apply to the variable's
1036 address.
1037
1038 We could certainly find out which section contains the variable
1039 by looking up the variable's unrelocated address with
1040 find_pc_section, but that would be expensive; this is the
1041 function that constructs the partial symbol tables by examining
1042 every symbol in the entire executable, and it's
1043 performance-critical. So that expense would not be welcome. I'm
1044 not sure what to do about this at the moment.
1045
1046 What we have done for years is to simply assume that the .data
1047 section's offset is appropriate for all global and static
1048 variables. Recently, this was expanded to fall back to the .bss
1049 section's offset if there is no .data section, and then to the
1050 .rodata section's offset. */
1051 data_sect_index = objfile->sect_index_data;
1052 if (data_sect_index == -1)
1053 data_sect_index = SECT_OFF_BSS (objfile);
1054 if (data_sect_index == -1)
1055 data_sect_index = SECT_OFF_RODATA (objfile);
1056
1057 /* If data_sect_index is still -1, that's okay. It's perfectly fine
1058 for the file to have no .data, no .bss, and no .text at all, if
1059 it also has no global or static variables. If it does, we will
1060 get an internal error from an ANOFFSET macro below when we try to
1061 use data_sect_index. */
1062
1063 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1064 {
1065 /* Get the symbol for this run and pull out some info. */
1066 QUIT; /* Allow this to be interruptable. */
1067 if (symbuf_idx == symbuf_end)
1068 fill_symbuf (abfd);
1069 bufp = &symbuf[symbuf_idx++];
1070
1071 /*
1072 * Special case to speed up readin.
1073 */
1074 if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE)
1075 {
1076 has_line_numbers = 1;
1077 continue;
1078 }
1079
1080 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1081 OBJSTAT (objfile, n_stabs++);
1082
1083 /* Ok. There is a lot of code duplicated in the rest of this
1084 switch statement (for efficiency reasons). Since I don't
1085 like duplicating code, I will do my penance here, and
1086 describe the code which is duplicated:
1087
1088 *) The assignment to namestring.
1089 *) The call to strchr.
1090 *) The addition of a partial symbol the two partial
1091 symbol lists. This last is a large section of code, so
1092 I've imbedded it in the following macro. */
1093
1094 switch (nlist.n_type)
1095 {
1096 /*
1097 * Standard, external, non-debugger, symbols
1098 */
1099
1100 case N_TEXT | N_EXT:
1101 case N_NBTEXT | N_EXT:
1102 goto record_it;
1103
1104 case N_DATA | N_EXT:
1105 case N_NBDATA | N_EXT:
1106 goto record_it;
1107
1108 case N_BSS:
1109 case N_BSS | N_EXT:
1110 case N_NBBSS | N_EXT:
1111 case N_SETV | N_EXT: /* FIXME, is this in BSS? */
1112 goto record_it;
1113
1114 case N_ABS | N_EXT:
1115 record_it:
1116 namestring = set_namestring (objfile, &nlist);
1117
1118 record_minimal_symbol (reader, namestring, nlist.n_value,
1119 nlist.n_type, objfile); /* Always */
1120 continue;
1121
1122 /* Standard, local, non-debugger, symbols. */
1123
1124 case N_NBTEXT:
1125
1126 /* We need to be able to deal with both N_FN or N_TEXT,
1127 because we have no way of knowing whether the sys-supplied ld
1128 or GNU ld was used to make the executable. Sequents throw
1129 in another wrinkle -- they renumbered N_FN. */
1130
1131 case N_FN:
1132 case N_FN_SEQ:
1133 case N_TEXT:
1134 namestring = set_namestring (objfile, &nlist);
1135
1136 if ((namestring[0] == '-' && namestring[1] == 'l')
1137 || (namestring[(nsl = strlen (namestring)) - 1] == 'o'
1138 && namestring[nsl - 2] == '.'))
1139 {
1140 if (past_first_source_file && pst
1141 /* The gould NP1 uses low values for .o and -l symbols
1142 which are not the address. */
1143 && nlist.n_value >= pst->raw_text_low ())
1144 {
1145 dbx_end_psymtab (objfile, pst, psymtab_include_list,
1146 includes_used, symnum * symbol_size,
1147 nlist.n_value > pst->raw_text_high ()
1148 ? nlist.n_value : pst->raw_text_high (),
1149 dependency_list, dependencies_used,
1150 textlow_not_set);
1151 pst = (struct partial_symtab *) 0;
1152 includes_used = 0;
1153 dependencies_used = 0;
1154 has_line_numbers = 0;
1155 }
1156 else
1157 past_first_source_file = 1;
1158 }
1159 else
1160 goto record_it;
1161 continue;
1162
1163 case N_DATA:
1164 goto record_it;
1165
1166 case N_UNDF | N_EXT:
1167 /* The case (nlist.n_value != 0) is a "Fortran COMMON" symbol.
1168 We used to rely on the target to tell us whether it knows
1169 where the symbol has been relocated to, but none of the
1170 target implementations actually provided that operation.
1171 So we just ignore the symbol, the same way we would do if
1172 we had a target-side symbol lookup which returned no match.
1173
1174 All other symbols (with nlist.n_value == 0), are really
1175 undefined, and so we ignore them too. */
1176 continue;
1177
1178 case N_UNDF:
1179 if (processing_acc_compilation && nlist.n_strx == 1)
1180 {
1181 /* Deal with relative offsets in the string table
1182 used in ELF+STAB under Solaris. If we want to use the
1183 n_strx field, which contains the name of the file,
1184 we must adjust file_string_table_offset *before* calling
1185 set_namestring(). */
1186 past_first_source_file = 1;
1187 file_string_table_offset = next_file_string_table_offset;
1188 next_file_string_table_offset =
1189 file_string_table_offset + nlist.n_value;
1190 if (next_file_string_table_offset < file_string_table_offset)
1191 error (_("string table offset backs up at %d"), symnum);
1192 /* FIXME -- replace error() with complaint. */
1193 continue;
1194 }
1195 continue;
1196
1197 /* Lots of symbol types we can just ignore. */
1198
1199 case N_ABS:
1200 case N_NBDATA:
1201 case N_NBBSS:
1202 continue;
1203
1204 /* Keep going . . . */
1205
1206 /*
1207 * Special symbol types for GNU
1208 */
1209 case N_INDR:
1210 case N_INDR | N_EXT:
1211 case N_SETA:
1212 case N_SETA | N_EXT:
1213 case N_SETT:
1214 case N_SETT | N_EXT:
1215 case N_SETD:
1216 case N_SETD | N_EXT:
1217 case N_SETB:
1218 case N_SETB | N_EXT:
1219 case N_SETV:
1220 continue;
1221
1222 /*
1223 * Debugger symbols
1224 */
1225
1226 case N_SO:
1227 {
1228 CORE_ADDR valu;
1229 static int prev_so_symnum = -10;
1230 static int first_so_symnum;
1231 const char *p;
1232 static const char *dirname_nso;
1233 int prev_textlow_not_set;
1234
1235 valu = nlist.n_value;
1236
1237 prev_textlow_not_set = textlow_not_set;
1238
1239 /* A zero value is probably an indication for the SunPRO 3.0
1240 compiler. dbx_end_psymtab explicitly tests for zero, so
1241 don't relocate it. */
1242
1243 if (nlist.n_value == 0
1244 && gdbarch_sofun_address_maybe_missing (gdbarch))
1245 {
1246 textlow_not_set = 1;
1247 valu = 0;
1248 }
1249 else
1250 textlow_not_set = 0;
1251
1252 past_first_source_file = 1;
1253
1254 if (prev_so_symnum != symnum - 1)
1255 { /* Here if prev stab wasn't N_SO. */
1256 first_so_symnum = symnum;
1257
1258 if (pst)
1259 {
1260 dbx_end_psymtab (objfile, pst, psymtab_include_list,
1261 includes_used, symnum * symbol_size,
1262 (valu > pst->raw_text_high ()
1263 ? valu : pst->raw_text_high ()),
1264 dependency_list, dependencies_used,
1265 prev_textlow_not_set);
1266 pst = (struct partial_symtab *) 0;
1267 includes_used = 0;
1268 dependencies_used = 0;
1269 has_line_numbers = 0;
1270 }
1271 }
1272
1273 prev_so_symnum = symnum;
1274
1275 /* End the current partial symtab and start a new one. */
1276
1277 namestring = set_namestring (objfile, &nlist);
1278
1279 /* Null name means end of .o file. Don't start a new one. */
1280 if (*namestring == '\000')
1281 continue;
1282
1283 /* Some compilers (including gcc) emit a pair of initial N_SOs.
1284 The first one is a directory name; the second the file name.
1285 If pst exists, is empty, and has a filename ending in '/',
1286 we assume the previous N_SO was a directory name. */
1287
1288 p = lbasename (namestring);
1289 if (p != namestring && *p == '\000')
1290 {
1291 /* Save the directory name SOs locally, then save it into
1292 the psymtab when it's created below. */
1293 dirname_nso = namestring;
1294 continue;
1295 }
1296
1297 /* Some other compilers (C++ ones in particular) emit useless
1298 SOs for non-existant .c files. We ignore all subsequent SOs
1299 that immediately follow the first. */
1300
1301 if (!pst)
1302 {
1303 pst = start_psymtab (objfile,
1304 namestring, valu,
1305 first_so_symnum * symbol_size,
1306 objfile->global_psymbols,
1307 objfile->static_psymbols);
1308 pst->dirname = dirname_nso;
1309 dirname_nso = NULL;
1310 }
1311 continue;
1312 }
1313
1314 case N_BINCL:
1315 {
1316 enum language tmp_language;
1317
1318 /* Add this bincl to the bincl_list for future EXCLs. No
1319 need to save the string; it'll be around until
1320 read_dbx_symtab function returns. */
1321
1322 namestring = set_namestring (objfile, &nlist);
1323 tmp_language = deduce_language_from_filename (namestring);
1324
1325 /* Only change the psymtab's language if we've learned
1326 something useful (eg. tmp_language is not language_unknown).
1327 In addition, to match what start_subfile does, never change
1328 from C++ to C. */
1329 if (tmp_language != language_unknown
1330 && (tmp_language != language_c
1331 || psymtab_language != language_cplus))
1332 psymtab_language = tmp_language;
1333
1334 if (pst == NULL)
1335 {
1336 /* FIXME: we should not get here without a PST to work on.
1337 Attempt to recover. */
1338 complaint (_("N_BINCL %s not in entries for "
1339 "any file, at symtab pos %d"),
1340 namestring, symnum);
1341 continue;
1342 }
1343 bincl_list->emplace_back (namestring, nlist.n_value, pst);
1344
1345 /* Mark down an include file in the current psymtab. */
1346
1347 goto record_include_file;
1348 }
1349
1350 case N_SOL:
1351 {
1352 enum language tmp_language;
1353
1354 /* Mark down an include file in the current psymtab. */
1355 namestring = set_namestring (objfile, &nlist);
1356 tmp_language = deduce_language_from_filename (namestring);
1357
1358 /* Only change the psymtab's language if we've learned
1359 something useful (eg. tmp_language is not language_unknown).
1360 In addition, to match what start_subfile does, never change
1361 from C++ to C. */
1362 if (tmp_language != language_unknown
1363 && (tmp_language != language_c
1364 || psymtab_language != language_cplus))
1365 psymtab_language = tmp_language;
1366
1367 /* In C++, one may expect the same filename to come round many
1368 times, when code is coming alternately from the main file
1369 and from inline functions in other files. So I check to see
1370 if this is a file we've seen before -- either the main
1371 source file, or a previously included file.
1372
1373 This seems to be a lot of time to be spending on N_SOL, but
1374 things like "break c-exp.y:435" need to work (I
1375 suppose the psymtab_include_list could be hashed or put
1376 in a binary tree, if profiling shows this is a major hog). */
1377 if (pst && filename_cmp (namestring, pst->filename) == 0)
1378 continue;
1379 {
1380 int i;
1381
1382 for (i = 0; i < includes_used; i++)
1383 if (filename_cmp (namestring, psymtab_include_list[i]) == 0)
1384 {
1385 i = -1;
1386 break;
1387 }
1388 if (i == -1)
1389 continue;
1390 }
1391
1392 record_include_file:
1393
1394 psymtab_include_list[includes_used++] = namestring;
1395 if (includes_used >= includes_allocated)
1396 {
1397 const char **orig = psymtab_include_list;
1398
1399 psymtab_include_list = (const char **)
1400 alloca ((includes_allocated *= 2) * sizeof (const char *));
1401 memcpy (psymtab_include_list, orig,
1402 includes_used * sizeof (const char *));
1403 }
1404 continue;
1405 }
1406 case N_LSYM: /* Typedef or automatic variable. */
1407 case N_STSYM: /* Data seg var -- static. */
1408 case N_LCSYM: /* BSS " */
1409 case N_ROSYM: /* Read-only data seg var -- static. */
1410 case N_NBSTS: /* Gould nobase. */
1411 case N_NBLCS: /* symbols. */
1412 case N_FUN:
1413 case N_GSYM: /* Global (extern) variable; can be
1414 data or bss (sigh FIXME). */
1415
1416 /* Following may probably be ignored; I'll leave them here
1417 for now (until I do Pascal and Modula 2 extensions). */
1418
1419 case N_PC: /* I may or may not need this; I
1420 suspect not. */
1421 case N_M2C: /* I suspect that I can ignore this here. */
1422 case N_SCOPE: /* Same. */
1423 {
1424 const char *p;
1425
1426 namestring = set_namestring (objfile, &nlist);
1427
1428 /* See if this is an end of function stab. */
1429 if (pst && nlist.n_type == N_FUN && *namestring == '\000')
1430 {
1431 CORE_ADDR valu;
1432
1433 /* It's value is the size (in bytes) of the function for
1434 function relative stabs, or the address of the function's
1435 end for old style stabs. */
1436 valu = nlist.n_value + last_function_start;
1437 if (pst->raw_text_high () == 0 || valu > pst->raw_text_high ())
1438 pst->set_text_high (valu);
1439 break;
1440 }
1441
1442 p = (char *) strchr (namestring, ':');
1443 if (!p)
1444 continue; /* Not a debugging symbol. */
1445
1446 sym_len = 0;
1447 sym_name = NULL; /* pacify "gcc -Werror" */
1448 if (psymtab_language == language_cplus)
1449 {
1450 std::string name (namestring, p - namestring);
1451 std::string new_name = cp_canonicalize_string (name.c_str ());
1452 if (!new_name.empty ())
1453 {
1454 sym_len = new_name.length ();
1455 sym_name = (char *) obstack_copy0 (&objfile->objfile_obstack,
1456 new_name.c_str (),
1457 sym_len);
1458 }
1459 }
1460
1461 if (sym_len == 0)
1462 {
1463 sym_name = namestring;
1464 sym_len = p - namestring;
1465 }
1466
1467 /* Main processing section for debugging symbols which
1468 the initial read through the symbol tables needs to worry
1469 about. If we reach this point, the symbol which we are
1470 considering is definitely one we are interested in.
1471 p must also contain the (valid) index into the namestring
1472 which indicates the debugging type symbol. */
1473
1474 switch (p[1])
1475 {
1476 case 'S':
1477 if (gdbarch_static_transform_name_p (gdbarch))
1478 gdbarch_static_transform_name (gdbarch, namestring);
1479
1480 add_psymbol_to_list (sym_name, sym_len, 1,
1481 VAR_DOMAIN, LOC_STATIC,
1482 data_sect_index,
1483 &objfile->static_psymbols,
1484 nlist.n_value, psymtab_language, objfile);
1485 continue;
1486
1487 case 'G':
1488 /* The addresses in these entries are reported to be
1489 wrong. See the code that reads 'G's for symtabs. */
1490 add_psymbol_to_list (sym_name, sym_len, 1,
1491 VAR_DOMAIN, LOC_STATIC,
1492 data_sect_index,
1493 &objfile->global_psymbols,
1494 nlist.n_value, psymtab_language, objfile);
1495 continue;
1496
1497 case 'T':
1498 /* When a 'T' entry is defining an anonymous enum, it
1499 may have a name which is the empty string, or a
1500 single space. Since they're not really defining a
1501 symbol, those shouldn't go in the partial symbol
1502 table. We do pick up the elements of such enums at
1503 'check_enum:', below. */
1504 if (p >= namestring + 2
1505 || (p == namestring + 1
1506 && namestring[0] != ' '))
1507 {
1508 add_psymbol_to_list (sym_name, sym_len, 1,
1509 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
1510 &objfile->static_psymbols,
1511 0, psymtab_language, objfile);
1512 if (p[2] == 't')
1513 {
1514 /* Also a typedef with the same name. */
1515 add_psymbol_to_list (sym_name, sym_len, 1,
1516 VAR_DOMAIN, LOC_TYPEDEF, -1,
1517 &objfile->static_psymbols,
1518 0, psymtab_language, objfile);
1519 p += 1;
1520 }
1521 }
1522 goto check_enum;
1523
1524 case 't':
1525 if (p != namestring) /* a name is there, not just :T... */
1526 {
1527 add_psymbol_to_list (sym_name, sym_len, 1,
1528 VAR_DOMAIN, LOC_TYPEDEF, -1,
1529 &objfile->static_psymbols,
1530 0, psymtab_language, objfile);
1531 }
1532 check_enum:
1533 /* If this is an enumerated type, we need to
1534 add all the enum constants to the partial symbol
1535 table. This does not cover enums without names, e.g.
1536 "enum {a, b} c;" in C, but fortunately those are
1537 rare. There is no way for GDB to find those from the
1538 enum type without spending too much time on it. Thus
1539 to solve this problem, the compiler needs to put out the
1540 enum in a nameless type. GCC2 does this. */
1541
1542 /* We are looking for something of the form
1543 <name> ":" ("t" | "T") [<number> "="] "e"
1544 {<constant> ":" <value> ","} ";". */
1545
1546 /* Skip over the colon and the 't' or 'T'. */
1547 p += 2;
1548 /* This type may be given a number. Also, numbers can come
1549 in pairs like (0,26). Skip over it. */
1550 while ((*p >= '0' && *p <= '9')
1551 || *p == '(' || *p == ',' || *p == ')'
1552 || *p == '=')
1553 p++;
1554
1555 if (*p++ == 'e')
1556 {
1557 /* The aix4 compiler emits extra crud before the members. */
1558 if (*p == '-')
1559 {
1560 /* Skip over the type (?). */
1561 while (*p != ':')
1562 p++;
1563
1564 /* Skip over the colon. */
1565 p++;
1566 }
1567
1568 /* We have found an enumerated type. */
1569 /* According to comments in read_enum_type
1570 a comma could end it instead of a semicolon.
1571 I don't know where that happens.
1572 Accept either. */
1573 while (*p && *p != ';' && *p != ',')
1574 {
1575 const char *q;
1576
1577 /* Check for and handle cretinous dbx symbol name
1578 continuation! */
1579 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
1580 p = next_symbol_text (objfile);
1581
1582 /* Point to the character after the name
1583 of the enum constant. */
1584 for (q = p; *q && *q != ':'; q++)
1585 ;
1586 /* Note that the value doesn't matter for
1587 enum constants in psymtabs, just in symtabs. */
1588 add_psymbol_to_list (p, q - p, 1,
1589 VAR_DOMAIN, LOC_CONST, -1,
1590 &objfile->static_psymbols, 0,
1591 psymtab_language, objfile);
1592 /* Point past the name. */
1593 p = q;
1594 /* Skip over the value. */
1595 while (*p && *p != ',')
1596 p++;
1597 /* Advance past the comma. */
1598 if (*p)
1599 p++;
1600 }
1601 }
1602 continue;
1603
1604 case 'c':
1605 /* Constant, e.g. from "const" in Pascal. */
1606 add_psymbol_to_list (sym_name, sym_len, 1,
1607 VAR_DOMAIN, LOC_CONST, -1,
1608 &objfile->static_psymbols, 0,
1609 psymtab_language, objfile);
1610 continue;
1611
1612 case 'f':
1613 if (! pst)
1614 {
1615 int name_len = p - namestring;
1616 char *name = (char *) xmalloc (name_len + 1);
1617
1618 memcpy (name, namestring, name_len);
1619 name[name_len] = '\0';
1620 function_outside_compilation_unit_complaint (name);
1621 xfree (name);
1622 }
1623 /* Kludges for ELF/STABS with Sun ACC. */
1624 last_function_name = namestring;
1625 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1626 value for the bottom of the text seg in those cases. */
1627 if (nlist.n_value == 0
1628 && gdbarch_sofun_address_maybe_missing (gdbarch))
1629 {
1630 struct bound_minimal_symbol minsym
1631 = find_stab_function (namestring,
1632 pst ? pst->filename : NULL,
1633 objfile);
1634 if (minsym.minsym != NULL)
1635 nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
1636 }
1637 if (pst && textlow_not_set
1638 && gdbarch_sofun_address_maybe_missing (gdbarch))
1639 {
1640 pst->set_text_low (nlist.n_value);
1641 textlow_not_set = 0;
1642 }
1643 /* End kludge. */
1644
1645 /* Keep track of the start of the last function so we
1646 can handle end of function symbols. */
1647 last_function_start = nlist.n_value;
1648
1649 /* In reordered executables this function may lie outside
1650 the bounds created by N_SO symbols. If that's the case
1651 use the address of this function as the low bound for
1652 the partial symbol table. */
1653 if (pst
1654 && (textlow_not_set
1655 || (nlist.n_value < pst->raw_text_low ()
1656 && (nlist.n_value != 0))))
1657 {
1658 pst->set_text_low (nlist.n_value);
1659 textlow_not_set = 0;
1660 }
1661 add_psymbol_to_list (sym_name, sym_len, 1,
1662 VAR_DOMAIN, LOC_BLOCK,
1663 SECT_OFF_TEXT (objfile),
1664 &objfile->static_psymbols,
1665 nlist.n_value, psymtab_language, objfile);
1666 continue;
1667
1668 /* Global functions were ignored here, but now they
1669 are put into the global psymtab like one would expect.
1670 They're also in the minimal symbol table. */
1671 case 'F':
1672 if (! pst)
1673 {
1674 int name_len = p - namestring;
1675 char *name = (char *) xmalloc (name_len + 1);
1676
1677 memcpy (name, namestring, name_len);
1678 name[name_len] = '\0';
1679 function_outside_compilation_unit_complaint (name);
1680 xfree (name);
1681 }
1682 /* Kludges for ELF/STABS with Sun ACC. */
1683 last_function_name = namestring;
1684 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1685 value for the bottom of the text seg in those cases. */
1686 if (nlist.n_value == 0
1687 && gdbarch_sofun_address_maybe_missing (gdbarch))
1688 {
1689 struct bound_minimal_symbol minsym
1690 = find_stab_function (namestring,
1691 pst ? pst->filename : NULL,
1692 objfile);
1693 if (minsym.minsym != NULL)
1694 nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
1695 }
1696 if (pst && textlow_not_set
1697 && gdbarch_sofun_address_maybe_missing (gdbarch))
1698 {
1699 pst->set_text_low (nlist.n_value);
1700 textlow_not_set = 0;
1701 }
1702 /* End kludge. */
1703
1704 /* Keep track of the start of the last function so we
1705 can handle end of function symbols. */
1706 last_function_start = nlist.n_value;
1707
1708 /* In reordered executables this function may lie outside
1709 the bounds created by N_SO symbols. If that's the case
1710 use the address of this function as the low bound for
1711 the partial symbol table. */
1712 if (pst
1713 && (textlow_not_set
1714 || (nlist.n_value < pst->raw_text_low ()
1715 && (nlist.n_value != 0))))
1716 {
1717 pst->set_text_low (nlist.n_value);
1718 textlow_not_set = 0;
1719 }
1720 add_psymbol_to_list (sym_name, sym_len, 1,
1721 VAR_DOMAIN, LOC_BLOCK,
1722 SECT_OFF_TEXT (objfile),
1723 &objfile->global_psymbols,
1724 nlist.n_value, psymtab_language, objfile);
1725 continue;
1726
1727 /* Two things show up here (hopefully); static symbols of
1728 local scope (static used inside braces) or extensions
1729 of structure symbols. We can ignore both. */
1730 case 'V':
1731 case '(':
1732 case '0':
1733 case '1':
1734 case '2':
1735 case '3':
1736 case '4':
1737 case '5':
1738 case '6':
1739 case '7':
1740 case '8':
1741 case '9':
1742 case '-':
1743 case '#': /* For symbol identification (used in live ranges). */
1744 continue;
1745
1746 case ':':
1747 /* It is a C++ nested symbol. We don't need to record it
1748 (I don't think); if we try to look up foo::bar::baz,
1749 then symbols for the symtab containing foo should get
1750 read in, I think. */
1751 /* Someone says sun cc puts out symbols like
1752 /foo/baz/maclib::/usr/local/bin/maclib,
1753 which would get here with a symbol type of ':'. */
1754 continue;
1755
1756 default:
1757 /* Unexpected symbol descriptor. The second and subsequent stabs
1758 of a continued stab can show up here. The question is
1759 whether they ever can mimic a normal stab--it would be
1760 nice if not, since we certainly don't want to spend the
1761 time searching to the end of every string looking for
1762 a backslash. */
1763
1764 complaint (_("unknown symbol descriptor `%c'"),
1765 p[1]);
1766
1767 /* Ignore it; perhaps it is an extension that we don't
1768 know about. */
1769 continue;
1770 }
1771 }
1772
1773 case N_EXCL:
1774
1775 namestring = set_namestring (objfile, &nlist);
1776
1777 /* Find the corresponding bincl and mark that psymtab on the
1778 psymtab dependency list. */
1779 {
1780 struct partial_symtab *needed_pst =
1781 find_corresponding_bincl_psymtab (namestring, nlist.n_value);
1782
1783 /* If this include file was defined earlier in this file,
1784 leave it alone. */
1785 if (needed_pst == pst)
1786 continue;
1787
1788 if (needed_pst)
1789 {
1790 int i;
1791 int found = 0;
1792
1793 for (i = 0; i < dependencies_used; i++)
1794 if (dependency_list[i] == needed_pst)
1795 {
1796 found = 1;
1797 break;
1798 }
1799
1800 /* If it's already in the list, skip the rest. */
1801 if (found)
1802 continue;
1803
1804 dependency_list[dependencies_used++] = needed_pst;
1805 if (dependencies_used >= dependencies_allocated)
1806 {
1807 struct partial_symtab **orig = dependency_list;
1808
1809 dependency_list =
1810 (struct partial_symtab **)
1811 alloca ((dependencies_allocated *= 2)
1812 * sizeof (struct partial_symtab *));
1813 memcpy (dependency_list, orig,
1814 (dependencies_used
1815 * sizeof (struct partial_symtab *)));
1816 #ifdef DEBUG_INFO
1817 fprintf_unfiltered (gdb_stderr,
1818 "Had to reallocate "
1819 "dependency list.\n");
1820 fprintf_unfiltered (gdb_stderr,
1821 "New dependencies allocated: %d\n",
1822 dependencies_allocated);
1823 #endif
1824 }
1825 }
1826 }
1827 continue;
1828
1829 case N_ENDM:
1830 /* Solaris 2 end of module, finish current partial symbol
1831 table. dbx_end_psymtab will set the high text address of
1832 PST to the proper value, which is necessary if a module
1833 compiled without debugging info follows this module. */
1834 if (pst && gdbarch_sofun_address_maybe_missing (gdbarch))
1835 {
1836 dbx_end_psymtab (objfile, pst,
1837 psymtab_include_list, includes_used,
1838 symnum * symbol_size,
1839 (CORE_ADDR) 0, dependency_list,
1840 dependencies_used, textlow_not_set);
1841 pst = (struct partial_symtab *) 0;
1842 includes_used = 0;
1843 dependencies_used = 0;
1844 has_line_numbers = 0;
1845 }
1846 continue;
1847
1848 case N_RBRAC:
1849 #ifdef HANDLE_RBRAC
1850 HANDLE_RBRAC (nlist.n_value);
1851 continue;
1852 #endif
1853 case N_EINCL:
1854 case N_DSLINE:
1855 case N_BSLINE:
1856 case N_SSYM: /* Claim: Structure or union element.
1857 Hopefully, I can ignore this. */
1858 case N_ENTRY: /* Alternate entry point; can ignore. */
1859 case N_MAIN: /* Can definitely ignore this. */
1860 case N_CATCH: /* These are GNU C++ extensions */
1861 case N_EHDECL: /* that can safely be ignored here. */
1862 case N_LENG:
1863 case N_BCOMM:
1864 case N_ECOMM:
1865 case N_ECOML:
1866 case N_FNAME:
1867 case N_SLINE:
1868 case N_RSYM:
1869 case N_PSYM:
1870 case N_BNSYM:
1871 case N_ENSYM:
1872 case N_LBRAC:
1873 case N_NSYMS: /* Ultrix 4.0: symbol count */
1874 case N_DEFD: /* GNU Modula-2 */
1875 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
1876
1877 case N_OBJ: /* Useless types from Solaris. */
1878 case N_OPT:
1879 case N_PATCH:
1880 /* These symbols aren't interesting; don't worry about them. */
1881 continue;
1882
1883 default:
1884 /* If we haven't found it yet, ignore it. It's probably some
1885 new type we don't know about yet. */
1886 unknown_symtype_complaint (hex_string (nlist.n_type));
1887 continue;
1888 }
1889 }
1890
1891 /* If there's stuff to be cleaned up, clean it up. */
1892 if (pst)
1893 {
1894 /* Don't set high text address of PST lower than it already
1895 is. */
1896 CORE_ADDR text_end =
1897 (lowest_text_address == (CORE_ADDR) -1
1898 ? text_addr
1899 : lowest_text_address)
1900 + text_size;
1901
1902 dbx_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
1903 symnum * symbol_size,
1904 (text_end > pst->raw_text_high ()
1905 ? text_end : pst->raw_text_high ()),
1906 dependency_list, dependencies_used, textlow_not_set);
1907 }
1908 }
1909
1910 /* Allocate and partially fill a partial symtab. It will be
1911 completely filled at the end of the symbol list.
1912
1913 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1914 is the address relative to which its symbols are (incremental) or 0
1915 (normal). */
1916
1917 static struct partial_symtab *
1918 start_psymtab (struct objfile *objfile, const char *filename, CORE_ADDR textlow,
1919 int ldsymoff, std::vector<partial_symbol *> &global_psymbols,
1920 std::vector<partial_symbol *> &static_psymbols)
1921 {
1922 struct partial_symtab *result =
1923 start_psymtab_common (objfile, filename, textlow,
1924 global_psymbols, static_psymbols);
1925
1926 result->read_symtab_private =
1927 XOBNEW (&objfile->objfile_obstack, struct symloc);
1928 LDSYMOFF (result) = ldsymoff;
1929 result->read_symtab = dbx_read_symtab;
1930 SYMBOL_SIZE (result) = symbol_size;
1931 SYMBOL_OFFSET (result) = symbol_table_offset;
1932 STRING_OFFSET (result) = string_table_offset;
1933 FILE_STRING_OFFSET (result) = file_string_table_offset;
1934
1935 /* Deduce the source language from the filename for this psymtab. */
1936 psymtab_language = deduce_language_from_filename (filename);
1937 PST_LANGUAGE (result) = psymtab_language;
1938
1939 return result;
1940 }
1941
1942 /* Close off the current usage of PST.
1943 Returns PST or NULL if the partial symtab was empty and thrown away.
1944
1945 FIXME: List variables and peculiarities of same. */
1946
1947 struct partial_symtab *
1948 dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
1949 const char **include_list, int num_includes,
1950 int capping_symbol_offset, CORE_ADDR capping_text,
1951 struct partial_symtab **dependency_list,
1952 int number_dependencies,
1953 int textlow_not_set)
1954 {
1955 int i;
1956 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1957
1958 if (capping_symbol_offset != -1)
1959 LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
1960 pst->set_text_high (capping_text);
1961
1962 /* Under Solaris, the N_SO symbols always have a value of 0,
1963 instead of the usual address of the .o file. Therefore,
1964 we have to do some tricks to fill in texthigh and textlow.
1965 The first trick is: if we see a static
1966 or global function, and the textlow for the current pst
1967 is not set (ie: textlow_not_set), then we use that function's
1968 address for the textlow of the pst. */
1969
1970 /* Now, to fill in texthigh, we remember the last function seen
1971 in the .o file. Also, there's a hack in
1972 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1973 to here via the misc_info field. Therefore, we can fill in
1974 a reliable texthigh by taking the address plus size of the
1975 last function in the file. */
1976
1977 if (!pst->text_high_valid && last_function_name
1978 && gdbarch_sofun_address_maybe_missing (gdbarch))
1979 {
1980 int n;
1981 struct bound_minimal_symbol minsym;
1982
1983 const char *colon = strchr (last_function_name, ':');
1984 if (colon == NULL)
1985 n = 0;
1986 else
1987 n = colon - last_function_name;
1988 char *p = (char *) alloca (n + 2);
1989 strncpy (p, last_function_name, n);
1990 p[n] = 0;
1991
1992 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1993 if (minsym.minsym == NULL)
1994 {
1995 /* Sun Fortran appends an underscore to the minimal symbol name,
1996 try again with an appended underscore if the minimal symbol
1997 was not found. */
1998 p[n] = '_';
1999 p[n + 1] = 0;
2000 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
2001 }
2002
2003 if (minsym.minsym)
2004 pst->set_text_high (MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym)
2005 + MSYMBOL_SIZE (minsym.minsym));
2006
2007 last_function_name = NULL;
2008 }
2009
2010 if (!gdbarch_sofun_address_maybe_missing (gdbarch))
2011 ;
2012 /* This test will be true if the last .o file is only data. */
2013 else if (textlow_not_set)
2014 pst->set_text_low (pst->raw_text_high ());
2015 else
2016 {
2017 /* If we know our own starting text address, then walk through all other
2018 psymtabs for this objfile, and if any didn't know their ending text
2019 address, set it to our starting address. Take care to not set our
2020 own ending address to our starting address. */
2021
2022 for (partial_symtab *p1 : objfile_psymtabs (objfile))
2023 if (!p1->text_high_valid && p1->text_low_valid && p1 != pst)
2024 p1->set_text_high (pst->raw_text_low ());
2025 }
2026
2027 /* End of kludge for patching Solaris textlow and texthigh. */
2028
2029 end_psymtab_common (objfile, pst);
2030
2031 pst->number_of_dependencies = number_dependencies;
2032 if (number_dependencies)
2033 {
2034 pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
2035 struct partial_symtab *,
2036 number_dependencies);
2037 memcpy (pst->dependencies, dependency_list,
2038 number_dependencies * sizeof (struct partial_symtab *));
2039 }
2040 else
2041 pst->dependencies = 0;
2042
2043 for (i = 0; i < num_includes; i++)
2044 {
2045 struct partial_symtab *subpst =
2046 allocate_psymtab (include_list[i], objfile);
2047
2048 subpst->read_symtab_private =
2049 XOBNEW (&objfile->objfile_obstack, struct symloc);
2050 LDSYMOFF (subpst) =
2051 LDSYMLEN (subpst) = 0;
2052
2053 /* We could save slight bits of space by only making one of these,
2054 shared by the entire set of include files. FIXME-someday. */
2055 subpst->dependencies =
2056 XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
2057 subpst->dependencies[0] = pst;
2058 subpst->number_of_dependencies = 1;
2059
2060 subpst->read_symtab = pst->read_symtab;
2061 }
2062
2063 if (num_includes == 0
2064 && number_dependencies == 0
2065 && pst->n_global_syms == 0
2066 && pst->n_static_syms == 0
2067 && has_line_numbers == 0)
2068 {
2069 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2070 it is on the obstack, but we can forget to chain it on the list. */
2071 /* Empty psymtabs happen as a result of header files which don't have
2072 any symbols in them. There can be a lot of them. But this check
2073 is wrong, in that a psymtab with N_SLINE entries but nothing else
2074 is not empty, but we don't realize that. Fixing that without slowing
2075 things down might be tricky. */
2076
2077 discard_psymtab (objfile, pst);
2078
2079 /* Indicate that psymtab was thrown away. */
2080 pst = NULL;
2081 }
2082 return pst;
2083 }
2084 \f
2085 static void
2086 dbx_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
2087 {
2088 int i;
2089
2090 if (pst->readin)
2091 {
2092 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
2093 "Shouldn't happen.\n",
2094 pst->filename);
2095 return;
2096 }
2097
2098 /* Read in all partial symtabs on which this one is dependent. */
2099 for (i = 0; i < pst->number_of_dependencies; i++)
2100 if (!pst->dependencies[i]->readin)
2101 {
2102 /* Inform about additional files that need to be read in. */
2103 if (info_verbose)
2104 {
2105 fputs_filtered (" ", gdb_stdout);
2106 wrap_here ("");
2107 fputs_filtered ("and ", gdb_stdout);
2108 wrap_here ("");
2109 printf_filtered ("%s...", pst->dependencies[i]->filename);
2110 wrap_here (""); /* Flush output. */
2111 gdb_flush (gdb_stdout);
2112 }
2113 dbx_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
2114 }
2115
2116 if (LDSYMLEN (pst)) /* Otherwise it's a dummy. */
2117 {
2118 /* Init stuff necessary for reading in symbols */
2119 stabsread_init ();
2120 scoped_free_pendings free_pending;
2121 file_string_table_offset = FILE_STRING_OFFSET (pst);
2122 symbol_size = SYMBOL_SIZE (pst);
2123
2124 /* Read in this file's symbols. */
2125 bfd_seek (objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
2126 read_ofile_symtab (objfile, pst);
2127 }
2128
2129 pst->readin = 1;
2130 }
2131
2132 /* Read in all of the symbols for a given psymtab for real.
2133 Be verbose about it if the user wants that. SELF is not NULL. */
2134
2135 static void
2136 dbx_read_symtab (struct partial_symtab *self, struct objfile *objfile)
2137 {
2138 if (self->readin)
2139 {
2140 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
2141 "Shouldn't happen.\n",
2142 self->filename);
2143 return;
2144 }
2145
2146 if (LDSYMLEN (self) || self->number_of_dependencies)
2147 {
2148 /* Print the message now, before reading the string table,
2149 to avoid disconcerting pauses. */
2150 if (info_verbose)
2151 {
2152 printf_filtered ("Reading in symbols for %s...", self->filename);
2153 gdb_flush (gdb_stdout);
2154 }
2155
2156 next_symbol_text_func = dbx_next_symbol_text;
2157
2158 {
2159 scoped_restore restore_stabs_data = make_scoped_restore (&stabs_data);
2160 gdb::unique_xmalloc_ptr<gdb_byte> data_holder;
2161 if (DBX_STAB_SECTION (objfile))
2162 {
2163 stabs_data
2164 = symfile_relocate_debug_section (objfile,
2165 DBX_STAB_SECTION (objfile),
2166 NULL);
2167 data_holder.reset (stabs_data);
2168 }
2169
2170 dbx_psymtab_to_symtab_1 (objfile, self);
2171 }
2172
2173 /* Match with global symbols. This only needs to be done once,
2174 after all of the symtabs and dependencies have been read in. */
2175 scan_file_globals (objfile);
2176
2177 /* Finish up the debug error message. */
2178 if (info_verbose)
2179 printf_filtered ("done.\n");
2180 }
2181 }
2182
2183 /* Read in a defined section of a specific object file's symbols. */
2184
2185 static void
2186 read_ofile_symtab (struct objfile *objfile, struct partial_symtab *pst)
2187 {
2188 const char *namestring;
2189 struct external_nlist *bufp;
2190 struct internal_nlist nlist;
2191 unsigned char type;
2192 unsigned max_symnum;
2193 bfd *abfd;
2194 int sym_offset; /* Offset to start of symbols to read */
2195 int sym_size; /* Size of symbols to read */
2196 CORE_ADDR text_offset; /* Start of text segment for symbols */
2197 int text_size; /* Size of text segment for symbols */
2198 struct section_offsets *section_offsets;
2199
2200 sym_offset = LDSYMOFF (pst);
2201 sym_size = LDSYMLEN (pst);
2202 text_offset = pst->text_low (objfile);
2203 text_size = pst->text_high (objfile) - pst->text_low (objfile);
2204 section_offsets = objfile->section_offsets;
2205
2206 dbxread_objfile = objfile;
2207
2208 stringtab_global = DBX_STRINGTAB (objfile);
2209 set_last_source_file (NULL);
2210
2211 abfd = objfile->obfd;
2212 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol. */
2213 symbuf_end = symbuf_idx = 0;
2214 symbuf_read = 0;
2215 symbuf_left = sym_offset + sym_size;
2216
2217 /* It is necessary to actually read one symbol *before* the start
2218 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2219 occurs before the N_SO symbol.
2220
2221 Detecting this in read_dbx_symtab
2222 would slow down initial readin, so we look for it here instead. */
2223 if (!processing_acc_compilation && sym_offset >= (int) symbol_size)
2224 {
2225 stabs_seek (sym_offset - symbol_size);
2226 fill_symbuf (abfd);
2227 bufp = &symbuf[symbuf_idx++];
2228 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
2229 OBJSTAT (objfile, n_stabs++);
2230
2231 namestring = set_namestring (objfile, &nlist);
2232
2233 processing_gcc_compilation = 0;
2234 if (nlist.n_type == N_TEXT)
2235 {
2236 const char *tempstring = namestring;
2237
2238 if (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0)
2239 processing_gcc_compilation = 1;
2240 else if (strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0)
2241 processing_gcc_compilation = 2;
2242 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
2243 ++tempstring;
2244 if (startswith (tempstring, "__gnu_compiled"))
2245 processing_gcc_compilation = 2;
2246 }
2247 }
2248 else
2249 {
2250 /* The N_SO starting this symtab is the first symbol, so we
2251 better not check the symbol before it. I'm not this can
2252 happen, but it doesn't hurt to check for it. */
2253 stabs_seek (sym_offset);
2254 processing_gcc_compilation = 0;
2255 }
2256
2257 if (symbuf_idx == symbuf_end)
2258 fill_symbuf (abfd);
2259 bufp = &symbuf[symbuf_idx];
2260 if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO)
2261 error (_("First symbol in segment of executable not a source symbol"));
2262
2263 max_symnum = sym_size / symbol_size;
2264
2265 for (symnum = 0;
2266 symnum < max_symnum;
2267 symnum++)
2268 {
2269 QUIT; /* Allow this to be interruptable. */
2270 if (symbuf_idx == symbuf_end)
2271 fill_symbuf (abfd);
2272 bufp = &symbuf[symbuf_idx++];
2273 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
2274 OBJSTAT (objfile, n_stabs++);
2275
2276 type = bfd_h_get_8 (abfd, bufp->e_type);
2277
2278 namestring = set_namestring (objfile, &nlist);
2279
2280 if (type & N_STAB)
2281 {
2282 if (sizeof (nlist.n_value) > 4
2283 /* We are a 64-bit debugger debugging a 32-bit program. */
2284 && (type == N_LSYM || type == N_PSYM))
2285 /* We have to be careful with the n_value in the case of N_LSYM
2286 and N_PSYM entries, because they are signed offsets from frame
2287 pointer, but we actually read them as unsigned 32-bit values.
2288 This is not a problem for 32-bit debuggers, for which negative
2289 values end up being interpreted correctly (as negative
2290 offsets) due to integer overflow.
2291 But we need to sign-extend the value for 64-bit debuggers,
2292 or we'll end up interpreting negative values as very large
2293 positive offsets. */
2294 nlist.n_value = (nlist.n_value ^ 0x80000000) - 0x80000000;
2295 process_one_symbol (type, nlist.n_desc, nlist.n_value,
2296 namestring, section_offsets, objfile,
2297 PST_LANGUAGE (pst));
2298 }
2299 /* We skip checking for a new .o or -l file; that should never
2300 happen in this routine. */
2301 else if (type == N_TEXT)
2302 {
2303 /* I don't think this code will ever be executed, because
2304 the GCC_COMPILED_FLAG_SYMBOL usually is right before
2305 the N_SO symbol which starts this source file.
2306 However, there is no reason not to accept
2307 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
2308
2309 if (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0)
2310 processing_gcc_compilation = 1;
2311 else if (strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0)
2312 processing_gcc_compilation = 2;
2313 }
2314 else if (type & N_EXT || type == (unsigned char) N_TEXT
2315 || type == (unsigned char) N_NBTEXT)
2316 {
2317 /* Global symbol: see if we came across a dbx defintion for
2318 a corresponding symbol. If so, store the value. Remove
2319 syms from the chain when their values are stored, but
2320 search the whole chain, as there may be several syms from
2321 different files with the same name. */
2322 /* This is probably not true. Since the files will be read
2323 in one at a time, each reference to a global symbol will
2324 be satisfied in each file as it appears. So we skip this
2325 section. */
2326 ;
2327 }
2328 }
2329
2330 /* In a Solaris elf file, this variable, which comes from the value
2331 of the N_SO symbol, will still be 0. Luckily, text_offset, which
2332 comes from low text address of PST, is correct. */
2333 if (get_last_source_start_addr () == 0)
2334 set_last_source_start_addr (text_offset);
2335
2336 /* In reordered executables last_source_start_addr may not be the
2337 lower bound for this symtab, instead use text_offset which comes
2338 from the low text address of PST, which is correct. */
2339 if (get_last_source_start_addr () > text_offset)
2340 set_last_source_start_addr (text_offset);
2341
2342 pst->compunit_symtab = end_symtab (text_offset + text_size,
2343 SECT_OFF_TEXT (objfile));
2344
2345 end_stabs ();
2346
2347 dbxread_objfile = NULL;
2348 }
2349 \f
2350
2351 /* Record the namespace that the function defined by SYMBOL was
2352 defined in, if necessary. BLOCK is the associated block; use
2353 OBSTACK for allocation. */
2354
2355 static void
2356 cp_set_block_scope (const struct symbol *symbol,
2357 struct block *block,
2358 struct obstack *obstack)
2359 {
2360 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
2361 {
2362 /* Try to figure out the appropriate namespace from the
2363 demangled name. */
2364
2365 /* FIXME: carlton/2003-04-15: If the function in question is
2366 a method of a class, the name will actually include the
2367 name of the class as well. This should be harmless, but
2368 is a little unfortunate. */
2369
2370 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
2371 unsigned int prefix_len = cp_entire_prefix_len (name);
2372
2373 block_set_scope (block,
2374 (const char *) obstack_copy0 (obstack, name, prefix_len),
2375 obstack);
2376 }
2377 }
2378
2379 /* This handles a single symbol from the symbol-file, building symbols
2380 into a GDB symtab. It takes these arguments and an implicit argument.
2381
2382 TYPE is the type field of the ".stab" symbol entry.
2383 DESC is the desc field of the ".stab" entry.
2384 VALU is the value field of the ".stab" entry.
2385 NAME is the symbol name, in our address space.
2386 SECTION_OFFSETS is a set of amounts by which the sections of this
2387 object file were relocated when it was loaded into memory. Note
2388 that these section_offsets are not the objfile->section_offsets but
2389 the pst->section_offsets. All symbols that refer to memory
2390 locations need to be offset by these amounts.
2391 OBJFILE is the object file from which we are reading symbols. It
2392 is used in end_symtab.
2393 LANGUAGE is the language of the symtab.
2394 */
2395
2396 void
2397 process_one_symbol (int type, int desc, CORE_ADDR valu, const char *name,
2398 const struct section_offsets *section_offsets,
2399 struct objfile *objfile, enum language language)
2400 {
2401 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2402 struct context_stack *newobj;
2403 struct context_stack cstk;
2404 /* This remembers the address of the start of a function. It is
2405 used because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries
2406 are relative to the current function's start address. On systems
2407 other than Solaris 2, this just holds the SECT_OFF_TEXT value,
2408 and is used to relocate these symbol types rather than
2409 SECTION_OFFSETS. */
2410 static CORE_ADDR function_start_offset;
2411
2412 /* This holds the address of the start of a function, without the
2413 system peculiarities of function_start_offset. */
2414 static CORE_ADDR last_function_start;
2415
2416 /* If this is nonzero, we've seen an N_SLINE since the start of the
2417 current function. We use this to tell us to move the first sline
2418 to the beginning of the function regardless of what its given
2419 value is. */
2420 static int sline_found_in_function = 1;
2421
2422 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this
2423 source file. Used to detect the SunPRO solaris compiler. */
2424 static int n_opt_found;
2425
2426 /* Something is wrong if we see real data before seeing a source
2427 file name. */
2428
2429 if (get_last_source_file () == NULL && type != (unsigned char) N_SO)
2430 {
2431 /* Ignore any symbols which appear before an N_SO symbol.
2432 Currently no one puts symbols there, but we should deal
2433 gracefully with the case. A complain()t might be in order,
2434 but this should not be an error (). */
2435 return;
2436 }
2437
2438 switch (type)
2439 {
2440 case N_FUN:
2441 case N_FNAME:
2442
2443 if (*name == '\000')
2444 {
2445 /* This N_FUN marks the end of a function. This closes off
2446 the current block. */
2447 struct block *block;
2448
2449 if (outermost_context_p ())
2450 {
2451 lbrac_mismatch_complaint (symnum);
2452 break;
2453 }
2454
2455 /* The following check is added before recording line 0 at
2456 end of function so as to handle hand-generated stabs
2457 which may have an N_FUN stabs at the end of the function,
2458 but no N_SLINE stabs. */
2459 if (sline_found_in_function)
2460 {
2461 CORE_ADDR addr = last_function_start + valu;
2462
2463 record_line (get_current_subfile (), 0,
2464 gdbarch_addr_bits_remove (gdbarch, addr));
2465 }
2466
2467 within_function = 0;
2468 cstk = pop_context ();
2469
2470 /* Make a block for the local symbols within. */
2471 block = finish_block (cstk.name,
2472 cstk.old_blocks, NULL,
2473 cstk.start_addr, cstk.start_addr + valu);
2474
2475 /* For C++, set the block's scope. */
2476 if (SYMBOL_LANGUAGE (cstk.name) == language_cplus)
2477 cp_set_block_scope (cstk.name, block, &objfile->objfile_obstack);
2478
2479 /* May be switching to an assembler file which may not be using
2480 block relative stabs, so reset the offset. */
2481 function_start_offset = 0;
2482
2483 break;
2484 }
2485
2486 sline_found_in_function = 0;
2487
2488 /* Relocate for dynamic loading. */
2489 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2490 valu = gdbarch_addr_bits_remove (gdbarch, valu);
2491 last_function_start = valu;
2492
2493 goto define_a_symbol;
2494
2495 case N_LBRAC:
2496 /* This "symbol" just indicates the start of an inner lexical
2497 context within a function. */
2498
2499 /* Ignore extra outermost context from SunPRO cc and acc. */
2500 if (n_opt_found && desc == 1)
2501 break;
2502
2503 valu += function_start_offset;
2504
2505 push_context (desc, valu);
2506 break;
2507
2508 case N_RBRAC:
2509 /* This "symbol" just indicates the end of an inner lexical
2510 context that was started with N_LBRAC. */
2511
2512 /* Ignore extra outermost context from SunPRO cc and acc. */
2513 if (n_opt_found && desc == 1)
2514 break;
2515
2516 valu += function_start_offset;
2517
2518 if (outermost_context_p ())
2519 {
2520 lbrac_mismatch_complaint (symnum);
2521 break;
2522 }
2523
2524 cstk = pop_context ();
2525 if (desc != cstk.depth)
2526 lbrac_mismatch_complaint (symnum);
2527
2528 if (*get_local_symbols () != NULL)
2529 {
2530 /* GCC development snapshots from March to December of
2531 2000 would output N_LSYM entries after N_LBRAC
2532 entries. As a consequence, these symbols are simply
2533 discarded. Complain if this is the case. */
2534 complaint (_("misplaced N_LBRAC entry; discarding local "
2535 "symbols which have no enclosing block"));
2536 }
2537 *get_local_symbols () = cstk.locals;
2538
2539 if (get_context_stack_depth () > 1)
2540 {
2541 /* This is not the outermost LBRAC...RBRAC pair in the
2542 function, its local symbols preceded it, and are the ones
2543 just recovered from the context stack. Define the block
2544 for them (but don't bother if the block contains no
2545 symbols. Should we complain on blocks without symbols?
2546 I can't think of any useful purpose for them). */
2547 if (*get_local_symbols () != NULL)
2548 {
2549 /* Muzzle a compiler bug that makes end < start.
2550
2551 ??? Which compilers? Is this ever harmful?. */
2552 if (cstk.start_addr > valu)
2553 {
2554 complaint (_("block start larger than block end"));
2555 cstk.start_addr = valu;
2556 }
2557 /* Make a block for the local symbols within. */
2558 finish_block (0, cstk.old_blocks, NULL,
2559 cstk.start_addr, valu);
2560 }
2561 }
2562 else
2563 {
2564 /* This is the outermost LBRAC...RBRAC pair. There is no
2565 need to do anything; leave the symbols that preceded it
2566 to be attached to the function's own block. We need to
2567 indicate that we just moved outside of the function. */
2568 within_function = 0;
2569 }
2570
2571 break;
2572
2573 case N_FN:
2574 case N_FN_SEQ:
2575 /* This kind of symbol indicates the start of an object file.
2576 Relocate for dynamic loading. */
2577 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2578 break;
2579
2580 case N_SO:
2581 /* This type of symbol indicates the start of data for one
2582 source file. Finish the symbol table of the previous source
2583 file (if any) and start accumulating a new symbol table.
2584 Relocate for dynamic loading. */
2585 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2586
2587 n_opt_found = 0;
2588
2589 if (get_last_source_file ())
2590 {
2591 /* Check if previous symbol was also an N_SO (with some
2592 sanity checks). If so, that one was actually the
2593 directory name, and the current one is the real file
2594 name. Patch things up. */
2595 if (previous_stab_code == (unsigned char) N_SO)
2596 {
2597 patch_subfile_names (get_current_subfile (), name);
2598 break; /* Ignore repeated SOs. */
2599 }
2600 end_symtab (valu, SECT_OFF_TEXT (objfile));
2601 end_stabs ();
2602 }
2603
2604 /* Null name means this just marks the end of text for this .o
2605 file. Don't start a new symtab in this case. */
2606 if (*name == '\000')
2607 break;
2608
2609 function_start_offset = 0;
2610
2611 start_stabs ();
2612 start_symtab (objfile, name, NULL, valu, language);
2613 record_debugformat ("stabs");
2614 break;
2615
2616 case N_SOL:
2617 /* This type of symbol indicates the start of data for a
2618 sub-source-file, one whose contents were copied or included
2619 in the compilation of the main source file (whose name was
2620 given in the N_SO symbol). Relocate for dynamic loading. */
2621 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2622 start_subfile (name);
2623 break;
2624
2625 case N_BINCL:
2626 push_subfile ();
2627 add_new_header_file (name, valu);
2628 start_subfile (name);
2629 break;
2630
2631 case N_EINCL:
2632 start_subfile (pop_subfile ());
2633 break;
2634
2635 case N_EXCL:
2636 add_old_header_file (name, valu);
2637 break;
2638
2639 case N_SLINE:
2640 /* This type of "symbol" really just records one line-number --
2641 core-address correspondence. Enter it in the line list for
2642 this symbol table. */
2643
2644 /* Relocate for dynamic loading and for ELF acc
2645 function-relative symbols. */
2646 valu += function_start_offset;
2647
2648 /* GCC 2.95.3 emits the first N_SLINE stab somwehere in the
2649 middle of the prologue instead of right at the start of the
2650 function. To deal with this we record the address for the
2651 first N_SLINE stab to be the start of the function instead of
2652 the listed location. We really shouldn't to this. When
2653 compiling with optimization, this first N_SLINE stab might be
2654 optimized away. Other (non-GCC) compilers don't emit this
2655 stab at all. There is no real harm in having an extra
2656 numbered line, although it can be a bit annoying for the
2657 user. However, it totally screws up our testsuite.
2658
2659 So for now, keep adjusting the address of the first N_SLINE
2660 stab, but only for code compiled with GCC. */
2661
2662 if (within_function && sline_found_in_function == 0)
2663 {
2664 CORE_ADDR addr = processing_gcc_compilation == 2 ?
2665 last_function_start : valu;
2666
2667 record_line (get_current_subfile (), desc,
2668 gdbarch_addr_bits_remove (gdbarch, addr));
2669 sline_found_in_function = 1;
2670 }
2671 else
2672 record_line (get_current_subfile (), desc,
2673 gdbarch_addr_bits_remove (gdbarch, valu));
2674 break;
2675
2676 case N_BCOMM:
2677 common_block_start (name, objfile);
2678 break;
2679
2680 case N_ECOMM:
2681 common_block_end (objfile);
2682 break;
2683
2684 /* The following symbol types need to have the appropriate
2685 offset added to their value; then we process symbol
2686 definitions in the name. */
2687
2688 case N_STSYM: /* Static symbol in data segment. */
2689 case N_LCSYM: /* Static symbol in BSS segment. */
2690 case N_ROSYM: /* Static symbol in read-only data segment. */
2691 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2692 Solaris 2's stabs-in-elf makes *most* symbols relative but
2693 leaves a few absolute (at least for Solaris 2.1 and version
2694 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on
2695 the fence. .stab "foo:S...",N_STSYM is absolute (ld
2696 relocates it) .stab "foo:V...",N_STSYM is relative (section
2697 base subtracted). This leaves us no choice but to search for
2698 the 'S' or 'V'... (or pass the whole section_offsets stuff
2699 down ONE MORE function call level, which we really don't want
2700 to do). */
2701 {
2702 const char *p;
2703
2704 /* Normal object file and NLMs have non-zero text seg offsets,
2705 but don't need their static syms offset in this fashion.
2706 XXX - This is really a crock that should be fixed in the
2707 solib handling code so that I don't have to work around it
2708 here. */
2709
2710 if (!symfile_relocatable)
2711 {
2712 p = strchr (name, ':');
2713 if (p != 0 && p[1] == 'S')
2714 {
2715 /* The linker relocated it. We don't want to add a
2716 Sun-stabs Tfoo.foo-like offset, but we *do*
2717 want to add whatever solib.c passed to
2718 symbol_file_add as addr (this is known to affect
2719 SunOS 4, and I suspect ELF too). Since there is no
2720 Ttext.text symbol, we can get addr from the text offset. */
2721 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2722 goto define_a_symbol;
2723 }
2724 }
2725 /* Since it's not the kludge case, re-dispatch to the right
2726 handler. */
2727 switch (type)
2728 {
2729 case N_STSYM:
2730 goto case_N_STSYM;
2731 case N_LCSYM:
2732 goto case_N_LCSYM;
2733 case N_ROSYM:
2734 goto case_N_ROSYM;
2735 default:
2736 internal_error (__FILE__, __LINE__,
2737 _("failed internal consistency check"));
2738 }
2739 }
2740
2741 case_N_STSYM: /* Static symbol in data segment. */
2742 case N_DSLINE: /* Source line number, data segment. */
2743 valu += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
2744 goto define_a_symbol;
2745
2746 case_N_LCSYM: /* Static symbol in BSS segment. */
2747 case N_BSLINE: /* Source line number, BSS segment. */
2748 /* N_BROWS: overlaps with N_BSLINE. */
2749 valu += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
2750 goto define_a_symbol;
2751
2752 case_N_ROSYM: /* Static symbol in read-only data segment. */
2753 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA (objfile));
2754 goto define_a_symbol;
2755
2756 case N_ENTRY: /* Alternate entry point. */
2757 /* Relocate for dynamic loading. */
2758 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2759 goto define_a_symbol;
2760
2761 /* The following symbol types we don't know how to process.
2762 Handle them in a "default" way, but complain to people who
2763 care. */
2764 default:
2765 case N_CATCH: /* Exception handler catcher. */
2766 case N_EHDECL: /* Exception handler name. */
2767 case N_PC: /* Global symbol in Pascal. */
2768 case N_M2C: /* Modula-2 compilation unit. */
2769 /* N_MOD2: overlaps with N_EHDECL. */
2770 case N_SCOPE: /* Modula-2 scope information. */
2771 case N_ECOML: /* End common (local name). */
2772 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
2773 case N_NBDATA:
2774 case N_NBBSS:
2775 case N_NBSTS:
2776 case N_NBLCS:
2777 unknown_symtype_complaint (hex_string (type));
2778 /* FALLTHROUGH */
2779
2780 define_a_symbol:
2781 /* These symbol types don't need the address field relocated,
2782 since it is either unused, or is absolute. */
2783 case N_GSYM: /* Global variable. */
2784 case N_NSYMS: /* Number of symbols (Ultrix). */
2785 case N_NOMAP: /* No map? (Ultrix). */
2786 case N_RSYM: /* Register variable. */
2787 case N_DEFD: /* Modula-2 GNU module dependency. */
2788 case N_SSYM: /* Struct or union element. */
2789 case N_LSYM: /* Local symbol in stack. */
2790 case N_PSYM: /* Parameter variable. */
2791 case N_LENG: /* Length of preceding symbol type. */
2792 if (name)
2793 {
2794 int deftype;
2795 const char *colon_pos = strchr (name, ':');
2796
2797 if (colon_pos == NULL)
2798 deftype = '\0';
2799 else
2800 deftype = colon_pos[1];
2801
2802 switch (deftype)
2803 {
2804 case 'f':
2805 case 'F':
2806 /* Deal with the SunPRO 3.0 compiler which omits the
2807 address from N_FUN symbols. */
2808 if (type == N_FUN
2809 && valu == ANOFFSET (section_offsets,
2810 SECT_OFF_TEXT (objfile))
2811 && gdbarch_sofun_address_maybe_missing (gdbarch))
2812 {
2813 struct bound_minimal_symbol minsym
2814 = find_stab_function (name, get_last_source_file (),
2815 objfile);
2816 if (minsym.minsym != NULL)
2817 valu = BMSYMBOL_VALUE_ADDRESS (minsym);
2818 }
2819
2820 /* These addresses are absolute. */
2821 function_start_offset = valu;
2822
2823 within_function = 1;
2824
2825 if (get_context_stack_depth () > 1)
2826 {
2827 complaint (_("unmatched N_LBRAC before symtab pos %d"),
2828 symnum);
2829 break;
2830 }
2831
2832 if (!outermost_context_p ())
2833 {
2834 struct block *block;
2835
2836 cstk = pop_context ();
2837 /* Make a block for the local symbols within. */
2838 block = finish_block (cstk.name,
2839 cstk.old_blocks, NULL,
2840 cstk.start_addr, valu);
2841
2842 /* For C++, set the block's scope. */
2843 if (SYMBOL_LANGUAGE (cstk.name) == language_cplus)
2844 cp_set_block_scope (cstk.name, block,
2845 &objfile->objfile_obstack);
2846 }
2847
2848 newobj = push_context (0, valu);
2849 newobj->name = define_symbol (valu, name, desc, type, objfile);
2850 break;
2851
2852 default:
2853 define_symbol (valu, name, desc, type, objfile);
2854 break;
2855 }
2856 }
2857 break;
2858
2859 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2860 for a bunch of other flags, too. Someday we may parse their
2861 flags; for now we ignore theirs and hope they'll ignore ours. */
2862 case N_OPT: /* Solaris 2: Compiler options. */
2863 if (name)
2864 {
2865 if (strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)
2866 {
2867 processing_gcc_compilation = 2;
2868 }
2869 else
2870 n_opt_found = 1;
2871 }
2872 break;
2873
2874 case N_MAIN: /* Name of main routine. */
2875 /* FIXME: If one has a symbol file with N_MAIN and then replaces
2876 it with a symbol file with "main" and without N_MAIN. I'm
2877 not sure exactly what rule to follow but probably something
2878 like: N_MAIN takes precedence over "main" no matter what
2879 objfile it is in; If there is more than one N_MAIN, choose
2880 the one in the symfile_objfile; If there is more than one
2881 N_MAIN within a given objfile, complain() and choose
2882 arbitrarily. (kingdon) */
2883 if (name != NULL)
2884 set_objfile_main_name (objfile, name, language_unknown);
2885 break;
2886
2887 /* The following symbol types can be ignored. */
2888 case N_OBJ: /* Solaris 2: Object file dir and name. */
2889 case N_PATCH: /* Solaris 2: Patch Run Time Checker. */
2890 /* N_UNDF: Solaris 2: File separator mark. */
2891 /* N_UNDF: -- we will never encounter it, since we only process
2892 one file's symbols at once. */
2893 case N_ENDM: /* Solaris 2: End of module. */
2894 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
2895 break;
2896 }
2897
2898 /* '#' is a GNU C extension to allow one symbol to refer to another
2899 related symbol.
2900
2901 Generally this is used so that an alias can refer to its main
2902 symbol. */
2903 gdb_assert (name);
2904 if (name[0] == '#')
2905 {
2906 /* Initialize symbol reference names and determine if this is a
2907 definition. If a symbol reference is being defined, go ahead
2908 and add it. Otherwise, just return. */
2909
2910 const char *s = name;
2911 int refnum;
2912
2913 /* If this stab defines a new reference ID that is not on the
2914 reference list, then put it on the reference list.
2915
2916 We go ahead and advance NAME past the reference, even though
2917 it is not strictly necessary at this time. */
2918 refnum = symbol_reference_defined (&s);
2919 if (refnum >= 0)
2920 if (!ref_search (refnum))
2921 ref_add (refnum, 0, name, valu);
2922 name = s;
2923 }
2924
2925 previous_stab_code = type;
2926 }
2927 \f
2928 /* FIXME: The only difference between this and elfstab_build_psymtabs
2929 is the call to install_minimal_symbols for elf, and the support for
2930 split sections. If the differences are really that small, the code
2931 should be shared. */
2932
2933 /* Scan and build partial symbols for an coff symbol file.
2934 The coff file has already been processed to get its minimal symbols.
2935
2936 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2937 rolled into one.
2938
2939 OBJFILE is the object file we are reading symbols from.
2940 ADDR is the address relative to which the symbols are (e.g.
2941 the base address of the text segment).
2942 TEXTADDR is the address of the text section.
2943 TEXTSIZE is the size of the text section.
2944 STABSECTS is the list of .stab sections in OBJFILE.
2945 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2946 .stabstr section exists.
2947
2948 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2949 adjusted for coff details. */
2950
2951 void
2952 coffstab_build_psymtabs (struct objfile *objfile,
2953 CORE_ADDR textaddr, unsigned int textsize,
2954 struct stab_section_list *stabsects,
2955 file_ptr stabstroffset, unsigned int stabstrsize)
2956 {
2957 int val;
2958 bfd *sym_bfd = objfile->obfd;
2959 char *name = bfd_get_filename (sym_bfd);
2960 unsigned int stabsize;
2961
2962 DBX_TEXT_ADDR (objfile) = textaddr;
2963 DBX_TEXT_SIZE (objfile) = textsize;
2964
2965 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2966 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
2967 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2968
2969 if (stabstrsize > bfd_get_size (sym_bfd))
2970 error (_("ridiculous string table size: %d bytes"), stabstrsize);
2971 DBX_STRINGTAB (objfile) = (char *)
2972 obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1);
2973 OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
2974
2975 /* Now read in the string table in one big gulp. */
2976
2977 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2978 if (val < 0)
2979 perror_with_name (name);
2980 val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
2981 if (val != stabstrsize)
2982 perror_with_name (name);
2983
2984 stabsread_new_init ();
2985 free_header_files ();
2986 init_header_files ();
2987
2988 processing_acc_compilation = 1;
2989
2990 /* In a coff file, we've already installed the minimal symbols that came
2991 from the coff (non-stab) symbol table, so always act like an
2992 incremental load here. */
2993 if (stabsects->next == NULL)
2994 {
2995 stabsize = bfd_section_size (sym_bfd, stabsects->section);
2996 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2997 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2998 }
2999 else
3000 {
3001 struct stab_section_list *stabsect;
3002
3003 DBX_SYMCOUNT (objfile) = 0;
3004 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
3005 {
3006 stabsize = bfd_section_size (sym_bfd, stabsect->section);
3007 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
3008 }
3009
3010 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
3011
3012 symbuf_sections = stabsects->next;
3013 symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
3014 symbuf_read = 0;
3015 }
3016
3017 dbx_symfile_read (objfile, 0);
3018 }
3019 \f
3020 /* Scan and build partial symbols for an ELF symbol file.
3021 This ELF file has already been processed to get its minimal symbols.
3022
3023 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3024 rolled into one.
3025
3026 OBJFILE is the object file we are reading symbols from.
3027 ADDR is the address relative to which the symbols are (e.g.
3028 the base address of the text segment).
3029 STABSECT is the BFD section information for the .stab section.
3030 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
3031 .stabstr section exists.
3032
3033 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
3034 adjusted for elf details. */
3035
3036 void
3037 elfstab_build_psymtabs (struct objfile *objfile, asection *stabsect,
3038 file_ptr stabstroffset, unsigned int stabstrsize)
3039 {
3040 int val;
3041 bfd *sym_bfd = objfile->obfd;
3042 char *name = bfd_get_filename (sym_bfd);
3043
3044 /* Find the first and last text address. dbx_symfile_read seems to
3045 want this. */
3046 find_text_range (sym_bfd, objfile);
3047
3048 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
3049 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
3050 DBX_SYMCOUNT (objfile)
3051 = bfd_section_size (objfile->obfd, stabsect) / DBX_SYMBOL_SIZE (objfile);
3052 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
3053 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos;
3054 DBX_STAB_SECTION (objfile) = stabsect;
3055
3056 if (stabstrsize > bfd_get_size (sym_bfd))
3057 error (_("ridiculous string table size: %d bytes"), stabstrsize);
3058 DBX_STRINGTAB (objfile) = (char *)
3059 obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1);
3060 OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
3061
3062 /* Now read in the string table in one big gulp. */
3063
3064 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
3065 if (val < 0)
3066 perror_with_name (name);
3067 val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
3068 if (val != stabstrsize)
3069 perror_with_name (name);
3070
3071 stabsread_new_init ();
3072 free_header_files ();
3073 init_header_files ();
3074
3075 processing_acc_compilation = 1;
3076
3077 symbuf_read = 0;
3078 symbuf_left = bfd_section_size (objfile->obfd, stabsect);
3079
3080 scoped_restore restore_stabs_data = make_scoped_restore (&stabs_data);
3081 gdb::unique_xmalloc_ptr<gdb_byte> data_holder;
3082
3083 stabs_data = symfile_relocate_debug_section (objfile, stabsect, NULL);
3084 if (stabs_data)
3085 data_holder.reset (stabs_data);
3086
3087 /* In an elf file, we've already installed the minimal symbols that came
3088 from the elf (non-stab) symbol table, so always act like an
3089 incremental load here. dbx_symfile_read should not generate any new
3090 minimal symbols, since we will have already read the ELF dynamic symbol
3091 table and normal symbol entries won't be in the ".stab" section; but in
3092 case it does, it will install them itself. */
3093 dbx_symfile_read (objfile, 0);
3094 }
3095 \f
3096 /* Scan and build partial symbols for a file with special sections for stabs
3097 and stabstrings. The file has already been processed to get its minimal
3098 symbols, and any other symbols that might be necessary to resolve GSYMs.
3099
3100 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3101 rolled into one.
3102
3103 OBJFILE is the object file we are reading symbols from.
3104 ADDR is the address relative to which the symbols are (e.g. the base address
3105 of the text segment).
3106 STAB_NAME is the name of the section that contains the stabs.
3107 STABSTR_NAME is the name of the section that contains the stab strings.
3108
3109 This routine is mostly copied from dbx_symfile_init and
3110 dbx_symfile_read. */
3111
3112 void
3113 stabsect_build_psymtabs (struct objfile *objfile, char *stab_name,
3114 char *stabstr_name, char *text_name)
3115 {
3116 int val;
3117 bfd *sym_bfd = objfile->obfd;
3118 char *name = bfd_get_filename (sym_bfd);
3119 asection *stabsect;
3120 asection *stabstrsect;
3121 asection *text_sect;
3122 struct dbx_symfile_info *dbx;
3123
3124 stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
3125 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
3126
3127 if (!stabsect)
3128 return;
3129
3130 if (!stabstrsect)
3131 error (_("stabsect_build_psymtabs: Found stabs (%s), "
3132 "but not string section (%s)"),
3133 stab_name, stabstr_name);
3134
3135 dbx = XCNEW (struct dbx_symfile_info);
3136 set_objfile_data (objfile, dbx_objfile_data_key, dbx);
3137
3138 text_sect = bfd_get_section_by_name (sym_bfd, text_name);
3139 if (!text_sect)
3140 error (_("Can't find %s section in symbol file"), text_name);
3141 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
3142 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
3143
3144 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
3145 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
3146 / DBX_SYMBOL_SIZE (objfile);
3147 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
3148 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING
3149 INSIDE BFD DATA
3150 STRUCTURES */
3151
3152 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
3153 error (_("ridiculous string table size: %d bytes"),
3154 DBX_STRINGTAB_SIZE (objfile));
3155 DBX_STRINGTAB (objfile) = (char *)
3156 obstack_alloc (&objfile->objfile_obstack,
3157 DBX_STRINGTAB_SIZE (objfile) + 1);
3158 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
3159
3160 /* Now read in the string table in one big gulp. */
3161
3162 val = bfd_get_section_contents (sym_bfd, /* bfd */
3163 stabstrsect, /* bfd section */
3164 DBX_STRINGTAB (objfile), /* input buffer */
3165 0, /* offset into section */
3166 DBX_STRINGTAB_SIZE (objfile)); /* amount to
3167 read */
3168
3169 if (!val)
3170 perror_with_name (name);
3171
3172 stabsread_new_init ();
3173 free_header_files ();
3174 init_header_files ();
3175
3176 /* Now, do an incremental load. */
3177
3178 processing_acc_compilation = 1;
3179 dbx_symfile_read (objfile, 0);
3180 }
3181 \f
3182 static const struct sym_fns aout_sym_fns =
3183 {
3184 dbx_new_init, /* init anything gbl to entire symtab */
3185 dbx_symfile_init, /* read initial info, setup for sym_read() */
3186 dbx_symfile_read, /* read a symbol file into symtab */
3187 NULL, /* sym_read_psymbols */
3188 dbx_symfile_finish, /* finished with file, cleanup */
3189 default_symfile_offsets, /* parse user's offsets to internal form */
3190 default_symfile_segments, /* Get segment information from a file. */
3191 NULL,
3192 default_symfile_relocate, /* Relocate a debug section. */
3193 NULL, /* sym_probe_fns */
3194 &psym_functions
3195 };
3196
3197 void
3198 _initialize_dbxread (void)
3199 {
3200 add_symtab_fns (bfd_target_aout_flavour, &aout_sym_fns);
3201
3202 dbx_objfile_data_key
3203 = register_objfile_data_with_cleanup (NULL, dbx_free_symfile_info);
3204 }
This page took 0.093207 seconds and 5 git commands to generate.