OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [dbxread.c] - Blame information for rev 258

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.