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