No longer need to sanitize away h8s stuff.
[deliverable/binutils-gdb.git] / gdb / dbxread.c
1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
25 from a file.
26
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
34
35 #include "defs.h"
36 #include "gdb_string.h"
37
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
40 #include <fcntl.h>
41 #endif
42
43 #include "obstack.h"
44 #include <sys/param.h>
45 #ifndef NO_SYS_FILE
46 #include <sys/file.h>
47 #endif
48 #include "gdb_stat.h"
49 #include <ctype.h>
50 #include "symtab.h"
51 #include "breakpoint.h"
52 #include "command.h"
53 #include "target.h"
54 #include "gdbcore.h" /* for bfd stuff */
55 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
56 #include "symfile.h"
57 #include "objfiles.h"
58 #include "buildsym.h"
59 #include "stabsread.h"
60 #include "gdb-stabs.h"
61 #include "demangle.h"
62 #include "language.h" /* Needed inside partial-stab.h */
63 #include "complaints.h"
64
65 #include "aout/aout64.h"
66 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
67
68 /* defined in stabsread.c; used for completing cfront stabs strings */
69 extern void
70 resolve_cfront_continuation PARAMS((struct objfile * objfile,
71 struct symbol * sym, char * p));
72
73 \f
74 /* We put a pointer to this structure in the read_symtab_private field
75 of the psymtab. */
76
77 struct symloc {
78
79 /* Offset within the file symbol table of first local symbol for this
80 file. */
81
82 int ldsymoff;
83
84 /* Length (in bytes) of the section of the symbol table devoted to
85 this file's symbols (actually, the section bracketed may contain
86 more than just this file's symbols). If ldsymlen is 0, the only
87 reason for this thing's existence is the dependency list. Nothing
88 else will happen when it is read in. */
89
90 int ldsymlen;
91
92 /* The size of each symbol in the symbol file (in external form). */
93
94 int symbol_size;
95
96 /* Further information needed to locate the symbols if they are in
97 an ELF file. */
98
99 int symbol_offset;
100 int string_offset;
101 int file_string_offset;
102 };
103
104 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
105 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
106 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
107 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
108 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
109 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
110 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
111
112 \f
113 /* Macro to determine which symbols to ignore when reading the first symbol
114 of a file. Some machines override this definition. */
115 #ifndef IGNORE_SYMBOL
116 /* This code is used on Ultrix systems. Ignore it */
117 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
118 #endif
119
120 /* Remember what we deduced to be the source language of this psymtab. */
121
122 static enum language psymtab_language = language_unknown;
123
124 /* Nonzero means give verbose info on gdb action. From main.c. */
125 extern int info_verbose;
126
127 /* The BFD for this file -- implicit parameter to next_symbol_text. */
128
129 static bfd *symfile_bfd;
130
131 /* The size of each symbol in the symbol file (in external form).
132 This is set by dbx_symfile_read when building psymtabs, and by
133 dbx_psymtab_to_symtab when building symtabs. */
134
135 static unsigned symbol_size;
136
137 /* This is the offset of the symbol table in the executable file */
138 static unsigned symbol_table_offset;
139
140 /* This is the offset of the string table in the executable file */
141 static unsigned string_table_offset;
142
143 /* For elf+stab executables, the n_strx field is not a simple index
144 into the string table. Instead, each .o file has a base offset
145 in the string table, and the associated symbols contain offsets
146 from this base. The following two variables contain the base
147 offset for the current and next .o files. */
148 static unsigned int file_string_table_offset;
149 static unsigned int next_file_string_table_offset;
150
151 /* .o and NLM files contain unrelocated addresses which are based at 0. When
152 non-zero, this flag disables some of the special cases for Solaris elf+stab
153 text addresses at location 0. */
154
155 static int symfile_relocatable = 0;
156
157 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
158 to the function start address. */
159
160 static int block_address_function_relative = 0;
161 \f
162 /* The lowest text address we have yet encountered. This is needed
163 because in an a.out file, there is no header field which tells us
164 what address the program is actually going to be loaded at, so we
165 need to make guesses based on the symbols (which *are* relocated to
166 reflect the address it will be loaded at). */
167 static CORE_ADDR lowest_text_address;
168
169 /* Complaints about the symbols we have encountered. */
170
171 struct complaint lbrac_complaint =
172 {"bad block start address patched", 0, 0};
173
174 struct complaint string_table_offset_complaint =
175 {"bad string table offset in symbol %d", 0, 0};
176
177 struct complaint unknown_symtype_complaint =
178 {"unknown symbol type %s", 0, 0};
179
180 struct complaint unknown_symchar_complaint =
181 {"unknown symbol descriptor `%c'", 0, 0};
182
183 struct complaint lbrac_rbrac_complaint =
184 {"block start larger than block end", 0, 0};
185
186 struct complaint lbrac_unmatched_complaint =
187 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
188
189 struct complaint lbrac_mismatch_complaint =
190 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
191
192 struct complaint repeated_header_complaint =
193 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
194 \f
195 /* During initial symbol readin, we need to have a structure to keep
196 track of which psymtabs have which bincls in them. This structure
197 is used during readin to setup the list of dependencies within each
198 partial symbol table. */
199
200 struct header_file_location
201 {
202 char *name; /* Name of header file */
203 int instance; /* See above */
204 struct partial_symtab *pst; /* Partial symtab that has the
205 BINCL/EINCL defs for this file */
206 };
207
208 /* The actual list and controling variables */
209 static struct header_file_location *bincl_list, *next_bincl;
210 static int bincls_allocated;
211
212 /* Local function prototypes */
213
214 static void
215 free_header_files PARAMS ((void));
216
217 static void
218 init_header_files PARAMS ((void));
219
220 static void
221 read_ofile_symtab PARAMS ((struct partial_symtab *));
222
223 static void
224 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
225
226 static void
227 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
228
229 static void
230 read_dbx_dynamic_symtab PARAMS ((struct section_offsets *,
231 struct objfile *objfile));
232
233 static void
234 read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
235 CORE_ADDR, int));
236
237 static void
238 free_bincl_list PARAMS ((struct objfile *));
239
240 static struct partial_symtab *
241 find_corresponding_bincl_psymtab PARAMS ((char *, int));
242
243 static void
244 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
245
246 static void
247 init_bincl_list PARAMS ((int, struct objfile *));
248
249 static char *
250 dbx_next_symbol_text PARAMS ((struct objfile *));
251
252 static void
253 fill_symbuf PARAMS ((bfd *));
254
255 static void
256 dbx_symfile_init PARAMS ((struct objfile *));
257
258 static void
259 dbx_new_init PARAMS ((struct objfile *));
260
261 static void
262 dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
263
264 static void
265 dbx_symfile_finish PARAMS ((struct objfile *));
266
267 static void
268 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
269
270 static void
271 add_new_header_file PARAMS ((char *, int));
272
273 static void
274 add_old_header_file PARAMS ((char *, int));
275
276 static void
277 add_this_object_header_file PARAMS ((int));
278
279 /* Free up old header file tables */
280
281 static void
282 free_header_files ()
283 {
284 register int i;
285
286 if (header_files != NULL)
287 {
288 for (i = 0; i < n_header_files; i++)
289 {
290 free (header_files[i].name);
291 }
292 free ((PTR)header_files);
293 header_files = NULL;
294 n_header_files = 0;
295 }
296 if (this_object_header_files)
297 {
298 free ((PTR)this_object_header_files);
299 this_object_header_files = NULL;
300 }
301 n_allocated_header_files = 0;
302 n_allocated_this_object_header_files = 0;
303 }
304
305 /* Allocate new header file tables */
306
307 static void
308 init_header_files ()
309 {
310 n_header_files = 0;
311 n_allocated_header_files = 10;
312 header_files = (struct header_file *)
313 xmalloc (10 * sizeof (struct header_file));
314
315 n_allocated_this_object_header_files = 10;
316 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
317 }
318
319 /* Add header file number I for this object file
320 at the next successive FILENUM. */
321
322 static void
323 add_this_object_header_file (i)
324 int i;
325 {
326 if (n_this_object_header_files == n_allocated_this_object_header_files)
327 {
328 n_allocated_this_object_header_files *= 2;
329 this_object_header_files
330 = (int *) xrealloc ((char *) this_object_header_files,
331 n_allocated_this_object_header_files * sizeof (int));
332 }
333
334 this_object_header_files[n_this_object_header_files++] = i;
335 }
336
337 /* Add to this file an "old" header file, one already seen in
338 a previous object file. NAME is the header file's name.
339 INSTANCE is its instance code, to select among multiple
340 symbol tables for the same header file. */
341
342 static void
343 add_old_header_file (name, instance)
344 char *name;
345 int instance;
346 {
347 register struct header_file *p = header_files;
348 register int i;
349
350 for (i = 0; i < n_header_files; i++)
351 if (STREQ (p[i].name, name) && instance == p[i].instance)
352 {
353 add_this_object_header_file (i);
354 return;
355 }
356 complain (&repeated_header_complaint, name, symnum);
357 }
358
359 /* Add to this file a "new" header file: definitions for its types follow.
360 NAME is the header file's name.
361 Most often this happens only once for each distinct header file,
362 but not necessarily. If it happens more than once, INSTANCE has
363 a different value each time, and references to the header file
364 use INSTANCE values to select among them.
365
366 dbx output contains "begin" and "end" markers for each new header file,
367 but at this level we just need to know which files there have been;
368 so we record the file when its "begin" is seen and ignore the "end". */
369
370 static void
371 add_new_header_file (name, instance)
372 char *name;
373 int instance;
374 {
375 register int i;
376
377 /* Make sure there is room for one more header file. */
378
379 if (n_header_files == n_allocated_header_files)
380 {
381 n_allocated_header_files *= 2;
382 header_files = (struct header_file *)
383 xrealloc ((char *) header_files,
384 (n_allocated_header_files * sizeof (struct header_file)));
385 }
386
387 /* Create an entry for this header file. */
388
389 i = n_header_files++;
390 header_files[i].name = savestring (name, strlen(name));
391 header_files[i].instance = instance;
392 header_files[i].length = 10;
393 header_files[i].vector
394 = (struct type **) xmalloc (10 * sizeof (struct type *));
395 memset (header_files[i].vector, 0, 10 * sizeof (struct type *));
396
397 add_this_object_header_file (i);
398 }
399
400 #if 0
401 static struct type **
402 explicit_lookup_type (real_filenum, index)
403 int real_filenum, index;
404 {
405 register struct header_file *f = &header_files[real_filenum];
406
407 if (index >= f->length)
408 {
409 f->length *= 2;
410 f->vector = (struct type **)
411 xrealloc (f->vector, f->length * sizeof (struct type *));
412 memset (&f->vector[f->length / 2],
413 '\0', f->length * sizeof (struct type *) / 2);
414 }
415 return &f->vector[index];
416 }
417 #endif
418 \f
419 static void
420 record_minimal_symbol (name, address, type, objfile)
421 char *name;
422 CORE_ADDR address;
423 int type;
424 struct objfile *objfile;
425 {
426 enum minimal_symbol_type ms_type;
427 int section;
428
429 switch (type)
430 {
431 case N_TEXT | N_EXT:
432 ms_type = mst_text;
433 section = SECT_OFF_TEXT;
434 break;
435 case N_DATA | N_EXT:
436 ms_type = mst_data;
437 section = SECT_OFF_DATA;
438 break;
439 case N_BSS | N_EXT:
440 ms_type = mst_bss;
441 section = SECT_OFF_BSS;
442 break;
443 case N_ABS | N_EXT:
444 ms_type = mst_abs;
445 section = -1;
446 break;
447 #ifdef N_SETV
448 case N_SETV | N_EXT:
449 ms_type = mst_data;
450 section = SECT_OFF_DATA;
451 break;
452 case N_SETV:
453 /* I don't think this type actually exists; since a N_SETV is the result
454 of going over many .o files, it doesn't make sense to have one
455 file local. */
456 ms_type = mst_file_data;
457 section = SECT_OFF_DATA;
458 break;
459 #endif
460 case N_TEXT:
461 case N_NBTEXT:
462 case N_FN:
463 case N_FN_SEQ:
464 ms_type = mst_file_text;
465 section = SECT_OFF_TEXT;
466 break;
467 case N_DATA:
468 ms_type = mst_file_data;
469
470 /* Check for __DYNAMIC, which is used by Sun shared libraries.
471 Record it as global even if it's local, not global, so
472 lookup_minimal_symbol can find it. We don't check symbol_leading_char
473 because for SunOS4 it always is '_'. */
474 if (name[8] == 'C' && STREQ ("__DYNAMIC", name))
475 ms_type = mst_data;
476
477 /* Same with virtual function tables, both global and static. */
478 {
479 char *tempstring = name;
480 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
481 ++tempstring;
482 if (VTBL_PREFIX_P ((tempstring)))
483 ms_type = mst_data;
484 }
485 section = SECT_OFF_DATA;
486 break;
487 case N_BSS:
488 ms_type = mst_file_bss;
489 section = SECT_OFF_BSS;
490 break;
491 default:
492 ms_type = mst_unknown;
493 section = -1;
494 break;
495 }
496
497 if ((ms_type == mst_file_text || ms_type == mst_text)
498 && address < lowest_text_address)
499 lowest_text_address = address;
500
501 prim_record_minimal_symbol_and_info
502 (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
503 address,
504 ms_type,
505 NULL,
506 section,
507 objfile);
508 }
509 \f
510 /* Scan and build partial symbols for a symbol file.
511 We have been initialized by a call to dbx_symfile_init, which
512 put all the relevant info into a "struct dbx_symfile_info",
513 hung off the objfile structure.
514
515 SECTION_OFFSETS contains offsets relative to which the symbols in the
516 various sections are (depending where the sections were actually loaded).
517 MAINLINE is true if we are reading the main symbol
518 table (as opposed to a shared lib or dynamically loaded file). */
519
520 static void
521 dbx_symfile_read (objfile, section_offsets, mainline)
522 struct objfile *objfile;
523 struct section_offsets *section_offsets;
524 int mainline; /* FIXME comments above */
525 {
526 bfd *sym_bfd;
527 int val;
528 struct cleanup *back_to;
529
530 val = strlen (objfile->name);
531
532 /* .o and .nlm files are relocatables with text, data and bss segs based at
533 0. This flag disables special (Solaris stabs-in-elf only) fixups for
534 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
535 should be fixed to determine pst->textlow without using this text seg of
536 0 fixup crap. */
537
538 if (strcmp (&objfile->name[val-2], ".o") == 0
539 || strcmp (&objfile->name[val-4], ".nlm") == 0)
540 symfile_relocatable = 1;
541
542 /* This is true for Solaris (and all other systems which put stabs
543 in sections, hopefully, since it would be silly to do things
544 differently from Solaris), and false for SunOS4 and other a.out
545 file formats. */
546 block_address_function_relative =
547 ((0 == strncmp (bfd_get_target (objfile->obfd), "elf", 3))
548 || (0 == strncmp (bfd_get_target (objfile->obfd), "som", 3))
549 || (0 == strncmp (bfd_get_target (objfile->obfd), "coff", 4))
550 || (0 == strncmp (bfd_get_target (objfile->obfd), "pe", 2))
551 || (0 == strncmp (bfd_get_target (objfile->obfd), "nlm", 3)));
552
553 sym_bfd = objfile->obfd;
554 val = bfd_seek (objfile->obfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
555 if (val < 0)
556 perror_with_name (objfile->name);
557
558 /* If we are reinitializing, or if we have never loaded syms yet, init */
559 if (mainline
560 || objfile->global_psymbols.size == 0
561 || objfile->static_psymbols.size == 0)
562 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
563
564 symbol_size = DBX_SYMBOL_SIZE (objfile);
565 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
566
567 pending_blocks = 0;
568 back_to = make_cleanup (really_free_pendings, 0);
569
570 init_minimal_symbol_collection ();
571 make_cleanup (discard_minimal_symbols, 0);
572
573 /* Now that the symbol table data of the executable file are all in core,
574 process them and define symbols accordingly. */
575
576 read_dbx_symtab (section_offsets, objfile,
577 DBX_TEXT_ADDR (objfile),
578 DBX_TEXT_SIZE (objfile));
579
580 /* Add the dynamic symbols. */
581
582 read_dbx_dynamic_symtab (section_offsets, objfile);
583
584 /* Install any minimal symbols that have been collected as the current
585 minimal symbols for this objfile. */
586
587 install_minimal_symbols (objfile);
588
589 do_cleanups (back_to);
590 }
591
592 /* Initialize anything that needs initializing when a completely new
593 symbol file is specified (not just adding some symbols from another
594 file, e.g. a shared library). */
595
596 static void
597 dbx_new_init (ignore)
598 struct objfile *ignore;
599 {
600 stabsread_new_init ();
601 buildsym_new_init ();
602 init_header_files ();
603 }
604
605
606 /* dbx_symfile_init ()
607 is the dbx-specific initialization routine for reading symbols.
608 It is passed a struct objfile which contains, among other things,
609 the BFD for the file whose symbols are being read, and a slot for a pointer
610 to "private data" which we fill with goodies.
611
612 We read the string table into malloc'd space and stash a pointer to it.
613
614 Since BFD doesn't know how to read debug symbols in a format-independent
615 way (and may never do so...), we have to do it ourselves. We will never
616 be called unless this is an a.out (or very similar) file.
617 FIXME, there should be a cleaner peephole into the BFD environment here. */
618
619 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
620
621 static void
622 dbx_symfile_init (objfile)
623 struct objfile *objfile;
624 {
625 int val;
626 bfd *sym_bfd = objfile->obfd;
627 char *name = bfd_get_filename (sym_bfd);
628 asection *text_sect;
629 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
630
631 /* Allocate struct to keep track of the symfile */
632 objfile->sym_stab_info = (PTR)
633 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
634
635 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
636 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
637 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
638
639 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
640
641 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
642
643 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
644 if (!text_sect)
645 error ("Can't find .text section in symbol file");
646 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
647 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
648
649 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
650 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
651 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
652
653 /* Read the string table and stash it away in the psymbol_obstack. It is
654 only needed as long as we need to expand psymbols into full symbols,
655 so when we blow away the psymbol the string table goes away as well.
656 Note that gdb used to use the results of attempting to malloc the
657 string table, based on the size it read, as a form of sanity check
658 for botched byte swapping, on the theory that a byte swapped string
659 table size would be so totally bogus that the malloc would fail. Now
660 that we put in on the psymbol_obstack, we can't do this since gdb gets
661 a fatal error (out of virtual memory) if the size is bogus. We can
662 however at least check to see if the size is less than the size of
663 the size field itself, or larger than the size of the entire file.
664 Note that all valid string tables have a size greater than zero, since
665 the bytes used to hold the size are included in the count. */
666
667 if (STRING_TABLE_OFFSET == 0)
668 {
669 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
670 will never be zero, even when there is no string table. This
671 would appear to be a bug in bfd. */
672 DBX_STRINGTAB_SIZE (objfile) = 0;
673 DBX_STRINGTAB (objfile) = NULL;
674 }
675 else
676 {
677 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
678 if (val < 0)
679 perror_with_name (name);
680
681 memset ((PTR) size_temp, 0, sizeof (size_temp));
682 val = bfd_read ((PTR) size_temp, sizeof (size_temp), 1, sym_bfd);
683 if (val < 0)
684 {
685 perror_with_name (name);
686 }
687 else if (val == 0)
688 {
689 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
690 EOF if there is no string table, and attempting to read the size
691 from EOF will read zero bytes. */
692 DBX_STRINGTAB_SIZE (objfile) = 0;
693 DBX_STRINGTAB (objfile) = NULL;
694 }
695 else
696 {
697 /* Read some data that would appear to be the string table size.
698 If there really is a string table, then it is probably the right
699 size. Byteswap if necessary and validate the size. Note that
700 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
701 random data that happened to be at STRING_TABLE_OFFSET, because
702 bfd can't tell us there is no string table, the sanity checks may
703 or may not catch this. */
704 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
705
706 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
707 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
708 error ("ridiculous string table size (%d bytes).",
709 DBX_STRINGTAB_SIZE (objfile));
710
711 DBX_STRINGTAB (objfile) =
712 (char *) obstack_alloc (&objfile -> psymbol_obstack,
713 DBX_STRINGTAB_SIZE (objfile));
714 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
715
716 /* Now read in the string table in one big gulp. */
717
718 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
719 if (val < 0)
720 perror_with_name (name);
721 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
722 sym_bfd);
723 if (val != DBX_STRINGTAB_SIZE (objfile))
724 perror_with_name (name);
725 }
726 }
727 }
728
729 /* Perform any local cleanups required when we are done with a particular
730 objfile. I.E, we are in the process of discarding all symbol information
731 for an objfile, freeing up all memory held for it, and unlinking the
732 objfile struct from the global list of known objfiles. */
733
734 static void
735 dbx_symfile_finish (objfile)
736 struct objfile *objfile;
737 {
738 if (objfile->sym_stab_info != NULL)
739 {
740 mfree (objfile -> md, objfile->sym_stab_info);
741 }
742 free_header_files ();
743 }
744
745 \f
746 /* Buffer for reading the symbol table entries. */
747 static struct internal_nlist symbuf[4096];
748 static int symbuf_idx;
749 static int symbuf_end;
750
751 /* cont_elem is used for continuing information in cfront.
752 It saves information about which types need to be fixed up and
753 completed after all the stabs are read. */
754 struct cont_elem
755 {
756 /* sym and stabsstring for continuing information in cfront */
757 struct symbol * sym;
758 char * stabs;
759 /* state dependancies (statics that must be preserved) */
760 int sym_idx;
761 int sym_end;
762 int symnum;
763 /* other state dependancies include:
764 (assumption is that these will not change since process_now FIXME!!)
765 stringtab_global
766 n_stabs
767 objfile
768 symfile_bfd */
769 };
770 static struct cont_elem cont_list[100];
771 static int cont_count = 0;
772
773 void
774 process_later(sym,p)
775 struct symbol * sym;
776 char * p;
777 {
778 /* save state so we can process these stabs later */
779 cont_list[cont_count].sym_idx = symbuf_idx;
780 cont_list[cont_count].sym_end = symbuf_end;
781 cont_list[cont_count].symnum = symnum;
782 cont_list[cont_count].sym = sym;
783 cont_list[cont_count].stabs = p;
784 cont_count++;
785 }
786
787 void
788 process_now(objfile)
789 struct objfile * objfile;
790 {
791 int i;
792 /* save original state */
793 int save_symbuf_idx = symbuf_idx;
794 int save_symbuf_end = symbuf_end;
795 int save_symnum = symnum;
796 for (i=0; i<cont_count; i++)
797 {
798 /* set state as if we were parsing stabs strings
799 for this symbol */
800 symbuf_idx = cont_list[i].sym_idx; /* statics used by gdb */
801 symbuf_end = cont_list[i].sym_end;
802 symnum = cont_list[i].symnum;
803 resolve_cfront_continuation(objfile,cont_list[i].sym,cont_list[i].stabs);
804 }
805 /* restore original state */
806 symbuf_idx = save_symbuf_idx;
807 symbuf_end = save_symbuf_end;
808 symnum = save_symnum;
809 cont_count=0; /* reset for next run */
810 }
811
812
813 /* Name of last function encountered. Used in Solaris to approximate
814 object file boundaries. */
815 static char *last_function_name;
816
817 /* The address in memory of the string table of the object file we are
818 reading (which might not be the "main" object file, but might be a
819 shared library or some other dynamically loaded thing). This is
820 set by read_dbx_symtab when building psymtabs, and by
821 read_ofile_symtab when building symtabs, and is used only by
822 next_symbol_text. FIXME: If that is true, we don't need it when
823 building psymtabs, right? */
824 static char *stringtab_global;
825
826 /* These variables are used to control fill_symbuf when the stabs
827 symbols are not contiguous (as may be the case when a COFF file is
828 linked using --split-by-reloc). */
829 static struct stab_section_list *symbuf_sections;
830 static unsigned int symbuf_left;
831 static unsigned int symbuf_read;
832
833 /* Refill the symbol table input buffer
834 and set the variables that control fetching entries from it.
835 Reports an error if no data available.
836 This function can read past the end of the symbol table
837 (into the string table) but this does no harm. */
838
839 static void
840 fill_symbuf (sym_bfd)
841 bfd *sym_bfd;
842 {
843 unsigned int count;
844 int nbytes;
845
846 if (symbuf_sections == NULL)
847 count = sizeof (symbuf);
848 else
849 {
850 if (symbuf_left <= 0)
851 {
852 file_ptr filepos = symbuf_sections->section->filepos;
853 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
854 perror_with_name (bfd_get_filename (sym_bfd));
855 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
856 symbol_table_offset = filepos - symbuf_read;
857 symbuf_sections = symbuf_sections->next;
858 }
859
860 count = symbuf_left;
861 if (count > sizeof (symbuf))
862 count = sizeof (symbuf);
863 }
864
865 nbytes = bfd_read ((PTR)symbuf, count, 1, sym_bfd);
866 if (nbytes < 0)
867 perror_with_name (bfd_get_filename (sym_bfd));
868 else if (nbytes == 0)
869 error ("Premature end of file reading symbol table");
870 symbuf_end = nbytes / symbol_size;
871 symbuf_idx = 0;
872 symbuf_left -= nbytes;
873 symbuf_read += nbytes;
874 }
875
876 #define SWAP_SYMBOL(symp, abfd) \
877 { \
878 (symp)->n_strx = bfd_h_get_32(abfd, \
879 (unsigned char *)&(symp)->n_strx); \
880 (symp)->n_desc = bfd_h_get_16 (abfd, \
881 (unsigned char *)&(symp)->n_desc); \
882 (symp)->n_value = bfd_h_get_32 (abfd, \
883 (unsigned char *)&(symp)->n_value); \
884 }
885
886 /* Invariant: The symbol pointed to by symbuf_idx is the first one
887 that hasn't been swapped. Swap the symbol at the same time
888 that symbuf_idx is incremented. */
889
890 /* dbx allows the text of a symbol name to be continued into the
891 next symbol name! When such a continuation is encountered
892 (a \ at the end of the text of a name)
893 call this function to get the continuation. */
894
895 static char *
896 dbx_next_symbol_text (objfile)
897 struct objfile *objfile;
898 {
899 if (symbuf_idx == symbuf_end)
900 fill_symbuf (symfile_bfd);
901 symnum++;
902 SWAP_SYMBOL(&symbuf[symbuf_idx], symfile_bfd);
903 OBJSTAT (objfile, n_stabs++);
904 return symbuf[symbuf_idx++].n_strx + stringtab_global
905 + file_string_table_offset;
906 }
907 \f
908 /* Initialize the list of bincls to contain none and have some
909 allocated. */
910
911 static void
912 init_bincl_list (number, objfile)
913 int number;
914 struct objfile *objfile;
915 {
916 bincls_allocated = number;
917 next_bincl = bincl_list = (struct header_file_location *)
918 xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
919 }
920
921 /* Add a bincl to the list. */
922
923 static void
924 add_bincl_to_list (pst, name, instance)
925 struct partial_symtab *pst;
926 char *name;
927 int instance;
928 {
929 if (next_bincl >= bincl_list + bincls_allocated)
930 {
931 int offset = next_bincl - bincl_list;
932 bincls_allocated *= 2;
933 bincl_list = (struct header_file_location *)
934 xmrealloc (pst->objfile->md, (char *)bincl_list,
935 bincls_allocated * sizeof (struct header_file_location));
936 next_bincl = bincl_list + offset;
937 }
938 next_bincl->pst = pst;
939 next_bincl->instance = instance;
940 next_bincl++->name = name;
941 }
942
943 /* Given a name, value pair, find the corresponding
944 bincl in the list. Return the partial symtab associated
945 with that header_file_location. */
946
947 static struct partial_symtab *
948 find_corresponding_bincl_psymtab (name, instance)
949 char *name;
950 int instance;
951 {
952 struct header_file_location *bincl;
953
954 for (bincl = bincl_list; bincl < next_bincl; bincl++)
955 if (bincl->instance == instance
956 && STREQ (name, bincl->name))
957 return bincl->pst;
958
959 complain (&repeated_header_complaint, name, symnum);
960 return (struct partial_symtab *) 0;
961 }
962
963 /* Free the storage allocated for the bincl list. */
964
965 static void
966 free_bincl_list (objfile)
967 struct objfile *objfile;
968 {
969 mfree (objfile -> md, (PTR)bincl_list);
970 bincls_allocated = 0;
971 }
972
973 /* Scan a SunOs dynamic symbol table for symbols of interest and
974 add them to the minimal symbol table. */
975
976 static void
977 read_dbx_dynamic_symtab (section_offsets, objfile)
978 struct section_offsets *section_offsets;
979 struct objfile *objfile;
980 {
981 bfd *abfd = objfile->obfd;
982 struct cleanup *back_to;
983 int counter;
984 long dynsym_size;
985 long dynsym_count;
986 asymbol **dynsyms;
987 asymbol **symptr;
988 arelent **relptr;
989 long dynrel_size;
990 long dynrel_count;
991 arelent **dynrels;
992 CORE_ADDR sym_value;
993 char *name;
994
995 /* Check that the symbol file has dynamic symbols that we know about.
996 bfd_arch_unknown can happen if we are reading a sun3 symbol file
997 on a sun4 host (and vice versa) and bfd is not configured
998 --with-target=all. This would trigger an assertion in bfd/sunos.c,
999 so we ignore the dynamic symbols in this case. */
1000 if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
1001 || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
1002 || bfd_get_arch (abfd) == bfd_arch_unknown)
1003 return;
1004
1005 dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
1006 if (dynsym_size < 0)
1007 return;
1008
1009 dynsyms = (asymbol **) xmalloc (dynsym_size);
1010 back_to = make_cleanup (free, dynsyms);
1011
1012 dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
1013 if (dynsym_count < 0)
1014 {
1015 do_cleanups (back_to);
1016 return;
1017 }
1018
1019 /* Enter dynamic symbols into the minimal symbol table
1020 if this is a stripped executable. */
1021 if (bfd_get_symcount (abfd) <= 0)
1022 {
1023 symptr = dynsyms;
1024 for (counter = 0; counter < dynsym_count; counter++, symptr++)
1025 {
1026 asymbol *sym = *symptr;
1027 asection *sec;
1028 int type;
1029
1030 sec = bfd_get_section (sym);
1031
1032 /* BFD symbols are section relative. */
1033 sym_value = sym->value + sec->vma;
1034
1035 if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
1036 {
1037 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1038 type = N_TEXT;
1039 }
1040 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
1041 {
1042 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
1043 type = N_DATA;
1044 }
1045 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
1046 {
1047 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
1048 type = N_BSS;
1049 }
1050 else
1051 continue;
1052
1053 if (sym->flags & BSF_GLOBAL)
1054 type |= N_EXT;
1055
1056 record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
1057 type, objfile);
1058 }
1059 }
1060
1061 /* Symbols from shared libraries have a dynamic relocation entry
1062 that points to the associated slot in the procedure linkage table.
1063 We make a mininal symbol table entry with type mst_solib_trampoline
1064 at the address in the procedure linkage table. */
1065 dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
1066 if (dynrel_size < 0)
1067 {
1068 do_cleanups (back_to);
1069 return;
1070 }
1071
1072 dynrels = (arelent **) xmalloc (dynrel_size);
1073 make_cleanup (free, dynrels);
1074
1075 dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
1076 if (dynrel_count < 0)
1077 {
1078 do_cleanups (back_to);
1079 return;
1080 }
1081
1082 for (counter = 0, relptr = dynrels;
1083 counter < dynrel_count;
1084 counter++, relptr++)
1085 {
1086 arelent *rel = *relptr;
1087 CORE_ADDR address =
1088 rel->address + ANOFFSET (section_offsets, SECT_OFF_DATA);
1089
1090 switch (bfd_get_arch (abfd))
1091 {
1092 case bfd_arch_sparc:
1093 if (rel->howto->type != RELOC_JMP_SLOT)
1094 continue;
1095 break;
1096 case bfd_arch_m68k:
1097 /* `16' is the type BFD produces for a jump table relocation. */
1098 if (rel->howto->type != 16)
1099 continue;
1100
1101 /* Adjust address in the jump table to point to
1102 the start of the bsr instruction. */
1103 address -= 2;
1104 break;
1105 default:
1106 continue;
1107 }
1108
1109 name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
1110 prim_record_minimal_symbol
1111 (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
1112 address,
1113 mst_solib_trampoline,
1114 objfile);
1115 }
1116
1117 do_cleanups (back_to);
1118 }
1119
1120 /* Given pointers to an a.out symbol table in core containing dbx
1121 style data, setup partial_symtab's describing each source file for
1122 which debugging information is available.
1123 SYMFILE_NAME is the name of the file we are reading from
1124 and SECTION_OFFSETS is the set of offsets for the various sections
1125 of the file (a set of zeros if the mainline program). */
1126
1127 static void
1128 read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
1129 struct section_offsets *section_offsets;
1130 struct objfile *objfile;
1131 CORE_ADDR text_addr;
1132 int text_size;
1133 {
1134 register struct internal_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
1135 register char *namestring;
1136 int nsl;
1137 int past_first_source_file = 0;
1138 CORE_ADDR last_o_file_start = 0;
1139 CORE_ADDR last_function_start = 0;
1140 struct cleanup *back_to;
1141 bfd *abfd;
1142
1143 /* Current partial symtab */
1144 struct partial_symtab *pst;
1145
1146 /* List of current psymtab's include files */
1147 char **psymtab_include_list;
1148 int includes_allocated;
1149 int includes_used;
1150
1151 /* Index within current psymtab dependency list */
1152 struct partial_symtab **dependency_list;
1153 int dependencies_used, dependencies_allocated;
1154
1155 /* FIXME. We probably want to change stringtab_global rather than add this
1156 while processing every symbol entry. FIXME. */
1157 file_string_table_offset = 0;
1158 next_file_string_table_offset = 0;
1159
1160 stringtab_global = DBX_STRINGTAB (objfile);
1161
1162 pst = (struct partial_symtab *) 0;
1163
1164 includes_allocated = 30;
1165 includes_used = 0;
1166 psymtab_include_list = (char **) alloca (includes_allocated *
1167 sizeof (char *));
1168
1169 dependencies_allocated = 30;
1170 dependencies_used = 0;
1171 dependency_list =
1172 (struct partial_symtab **) alloca (dependencies_allocated *
1173 sizeof (struct partial_symtab *));
1174
1175 /* Init bincl list */
1176 init_bincl_list (20, objfile);
1177 back_to = make_cleanup (free_bincl_list, objfile);
1178
1179 last_source_file = NULL;
1180
1181 lowest_text_address = (CORE_ADDR)-1;
1182
1183 symfile_bfd = objfile->obfd; /* For next_text_symbol */
1184 abfd = objfile->obfd;
1185 symbuf_end = symbuf_idx = 0;
1186 next_symbol_text_func = dbx_next_symbol_text;
1187
1188 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1189 {
1190 /* Get the symbol for this run and pull out some info */
1191 QUIT; /* allow this to be interruptable */
1192 if (symbuf_idx == symbuf_end)
1193 fill_symbuf (abfd);
1194 bufp = &symbuf[symbuf_idx++];
1195
1196 /*
1197 * Special case to speed up readin.
1198 */
1199 if (bufp->n_type == (unsigned char)N_SLINE) continue;
1200
1201 SWAP_SYMBOL (bufp, abfd);
1202 OBJSTAT (objfile, n_stabs++);
1203
1204 /* Ok. There is a lot of code duplicated in the rest of this
1205 switch statement (for efficiency reasons). Since I don't
1206 like duplicating code, I will do my penance here, and
1207 describe the code which is duplicated:
1208
1209 *) The assignment to namestring.
1210 *) The call to strchr.
1211 *) The addition of a partial symbol the the two partial
1212 symbol lists. This last is a large section of code, so
1213 I've imbedded it in the following macro.
1214 */
1215
1216 /* Set namestring based on bufp. If the string table index is invalid,
1217 give a fake name, and print a single error message per symbol file read,
1218 rather than abort the symbol reading or flood the user with messages. */
1219
1220 /*FIXME: Too many adds and indirections in here for the inner loop. */
1221 #define SET_NAMESTRING()\
1222 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1223 DBX_STRINGTAB_SIZE (objfile)) { \
1224 complain (&string_table_offset_complaint, symnum); \
1225 namestring = "<bad string table offset>"; \
1226 } else \
1227 namestring = bufp->n_strx + file_string_table_offset + \
1228 DBX_STRINGTAB (objfile)
1229
1230 #define CUR_SYMBOL_TYPE bufp->n_type
1231 #define CUR_SYMBOL_VALUE bufp->n_value
1232 #define DBXREAD_ONLY
1233 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1234 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1235 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1236 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1237
1238 #include "partial-stab.h"
1239 }
1240
1241 /* If there's stuff to be cleaned up, clean it up. */
1242 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
1243 /*FIXME, does this have a bug at start address 0? */
1244 && last_o_file_start
1245 && objfile -> ei.entry_point < bufp->n_value
1246 && objfile -> ei.entry_point >= last_o_file_start)
1247 {
1248 objfile -> ei.entry_file_lowpc = last_o_file_start;
1249 objfile -> ei.entry_file_highpc = bufp->n_value;
1250 }
1251
1252 if (pst)
1253 {
1254 end_psymtab (pst, psymtab_include_list, includes_used,
1255 symnum * symbol_size,
1256 (lowest_text_address == (CORE_ADDR)-1
1257 ? (text_addr + section_offsets->offsets[SECT_OFF_TEXT])
1258 : lowest_text_address)
1259 + text_size,
1260 dependency_list, dependencies_used);
1261 }
1262
1263 do_cleanups (back_to);
1264 }
1265
1266 /* Allocate and partially fill a partial symtab. It will be
1267 completely filled at the end of the symbol list.
1268
1269 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1270 is the address relative to which its symbols are (incremental) or 0
1271 (normal). */
1272
1273
1274 struct partial_symtab *
1275 start_psymtab (objfile, section_offsets,
1276 filename, textlow, ldsymoff, global_syms, static_syms)
1277 struct objfile *objfile;
1278 struct section_offsets *section_offsets;
1279 char *filename;
1280 CORE_ADDR textlow;
1281 int ldsymoff;
1282 struct partial_symbol **global_syms;
1283 struct partial_symbol **static_syms;
1284 {
1285 struct partial_symtab *result =
1286 start_psymtab_common(objfile, section_offsets,
1287 filename, textlow, global_syms, static_syms);
1288
1289 result->read_symtab_private = (char *)
1290 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
1291 LDSYMOFF(result) = ldsymoff;
1292 result->read_symtab = dbx_psymtab_to_symtab;
1293 SYMBOL_SIZE(result) = symbol_size;
1294 SYMBOL_OFFSET(result) = symbol_table_offset;
1295 STRING_OFFSET(result) = string_table_offset;
1296 FILE_STRING_OFFSET(result) = file_string_table_offset;
1297
1298 /* If we're handling an ELF file, drag some section-relocation info
1299 for this source file out of the ELF symbol table, to compensate for
1300 Sun brain death. This replaces the section_offsets in this psymtab,
1301 if successful. */
1302 elfstab_offset_sections (objfile, result);
1303
1304 /* Deduce the source language from the filename for this psymtab. */
1305 psymtab_language = deduce_language_from_filename (filename);
1306
1307 return result;
1308 }
1309
1310 /* Close off the current usage of PST.
1311 Returns PST or NULL if the partial symtab was empty and thrown away.
1312
1313 FIXME: List variables and peculiarities of same. */
1314
1315 struct partial_symtab *
1316 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1317 capping_text, dependency_list, number_dependencies)
1318 struct partial_symtab *pst;
1319 char **include_list;
1320 int num_includes;
1321 int capping_symbol_offset;
1322 CORE_ADDR capping_text;
1323 struct partial_symtab **dependency_list;
1324 int number_dependencies;
1325 {
1326 int i;
1327 struct objfile *objfile = pst -> objfile;
1328
1329 if (capping_symbol_offset != -1)
1330 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1331 pst->texthigh = capping_text;
1332
1333 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1334 /* Under Solaris, the N_SO symbols always have a value of 0,
1335 instead of the usual address of the .o file. Therefore,
1336 we have to do some tricks to fill in texthigh and textlow.
1337 The first trick is in partial-stab.h: if we see a static
1338 or global function, and the textlow for the current pst
1339 is still 0, then we use that function's address for
1340 the textlow of the pst. */
1341
1342 /* Now, to fill in texthigh, we remember the last function seen
1343 in the .o file (also in partial-stab.h). Also, there's a hack in
1344 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1345 to here via the misc_info field. Therefore, we can fill in
1346 a reliable texthigh by taking the address plus size of the
1347 last function in the file. */
1348
1349 if (pst->texthigh == 0 && last_function_name) {
1350 char *p;
1351 int n;
1352 struct minimal_symbol *minsym;
1353
1354 p = strchr (last_function_name, ':');
1355 if (p == NULL)
1356 p = last_function_name;
1357 n = p - last_function_name;
1358 p = alloca (n + 1);
1359 strncpy (p, last_function_name, n);
1360 p[n] = 0;
1361
1362 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1363
1364 if (minsym)
1365 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) +
1366 (long) MSYMBOL_INFO (minsym);
1367
1368 last_function_name = NULL;
1369 }
1370
1371 /* this test will be true if the last .o file is only data */
1372 if (pst->textlow == 0)
1373 /* This loses if the text section really starts at address zero
1374 (generally true when we are debugging a .o file, for example).
1375 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1376 pst->textlow = pst->texthigh;
1377
1378 /* If we know our own starting text address, then walk through all other
1379 psymtabs for this objfile, and if any didn't know their ending text
1380 address, set it to our starting address. Take care to not set our
1381 own ending address to our starting address, nor to set addresses on
1382 `dependency' files that have both textlow and texthigh zero. */
1383 if (pst->textlow) {
1384 struct partial_symtab *p1;
1385
1386 ALL_OBJFILE_PSYMTABS (objfile, p1) {
1387 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) {
1388 p1->texthigh = pst->textlow;
1389 /* if this file has only data, then make textlow match texthigh */
1390 if (p1->textlow == 0)
1391 p1->textlow = p1->texthigh;
1392 }
1393 }
1394 }
1395
1396 /* End of kludge for patching Solaris textlow and texthigh. */
1397 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1398
1399 pst->n_global_syms =
1400 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1401 pst->n_static_syms =
1402 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1403
1404 pst->number_of_dependencies = number_dependencies;
1405 if (number_dependencies)
1406 {
1407 pst->dependencies = (struct partial_symtab **)
1408 obstack_alloc (&objfile->psymbol_obstack,
1409 number_dependencies * sizeof (struct partial_symtab *));
1410 memcpy (pst->dependencies, dependency_list,
1411 number_dependencies * sizeof (struct partial_symtab *));
1412 }
1413 else
1414 pst->dependencies = 0;
1415
1416 for (i = 0; i < num_includes; i++)
1417 {
1418 struct partial_symtab *subpst =
1419 allocate_psymtab (include_list[i], objfile);
1420
1421 subpst->section_offsets = pst->section_offsets;
1422 subpst->read_symtab_private =
1423 (char *) obstack_alloc (&objfile->psymbol_obstack,
1424 sizeof (struct symloc));
1425 LDSYMOFF(subpst) =
1426 LDSYMLEN(subpst) =
1427 subpst->textlow =
1428 subpst->texthigh = 0;
1429
1430 /* We could save slight bits of space by only making one of these,
1431 shared by the entire set of include files. FIXME-someday. */
1432 subpst->dependencies = (struct partial_symtab **)
1433 obstack_alloc (&objfile->psymbol_obstack,
1434 sizeof (struct partial_symtab *));
1435 subpst->dependencies[0] = pst;
1436 subpst->number_of_dependencies = 1;
1437
1438 subpst->globals_offset =
1439 subpst->n_global_syms =
1440 subpst->statics_offset =
1441 subpst->n_static_syms = 0;
1442
1443 subpst->readin = 0;
1444 subpst->symtab = 0;
1445 subpst->read_symtab = pst->read_symtab;
1446 }
1447
1448 sort_pst_symbols (pst);
1449
1450 /* If there is already a psymtab or symtab for a file of this name, remove it.
1451 (If there is a symtab, more drastic things also happen.)
1452 This happens in VxWorks. */
1453 free_named_symtabs (pst->filename);
1454
1455 if (num_includes == 0
1456 && number_dependencies == 0
1457 && pst->n_global_syms == 0
1458 && pst->n_static_syms == 0)
1459 {
1460 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1461 it is on the obstack, but we can forget to chain it on the list. */
1462 /* Empty psymtabs happen as a result of header files which don't have
1463 any symbols in them. There can be a lot of them. But this check
1464 is wrong, in that a psymtab with N_SLINE entries but nothing else
1465 is not empty, but we don't realize that. Fixing that without slowing
1466 things down might be tricky. */
1467 struct partial_symtab *prev_pst;
1468
1469 /* First, snip it out of the psymtab chain */
1470
1471 if (pst->objfile->psymtabs == pst)
1472 pst->objfile->psymtabs = pst->next;
1473 else
1474 for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
1475 if (prev_pst->next == pst)
1476 prev_pst->next = pst->next;
1477
1478 /* Next, put it on a free list for recycling */
1479
1480 pst->next = pst->objfile->free_psymtabs;
1481 pst->objfile->free_psymtabs = pst;
1482
1483 /* Indicate that psymtab was thrown away. */
1484 pst = (struct partial_symtab *)NULL;
1485 }
1486 return pst;
1487 }
1488 \f
1489 static void
1490 dbx_psymtab_to_symtab_1 (pst)
1491 struct partial_symtab *pst;
1492 {
1493 struct cleanup *old_chain;
1494 int i;
1495
1496 if (!pst)
1497 return;
1498
1499 if (pst->readin)
1500 {
1501 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1502 pst->filename);
1503 return;
1504 }
1505
1506 /* Read in all partial symtabs on which this one is dependent */
1507 for (i = 0; i < pst->number_of_dependencies; i++)
1508 if (!pst->dependencies[i]->readin)
1509 {
1510 /* Inform about additional files that need to be read in. */
1511 if (info_verbose)
1512 {
1513 fputs_filtered (" ", gdb_stdout);
1514 wrap_here ("");
1515 fputs_filtered ("and ", gdb_stdout);
1516 wrap_here ("");
1517 printf_filtered ("%s...", pst->dependencies[i]->filename);
1518 wrap_here (""); /* Flush output */
1519 gdb_flush (gdb_stdout);
1520 }
1521 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1522 }
1523
1524 if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
1525 {
1526 /* Init stuff necessary for reading in symbols */
1527 stabsread_init ();
1528 buildsym_init ();
1529 old_chain = make_cleanup (really_free_pendings, 0);
1530 file_string_table_offset = FILE_STRING_OFFSET (pst);
1531 symbol_size = SYMBOL_SIZE (pst);
1532
1533 /* Read in this file's symbols */
1534 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
1535 read_ofile_symtab (pst);
1536 sort_symtab_syms (pst->symtab);
1537
1538 do_cleanups (old_chain);
1539 }
1540
1541 pst->readin = 1;
1542 }
1543
1544 /* Read in all of the symbols for a given psymtab for real.
1545 Be verbose about it if the user wants that. */
1546
1547 static void
1548 dbx_psymtab_to_symtab (pst)
1549 struct partial_symtab *pst;
1550 {
1551 bfd *sym_bfd;
1552
1553 if (!pst)
1554 return;
1555
1556 if (pst->readin)
1557 {
1558 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1559 pst->filename);
1560 return;
1561 }
1562
1563 if (LDSYMLEN(pst) || pst->number_of_dependencies)
1564 {
1565 /* Print the message now, before reading the string table,
1566 to avoid disconcerting pauses. */
1567 if (info_verbose)
1568 {
1569 printf_filtered ("Reading in symbols for %s...", pst->filename);
1570 gdb_flush (gdb_stdout);
1571 }
1572
1573 sym_bfd = pst->objfile->obfd;
1574
1575 next_symbol_text_func = dbx_next_symbol_text;
1576
1577 dbx_psymtab_to_symtab_1 (pst);
1578
1579 /* Match with global symbols. This only needs to be done once,
1580 after all of the symtabs and dependencies have been read in. */
1581 scan_file_globals (pst->objfile);
1582
1583 /* Finish up the debug error message. */
1584 if (info_verbose)
1585 printf_filtered ("done.\n");
1586 }
1587 }
1588
1589 /* Read in a defined section of a specific object file's symbols. */
1590
1591 static void
1592 read_ofile_symtab (pst)
1593 struct partial_symtab *pst;
1594 {
1595 register char *namestring;
1596 register struct internal_nlist *bufp;
1597 unsigned char type;
1598 unsigned max_symnum;
1599 register bfd *abfd;
1600 struct objfile *objfile;
1601 int sym_offset; /* Offset to start of symbols to read */
1602 int sym_size; /* Size of symbols to read */
1603 CORE_ADDR text_offset; /* Start of text segment for symbols */
1604 int text_size; /* Size of text segment for symbols */
1605 struct section_offsets *section_offsets;
1606
1607 objfile = pst->objfile;
1608 sym_offset = LDSYMOFF(pst);
1609 sym_size = LDSYMLEN(pst);
1610 text_offset = pst->textlow;
1611 text_size = pst->texthigh - pst->textlow;
1612 section_offsets = pst->section_offsets;
1613
1614 current_objfile = objfile;
1615 subfile_stack = NULL;
1616
1617 stringtab_global = DBX_STRINGTAB (objfile);
1618 last_source_file = NULL;
1619
1620 abfd = objfile->obfd;
1621 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1622 symbuf_end = symbuf_idx = 0;
1623
1624 /* It is necessary to actually read one symbol *before* the start
1625 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1626 occurs before the N_SO symbol.
1627
1628 Detecting this in read_dbx_symtab
1629 would slow down initial readin, so we look for it here instead. */
1630 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1631 {
1632 bfd_seek (symfile_bfd, sym_offset - symbol_size, SEEK_CUR);
1633 fill_symbuf (abfd);
1634 bufp = &symbuf[symbuf_idx++];
1635 SWAP_SYMBOL (bufp, abfd);
1636 OBJSTAT (objfile, n_stabs++);
1637
1638 SET_NAMESTRING ();
1639
1640 processing_gcc_compilation = 0;
1641 if (bufp->n_type == N_TEXT)
1642 {
1643 const char *tempstring = namestring;
1644
1645 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1646 processing_gcc_compilation = 1;
1647 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1648 processing_gcc_compilation = 2;
1649 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
1650 ++tempstring;
1651 if (STREQN (tempstring, "__gnu_compiled", 14))
1652 processing_gcc_compilation = 2;
1653 }
1654
1655 /* Try to select a C++ demangling based on the compilation unit
1656 producer. */
1657
1658 if (processing_gcc_compilation)
1659 {
1660 if (AUTO_DEMANGLING)
1661 {
1662 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1663 }
1664 }
1665 }
1666 else
1667 {
1668 /* The N_SO starting this symtab is the first symbol, so we
1669 better not check the symbol before it. I'm not this can
1670 happen, but it doesn't hurt to check for it. */
1671 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
1672 processing_gcc_compilation = 0;
1673 }
1674
1675 if (symbuf_idx == symbuf_end)
1676 fill_symbuf (abfd);
1677 bufp = &symbuf[symbuf_idx];
1678 if (bufp->n_type != (unsigned char)N_SO)
1679 error("First symbol in segment of executable not a source symbol");
1680
1681 max_symnum = sym_size / symbol_size;
1682
1683 for (symnum = 0;
1684 symnum < max_symnum;
1685 symnum++)
1686 {
1687 QUIT; /* Allow this to be interruptable */
1688 if (symbuf_idx == symbuf_end)
1689 fill_symbuf(abfd);
1690 bufp = &symbuf[symbuf_idx++];
1691 SWAP_SYMBOL (bufp, abfd);
1692 OBJSTAT (objfile, n_stabs++);
1693
1694 type = bufp->n_type;
1695
1696 SET_NAMESTRING ();
1697
1698 if (type & N_STAB) {
1699 process_one_symbol (type, bufp->n_desc, bufp->n_value,
1700 namestring, section_offsets, objfile);
1701 }
1702 /* We skip checking for a new .o or -l file; that should never
1703 happen in this routine. */
1704 else if (type == N_TEXT)
1705 {
1706 /* I don't think this code will ever be executed, because
1707 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1708 the N_SO symbol which starts this source file.
1709 However, there is no reason not to accept
1710 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1711
1712 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1713 processing_gcc_compilation = 1;
1714 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1715 processing_gcc_compilation = 2;
1716
1717 if (AUTO_DEMANGLING)
1718 {
1719 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1720 }
1721 }
1722 else if (type & N_EXT || type == (unsigned char)N_TEXT
1723 || type == (unsigned char)N_NBTEXT
1724 ) {
1725 /* Global symbol: see if we came across a dbx defintion for
1726 a corresponding symbol. If so, store the value. Remove
1727 syms from the chain when their values are stored, but
1728 search the whole chain, as there may be several syms from
1729 different files with the same name. */
1730 /* This is probably not true. Since the files will be read
1731 in one at a time, each reference to a global symbol will
1732 be satisfied in each file as it appears. So we skip this
1733 section. */
1734 ;
1735 }
1736 }
1737
1738 current_objfile = NULL;
1739
1740 /* In a Solaris elf file, this variable, which comes from the
1741 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1742 which comes from pst->textlow is correct. */
1743 if (last_source_start_addr == 0)
1744 last_source_start_addr = text_offset;
1745
1746 /* In reordered executables last_source_start_addr may not be the
1747 lower bound for this symtab, instead use text_offset which comes
1748 from pst->textlow which is correct. */
1749 if (last_source_start_addr > text_offset)
1750 last_source_start_addr = text_offset;
1751
1752 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT);
1753
1754 if (ARM_DEMANGLING) /* process incomplete C++ types now */
1755 process_now(objfile);
1756
1757 end_stabs ();
1758 }
1759
1760 \f
1761 /* This handles a single symbol from the symbol-file, building symbols
1762 into a GDB symtab. It takes these arguments and an implicit argument.
1763
1764 TYPE is the type field of the ".stab" symbol entry.
1765 DESC is the desc field of the ".stab" entry.
1766 VALU is the value field of the ".stab" entry.
1767 NAME is the symbol name, in our address space.
1768 SECTION_OFFSETS is a set of amounts by which the sections of this object
1769 file were relocated when it was loaded into memory.
1770 All symbols that refer
1771 to memory locations need to be offset by these amounts.
1772 OBJFILE is the object file from which we are reading symbols.
1773 It is used in end_symtab. */
1774
1775 void
1776 process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1777 int type, desc;
1778 CORE_ADDR valu;
1779 char *name;
1780 struct section_offsets *section_offsets;
1781 struct objfile *objfile;
1782 {
1783 #ifdef SUN_FIXED_LBRAC_BUG
1784 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1785 to correct the address of N_LBRAC's. If it is not defined, then
1786 we never need to correct the addresses. */
1787
1788 /* This records the last pc address we've seen. We depend on there being
1789 an SLINE or FUN or SO before the first LBRAC, since the variable does
1790 not get reset in between reads of different symbol files. */
1791 static CORE_ADDR last_pc_address;
1792 #endif
1793
1794 register struct context_stack *new;
1795 /* This remembers the address of the start of a function. It is used
1796 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1797 relative to the current function's start address. On systems
1798 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1799 used to relocate these symbol types rather than SECTION_OFFSETS. */
1800 static CORE_ADDR function_start_offset;
1801
1802 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1803 file. Used to detect the SunPRO solaris compiler. */
1804 static int n_opt_found;
1805
1806 /* The stab type used for the definition of the last function.
1807 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1808 static int function_stab_type = 0;
1809
1810 if (!block_address_function_relative)
1811 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1812 function start address, so just use the text offset. */
1813 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
1814
1815 /* Something is wrong if we see real data before
1816 seeing a source file name. */
1817
1818 if (last_source_file == NULL && type != (unsigned char)N_SO)
1819 {
1820 /* Ignore any symbols which appear before an N_SO symbol. Currently
1821 no one puts symbols there, but we should deal gracefully with the
1822 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1823 but this should not be an error (). */
1824 return;
1825 }
1826
1827 switch (type)
1828 {
1829 case N_FUN:
1830 case N_FNAME:
1831
1832 if (! strcmp (name, ""))
1833 {
1834 /* This N_FUN marks the end of a function. This closes off the
1835 current block. */
1836 within_function = 0;
1837 new = pop_context ();
1838
1839 /* Make a block for the local symbols within. */
1840 finish_block (new->name, &local_symbols, new->old_blocks,
1841 function_start_offset, function_start_offset + valu,
1842 objfile);
1843 break;
1844 }
1845
1846 /* Relocate for dynamic loading */
1847 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1848 goto define_a_symbol;
1849
1850 case N_LBRAC:
1851 /* This "symbol" just indicates the start of an inner lexical
1852 context within a function. */
1853
1854 /* Ignore extra outermost context from SunPRO cc and acc. */
1855 if (n_opt_found && desc == 1)
1856 break;
1857
1858 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1859 /* Relocate for dynamic loading (?). */
1860 valu += function_start_offset;
1861 #else
1862 if (block_address_function_relative)
1863 /* Relocate for Sun ELF acc fn-relative syms. */
1864 valu += function_start_offset;
1865 else
1866 /* On most machines, the block addresses are relative to the
1867 N_SO, the linker did not relocate them (sigh). */
1868 valu += last_source_start_addr;
1869 #endif
1870
1871 #ifdef SUN_FIXED_LBRAC_BUG
1872 if (!SUN_FIXED_LBRAC_BUG && valu < last_pc_address) {
1873 /* Patch current LBRAC pc value to match last handy pc value */
1874 complain (&lbrac_complaint);
1875 valu = last_pc_address;
1876 }
1877 #endif
1878 new = push_context (desc, valu);
1879 break;
1880
1881 case N_RBRAC:
1882 /* This "symbol" just indicates the end of an inner lexical
1883 context that was started with N_LBRAC. */
1884
1885 /* Ignore extra outermost context from SunPRO cc and acc. */
1886 if (n_opt_found && desc == 1)
1887 break;
1888
1889 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1890 /* Relocate for dynamic loading (?). */
1891 valu += function_start_offset;
1892 #else
1893 if (block_address_function_relative)
1894 /* Relocate for Sun ELF acc fn-relative syms. */
1895 valu += function_start_offset;
1896 else
1897 /* On most machines, the block addresses are relative to the
1898 N_SO, the linker did not relocate them (sigh). */
1899 valu += last_source_start_addr;
1900 #endif
1901
1902 new = pop_context();
1903 if (desc != new->depth)
1904 complain (&lbrac_mismatch_complaint, symnum);
1905
1906 /* Some compilers put the variable decls inside of an
1907 LBRAC/RBRAC block. This macro should be nonzero if this
1908 is true. DESC is N_DESC from the N_RBRAC symbol.
1909 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1910 or the GCC2_COMPILED_SYMBOL. */
1911 #if !defined (VARIABLES_INSIDE_BLOCK)
1912 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1913 #endif
1914
1915 /* Can only use new->locals as local symbols here if we're in
1916 gcc or on a machine that puts them before the lbrack. */
1917 if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1918 local_symbols = new->locals;
1919
1920 if (context_stack_depth
1921 > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1922 {
1923 /* This is not the outermost LBRAC...RBRAC pair in the function,
1924 its local symbols preceded it, and are the ones just recovered
1925 from the context stack. Define the block for them (but don't
1926 bother if the block contains no symbols. Should we complain
1927 on blocks without symbols? I can't think of any useful purpose
1928 for them). */
1929 if (local_symbols != NULL)
1930 {
1931 /* Muzzle a compiler bug that makes end < start. (which
1932 compilers? Is this ever harmful?). */
1933 if (new->start_addr > valu)
1934 {
1935 complain (&lbrac_rbrac_complaint);
1936 new->start_addr = valu;
1937 }
1938 /* Make a block for the local symbols within. */
1939 finish_block (0, &local_symbols, new->old_blocks,
1940 new->start_addr, valu, objfile);
1941 }
1942 }
1943 else
1944 {
1945 /* This is the outermost LBRAC...RBRAC pair. There is no
1946 need to do anything; leave the symbols that preceded it
1947 to be attached to the function's own block. We need to
1948 indicate that we just moved outside of the function. */
1949 within_function = 0;
1950 }
1951
1952 if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1953 /* Now pop locals of block just finished. */
1954 local_symbols = new->locals;
1955 break;
1956
1957 case N_FN:
1958 case N_FN_SEQ:
1959 /* This kind of symbol indicates the start of an object file. */
1960 /* Relocate for dynamic loading */
1961 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1962 break;
1963
1964 case N_SO:
1965 /* This type of symbol indicates the start of data
1966 for one source file.
1967 Finish the symbol table of the previous source file
1968 (if any) and start accumulating a new symbol table. */
1969 /* Relocate for dynamic loading */
1970 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1971
1972 n_opt_found = 0;
1973
1974 #ifdef SUN_FIXED_LBRAC_BUG
1975 last_pc_address = valu; /* Save for SunOS bug circumcision */
1976 #endif
1977
1978 #ifdef PCC_SOL_BROKEN
1979 /* pcc bug, occasionally puts out SO for SOL. */
1980 if (context_stack_depth > 0)
1981 {
1982 start_subfile (name, NULL);
1983 break;
1984 }
1985 #endif
1986 if (last_source_file)
1987 {
1988 /* Check if previous symbol was also an N_SO (with some
1989 sanity checks). If so, that one was actually the directory
1990 name, and the current one is the real file name.
1991 Patch things up. */
1992 if (previous_stab_code == (unsigned char) N_SO)
1993 {
1994 patch_subfile_names (current_subfile, name);
1995 break; /* Ignore repeated SOs */
1996 }
1997 end_symtab (valu, objfile, SECT_OFF_TEXT);
1998 end_stabs ();
1999 }
2000
2001 /* Null name means this just marks the end of text for this .o file.
2002 Don't start a new symtab in this case. */
2003 if (*name == '\000')
2004 break;
2005
2006 start_stabs ();
2007 start_symtab (name, NULL, valu);
2008 break;
2009
2010 case N_SOL:
2011 /* This type of symbol indicates the start of data for
2012 a sub-source-file, one whose contents were copied or
2013 included in the compilation of the main source file
2014 (whose name was given in the N_SO symbol.) */
2015 /* Relocate for dynamic loading */
2016 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2017 start_subfile (name, current_subfile->dirname);
2018 break;
2019
2020 case N_BINCL:
2021 push_subfile ();
2022 add_new_header_file (name, valu);
2023 start_subfile (name, current_subfile->dirname);
2024 break;
2025
2026 case N_EINCL:
2027 start_subfile (pop_subfile (), current_subfile->dirname);
2028 break;
2029
2030 case N_EXCL:
2031 add_old_header_file (name, valu);
2032 break;
2033
2034 case N_SLINE:
2035 /* This type of "symbol" really just records
2036 one line-number -- core-address correspondence.
2037 Enter it in the line list for this symbol table. */
2038 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2039 valu += function_start_offset;
2040 #ifdef SUN_FIXED_LBRAC_BUG
2041 last_pc_address = valu; /* Save for SunOS bug circumcision */
2042 #endif
2043 record_line (current_subfile, desc, valu);
2044 break;
2045
2046 case N_BCOMM:
2047 common_block_start (name, objfile);
2048 break;
2049
2050 case N_ECOMM:
2051 common_block_end (objfile);
2052 break;
2053
2054 /* The following symbol types need to have the appropriate offset added
2055 to their value; then we process symbol definitions in the name. */
2056
2057 case N_STSYM: /* Static symbol in data seg */
2058 case N_LCSYM: /* Static symbol in BSS seg */
2059 case N_ROSYM: /* Static symbol in Read-only data seg */
2060 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2061 Solaris2's stabs-in-elf makes *most* symbols relative
2062 but leaves a few absolute (at least for Solaris 2.1 and version
2063 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2064 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2065 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2066 This leaves us no choice but to search for the 'S' or 'V'...
2067 (or pass the whole section_offsets stuff down ONE MORE function
2068 call level, which we really don't want to do). */
2069 {
2070 char *p;
2071
2072 /* .o files and NLMs have non-zero text seg offsets, but don't need
2073 their static syms offset in this fashion. XXX - This is really a
2074 crock that should be fixed in the solib handling code so that I
2075 don't have to work around it here. */
2076
2077 if (!symfile_relocatable)
2078 {
2079 p = strchr (name, ':');
2080 if (p != 0 && p[1] == 'S')
2081 {
2082 /* The linker relocated it. We don't want to add an
2083 elfstab_offset_sections-type offset, but we *do* want
2084 to add whatever solib.c passed to symbol_file_add as
2085 addr (this is known to affect SunOS4, and I suspect ELF
2086 too). Since elfstab_offset_sections currently does not
2087 muck with the text offset (there is no Ttext.text
2088 symbol), we can get addr from the text offset. If
2089 elfstab_offset_sections ever starts dealing with the
2090 text offset, and we still need to do this, we need to
2091 invent a SECT_OFF_ADDR_KLUDGE or something. */
2092 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2093 goto define_a_symbol;
2094 }
2095 }
2096 /* Since it's not the kludge case, re-dispatch to the right handler. */
2097 switch (type) {
2098 case N_STSYM: goto case_N_STSYM;
2099 case N_LCSYM: goto case_N_LCSYM;
2100 case N_ROSYM: goto case_N_ROSYM;
2101 default: abort();
2102 }
2103 }
2104
2105 case_N_STSYM: /* Static symbol in data seg */
2106 case N_DSLINE: /* Source line number, data seg */
2107 valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
2108 goto define_a_symbol;
2109
2110 case_N_LCSYM: /* Static symbol in BSS seg */
2111 case N_BSLINE: /* Source line number, bss seg */
2112 /* N_BROWS: overlaps with N_BSLINE */
2113 valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
2114 goto define_a_symbol;
2115
2116 case_N_ROSYM: /* Static symbol in Read-only data seg */
2117 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
2118 goto define_a_symbol;
2119
2120 case N_ENTRY: /* Alternate entry point */
2121 /* Relocate for dynamic loading */
2122 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2123 goto define_a_symbol;
2124
2125 /* The following symbol types we don't know how to process. Handle
2126 them in a "default" way, but complain to people who care. */
2127 default:
2128 case N_CATCH: /* Exception handler catcher */
2129 case N_EHDECL: /* Exception handler name */
2130 case N_PC: /* Global symbol in Pascal */
2131 case N_M2C: /* Modula-2 compilation unit */
2132 /* N_MOD2: overlaps with N_EHDECL */
2133 case N_SCOPE: /* Modula-2 scope information */
2134 case N_ECOML: /* End common (local name) */
2135 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
2136 case N_NBDATA:
2137 case N_NBBSS:
2138 case N_NBSTS:
2139 case N_NBLCS:
2140 complain (&unknown_symtype_complaint, local_hex_string (type));
2141 /* FALLTHROUGH */
2142
2143 /* The following symbol types don't need the address field relocated,
2144 since it is either unused, or is absolute. */
2145 define_a_symbol:
2146 case N_GSYM: /* Global variable */
2147 case N_NSYMS: /* Number of symbols (ultrix) */
2148 case N_NOMAP: /* No map? (ultrix) */
2149 case N_RSYM: /* Register variable */
2150 case N_DEFD: /* Modula-2 GNU module dependency */
2151 case N_SSYM: /* Struct or union element */
2152 case N_LSYM: /* Local symbol in stack */
2153 case N_PSYM: /* Parameter variable */
2154 case N_LENG: /* Length of preceding symbol type */
2155 if (name)
2156 {
2157 int deftype;
2158 char *colon_pos = strchr (name, ':');
2159 if (colon_pos == NULL)
2160 deftype = '\0';
2161 else
2162 deftype = colon_pos[1];
2163
2164 switch (deftype)
2165 {
2166 case 'f':
2167 case 'F':
2168 function_stab_type = type;
2169
2170 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2171 /* Deal with the SunPRO 3.0 compiler which omits the address
2172 from N_FUN symbols. */
2173 if (type == N_FUN
2174 && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT))
2175 {
2176 struct minimal_symbol *msym;
2177 char *p;
2178 int n;
2179
2180 p = strchr (name, ':');
2181 if (p == NULL)
2182 p = name;
2183 n = p - name;
2184 p = alloca (n + 1);
2185 strncpy (p, name, n);
2186 p[n] = 0;
2187
2188 msym = lookup_minimal_symbol (p, last_source_file,
2189 objfile);
2190 if (msym)
2191 valu = SYMBOL_VALUE_ADDRESS (msym);
2192 }
2193 #endif
2194
2195 #ifdef SUN_FIXED_LBRAC_BUG
2196 /* The Sun acc compiler, under SunOS4, puts out
2197 functions with N_GSYM or N_STSYM. The problem is
2198 that the address of the symbol is no good (for N_GSYM
2199 it doesn't even attept an address; for N_STSYM it
2200 puts out an address but then it gets relocated
2201 relative to the data segment, not the text segment).
2202 Currently we can't fix this up later as we do for
2203 some types of symbol in scan_file_globals.
2204 Fortunately we do have a way of finding the address -
2205 we know that the value in last_pc_address is either
2206 the one we want (if we're dealing with the first
2207 function in an object file), or somewhere in the
2208 previous function. This means that we can use the
2209 minimal symbol table to get the address. */
2210
2211 /* Starting with release 3.0, the Sun acc compiler,
2212 under SunOS4, puts out functions with N_FUN and a value
2213 of zero. This gets relocated to the start of the text
2214 segment of the module, which is no good either.
2215 Under SunOS4 we can deal with this as N_SLINE and N_SO
2216 entries contain valid absolute addresses.
2217 Release 3.0 acc also puts out N_OPT entries, which makes
2218 it possible to discern acc from cc or gcc. */
2219
2220 if (type == N_GSYM || type == N_STSYM
2221 || (type == N_FUN
2222 && n_opt_found && !block_address_function_relative))
2223 {
2224 struct minimal_symbol *m;
2225 int l = colon_pos - name;
2226
2227 m = lookup_minimal_symbol_by_pc (last_pc_address);
2228 if (m && STREQN (SYMBOL_NAME (m), name, l)
2229 && SYMBOL_NAME (m) [l] == '\0')
2230 /* last_pc_address was in this function */
2231 valu = SYMBOL_VALUE (m);
2232 else if (m && SYMBOL_NAME (m+1)
2233 && STREQN (SYMBOL_NAME (m+1), name, l)
2234 && SYMBOL_NAME (m+1) [l] == '\0')
2235 /* last_pc_address was in last function */
2236 valu = SYMBOL_VALUE (m+1);
2237 else
2238 /* Not found - use last_pc_address (for finish_block) */
2239 valu = last_pc_address;
2240 }
2241
2242 last_pc_address = valu; /* Save for SunOS bug circumcision */
2243 #endif
2244
2245 if (block_address_function_relative)
2246 /* For Solaris 2.0 compilers, the block addresses and
2247 N_SLINE's are relative to the start of the
2248 function. On normal systems, and when using gcc on
2249 Solaris 2.0, these addresses are just absolute, or
2250 relative to the N_SO, depending on
2251 BLOCK_ADDRESS_ABSOLUTE. */
2252 function_start_offset = valu;
2253
2254 within_function = 1;
2255 if (context_stack_depth > 0)
2256 {
2257 new = pop_context ();
2258 /* Make a block for the local symbols within. */
2259 finish_block (new->name, &local_symbols, new->old_blocks,
2260 new->start_addr, valu, objfile);
2261 }
2262 /* Stack must be empty now. */
2263 if (context_stack_depth != 0)
2264 complain (&lbrac_unmatched_complaint, symnum);
2265
2266 new = push_context (0, valu);
2267 new->name = define_symbol (valu, name, desc, type, objfile);
2268 break;
2269
2270 default:
2271 define_symbol (valu, name, desc, type, objfile);
2272 break;
2273 }
2274 }
2275 break;
2276
2277 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2278 for a bunch of other flags, too. Someday we may parse their
2279 flags; for now we ignore theirs and hope they'll ignore ours. */
2280 case N_OPT: /* Solaris 2: Compiler options */
2281 if (name)
2282 {
2283 if (STREQ (name, GCC2_COMPILED_FLAG_SYMBOL))
2284 {
2285 processing_gcc_compilation = 2;
2286 #if 1 /* Works, but is experimental. -fnf */
2287 if (AUTO_DEMANGLING)
2288 {
2289 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2290 }
2291 #endif
2292 }
2293 else
2294 n_opt_found = 1;
2295 }
2296 break;
2297
2298 /* The following symbol types can be ignored. */
2299 case N_OBJ: /* Solaris 2: Object file dir and name */
2300 /* N_UNDF: Solaris 2: file separator mark */
2301 /* N_UNDF: -- we will never encounter it, since we only process one
2302 file's symbols at once. */
2303 case N_ENDM: /* Solaris 2: End of module */
2304 case N_MAIN: /* Name of main routine. */
2305 break;
2306 }
2307
2308 previous_stab_code = type;
2309 }
2310 \f
2311 /* FIXME: The only difference between this and elfstab_build_psymtabs
2312 is the call to install_minimal_symbols for elf, and the support for
2313 split sections. If the differences are really that small, the code
2314 should be shared. */
2315
2316 /* Scan and build partial symbols for an coff symbol file.
2317 The coff file has already been processed to get its minimal symbols.
2318
2319 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2320 rolled into one.
2321
2322 OBJFILE is the object file we are reading symbols from.
2323 ADDR is the address relative to which the symbols are (e.g.
2324 the base address of the text segment).
2325 MAINLINE is true if we are reading the main symbol
2326 table (as opposed to a shared lib or dynamically loaded file).
2327 TEXTADDR is the address of the text section.
2328 TEXTSIZE is the size of the text section.
2329 STABSECTS is the list of .stab sections in OBJFILE.
2330 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2331 .stabstr section exists.
2332
2333 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2334 adjusted for coff details. */
2335
2336 void
2337 coffstab_build_psymtabs (objfile, section_offsets, mainline,
2338 textaddr, textsize, stabsects,
2339 stabstroffset, stabstrsize)
2340 struct objfile *objfile;
2341 struct section_offsets *section_offsets;
2342 int mainline;
2343 CORE_ADDR textaddr;
2344 unsigned int textsize;
2345 struct stab_section_list *stabsects;
2346 file_ptr stabstroffset;
2347 unsigned int stabstrsize;
2348 {
2349 int val;
2350 bfd *sym_bfd = objfile->obfd;
2351 char *name = bfd_get_filename (sym_bfd);
2352 struct dbx_symfile_info *info;
2353 unsigned int stabsize;
2354
2355 /* There is already a dbx_symfile_info allocated by our caller.
2356 It might even contain some info from the coff symtab to help us. */
2357 info = (struct dbx_symfile_info *) objfile->sym_stab_info;
2358
2359 DBX_TEXT_ADDR (objfile) = textaddr;
2360 DBX_TEXT_SIZE (objfile) = textsize;
2361
2362 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2363 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
2364 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2365
2366 if (stabstrsize > bfd_get_size (sym_bfd))
2367 error ("ridiculous string table size: %d bytes", stabstrsize);
2368 DBX_STRINGTAB (objfile) = (char *)
2369 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2370 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2371
2372 /* Now read in the string table in one big gulp. */
2373
2374 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2375 if (val < 0)
2376 perror_with_name (name);
2377 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2378 if (val != stabstrsize)
2379 perror_with_name (name);
2380
2381 stabsread_new_init ();
2382 buildsym_new_init ();
2383 free_header_files ();
2384 init_header_files ();
2385
2386 processing_acc_compilation = 1;
2387
2388 /* In a coff file, we've already installed the minimal symbols that came
2389 from the coff (non-stab) symbol table, so always act like an
2390 incremental load here. */
2391 if (stabsects->next == NULL)
2392 {
2393 stabsize = bfd_section_size (sym_bfd, stabsects->section);
2394 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2395 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2396 }
2397 else
2398 {
2399 struct stab_section_list *stabsect;
2400
2401 DBX_SYMCOUNT (objfile) = 0;
2402 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
2403 {
2404 stabsize = bfd_section_size (sym_bfd, stabsect->section);
2405 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
2406 }
2407
2408 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2409
2410 symbuf_sections = stabsects->next;
2411 symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
2412 symbuf_read = 0;
2413 }
2414
2415 dbx_symfile_read (objfile, section_offsets, 0);
2416 }
2417 \f
2418 /* Scan and build partial symbols for an ELF symbol file.
2419 This ELF file has already been processed to get its minimal symbols,
2420 and any DWARF symbols that were in it.
2421
2422 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2423 rolled into one.
2424
2425 OBJFILE is the object file we are reading symbols from.
2426 ADDR is the address relative to which the symbols are (e.g.
2427 the base address of the text segment).
2428 MAINLINE is true if we are reading the main symbol
2429 table (as opposed to a shared lib or dynamically loaded file).
2430 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2431 section exists.
2432 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2433 .stabstr section exists.
2434
2435 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2436 adjusted for elf details. */
2437
2438 void
2439 elfstab_build_psymtabs (objfile, section_offsets, mainline,
2440 staboffset, stabsize,
2441 stabstroffset, stabstrsize)
2442 struct objfile *objfile;
2443 struct section_offsets *section_offsets;
2444 int mainline;
2445 file_ptr staboffset;
2446 unsigned int stabsize;
2447 file_ptr stabstroffset;
2448 unsigned int stabstrsize;
2449 {
2450 int val;
2451 bfd *sym_bfd = objfile->obfd;
2452 char *name = bfd_get_filename (sym_bfd);
2453 struct dbx_symfile_info *info;
2454 asection *text_sect;
2455
2456 /* There is already a dbx_symfile_info allocated by our caller.
2457 It might even contain some info from the ELF symtab to help us. */
2458 info = (struct dbx_symfile_info *) objfile->sym_stab_info;
2459
2460 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
2461 if (!text_sect)
2462 error ("Can't find .text section in symbol file");
2463 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2464 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2465
2466 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2467 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
2468 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2469 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2470 DBX_SYMTAB_OFFSET (objfile) = staboffset;
2471
2472 if (stabstrsize > bfd_get_size (sym_bfd))
2473 error ("ridiculous string table size: %d bytes", stabstrsize);
2474 DBX_STRINGTAB (objfile) = (char *)
2475 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2476 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2477
2478 /* Now read in the string table in one big gulp. */
2479
2480 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2481 if (val < 0)
2482 perror_with_name (name);
2483 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2484 if (val != stabstrsize)
2485 perror_with_name (name);
2486
2487 stabsread_new_init ();
2488 buildsym_new_init ();
2489 free_header_files ();
2490 init_header_files ();
2491 install_minimal_symbols (objfile);
2492
2493 processing_acc_compilation = 1;
2494
2495 /* In an elf file, we've already installed the minimal symbols that came
2496 from the elf (non-stab) symbol table, so always act like an
2497 incremental load here. */
2498 dbx_symfile_read (objfile, section_offsets, 0);
2499 }
2500 \f
2501 /* Scan and build partial symbols for a file with special sections for stabs
2502 and stabstrings. The file has already been processed to get its minimal
2503 symbols, and any other symbols that might be necessary to resolve GSYMs.
2504
2505 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2506 rolled into one.
2507
2508 OBJFILE is the object file we are reading symbols from.
2509 ADDR is the address relative to which the symbols are (e.g. the base address
2510 of the text segment).
2511 MAINLINE is true if we are reading the main symbol table (as opposed to a
2512 shared lib or dynamically loaded file).
2513 STAB_NAME is the name of the section that contains the stabs.
2514 STABSTR_NAME is the name of the section that contains the stab strings.
2515
2516 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2517
2518 void
2519 stabsect_build_psymtabs (objfile, section_offsets, mainline, stab_name,
2520 stabstr_name, text_name)
2521 struct objfile *objfile;
2522 struct section_offsets *section_offsets;
2523 int mainline;
2524 char *stab_name;
2525 char *stabstr_name;
2526 char *text_name;
2527 {
2528 int val;
2529 bfd *sym_bfd = objfile->obfd;
2530 char *name = bfd_get_filename (sym_bfd);
2531 asection *stabsect;
2532 asection *stabstrsect;
2533 asection *text_sect;
2534
2535 stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
2536 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
2537
2538 if (!stabsect)
2539 return;
2540
2541 if (!stabstrsect)
2542 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2543 stab_name, stabstr_name);
2544
2545 objfile->sym_stab_info = (PTR) xmalloc (sizeof (struct dbx_symfile_info));
2546 memset (DBX_SYMFILE_INFO (objfile), 0, sizeof (struct dbx_symfile_info));
2547
2548 text_sect = bfd_get_section_by_name (sym_bfd, text_name);
2549 if (!text_sect)
2550 error ("Can't find %s section in symbol file", text_name);
2551 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2552 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2553
2554 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
2555 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
2556 / DBX_SYMBOL_SIZE (objfile);
2557 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
2558 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2559
2560 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
2561 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
2562 DBX_STRINGTAB (objfile) = (char *)
2563 obstack_alloc (&objfile->psymbol_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
2564 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
2565
2566 /* Now read in the string table in one big gulp. */
2567
2568 val = bfd_get_section_contents (sym_bfd, /* bfd */
2569 stabstrsect, /* bfd section */
2570 DBX_STRINGTAB (objfile), /* input buffer */
2571 0, /* offset into section */
2572 DBX_STRINGTAB_SIZE (objfile)); /* amount to read */
2573
2574 if (!val)
2575 perror_with_name (name);
2576
2577 stabsread_new_init ();
2578 buildsym_new_init ();
2579 free_header_files ();
2580 init_header_files ();
2581 install_minimal_symbols (objfile);
2582
2583 /* Now, do an incremental load */
2584
2585 processing_acc_compilation = 1;
2586 dbx_symfile_read (objfile, section_offsets, 0);
2587 }
2588 \f
2589 static struct sym_fns aout_sym_fns =
2590 {
2591 bfd_target_aout_flavour,
2592 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2593 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2594 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2595 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2596 default_symfile_offsets,
2597 /* sym_offsets: parse user's offsets to internal form */
2598 NULL /* next: pointer to next struct sym_fns */
2599 };
2600
2601 void
2602 _initialize_dbxread ()
2603 {
2604 add_symtab_fns(&aout_sym_fns);
2605 }
This page took 0.084416 seconds and 4 git commands to generate.