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