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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [dbxread.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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