GDB (xrefs)

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