* libaout.h (enum machine_type): Change M_SPARCLET from 142 to 131.
[deliverable/binutils-gdb.git] / gdb / os9kread.c
CommitLineData
1340861c 1/* Read os9/os9k symbol tables and convert to internal format, for GDB.
436d4143 2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996
1340861c
KH
3 Free Software Foundation, Inc.
4
5This file is part of GDB.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
6c9638b4 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
1340861c
KH
20
21/* This module provides three functions: os9k_symfile_init,
22 which initializes to read a symbol file; os9k_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and os9k_symfile_read, which reads a symbol table
25 from a file.
26
27 os9k_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. os9k_psymtab_to_symtab() is the function that does this */
34
35#include "defs.h"
2b576293 36#include "gdb_string.h"
1340861c
KH
37#include <stdio.h>
38
39#if defined(USG) || defined(__CYGNUSCLIB__)
40#include <sys/types.h>
41#include <fcntl.h>
42#endif
43
f309ad95 44#include "obstack.h"
2b576293 45#include "gdb_stat.h"
1340861c
KH
46#include <ctype.h>
47#include "symtab.h"
48#include "breakpoint.h"
49#include "command.h"
50#include "target.h"
51#include "gdbcore.h" /* for bfd stuff */
1340861c
KH
52#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
53#include "symfile.h"
54#include "objfiles.h"
55#include "buildsym.h"
56#include "gdb-stabs.h"
57#include "demangle.h"
58#include "language.h" /* Needed inside partial-stab.h */
59#include "complaints.h"
60#include "os9k.h"
25200748 61#include "stabsread.h"
1340861c 62
1340861c
KH
63/* Each partial symbol table entry contains a pointer to private data for the
64 read_symtab() function to use when expanding a partial symbol table entry
65 to a full symbol table entry.
66
67 For dbxread this structure contains the offset within the file symbol table
68 of first local symbol for this file, and count of the section
69 of the symbol table devoted to this file's symbols (actually, the section
70 bracketed may contain more than just this file's symbols). It also contains
71 further information needed to locate the symbols if they are in an ELF file.
72
73 If ldsymcnt is 0, the only reason for this thing's existence is the
74 dependency list. Nothing else will happen when it is read in. */
75
76#define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
77#define LDSYMCNT(p) (((struct symloc *)((p)->read_symtab_private))->ldsymnum)
78
79struct symloc {
80 int ldsymoff;
81 int ldsymnum;
82};
83
84/* Remember what we deduced to be the source language of this psymtab. */
85static enum language psymtab_language = language_unknown;
86
87/* keep partial symbol table file nested depth */
88static int psymfile_depth = 0;
89
90/* keep symbol table file nested depth */
91static int symfile_depth = 0;
92
93/* Nonzero means give verbose info on gdb action. From main.c. */
94extern int info_verbose;
95
96extern int previous_stab_code;
97
1340861c
KH
98/* Name of last function encountered. Used in Solaris to approximate
99 object file boundaries. */
100static char *last_function_name;
101
102/* Complaints about the symbols we have encountered. */
103extern struct complaint lbrac_complaint;
104
105extern struct complaint unknown_symtype_complaint;
106
107extern struct complaint unknown_symchar_complaint;
108
109extern struct complaint lbrac_rbrac_complaint;
110
111extern struct complaint repeated_header_complaint;
112
113extern struct complaint repeated_header_name_complaint;
114
1c95d7ab 115#if 0
1340861c
KH
116static struct complaint lbrac_unmatched_complaint =
117 {"unmatched Increment Block Entry before symtab pos %d", 0, 0};
118
119static struct complaint lbrac_mismatch_complaint =
120 {"IBE/IDE symbol mismatch at symtab pos %d", 0, 0};
1c95d7ab 121#endif
1340861c
KH
122\f
123/* Local function prototypes */
b607efe7
FF
124
125static void
126read_minimal_symbols PARAMS ((struct objfile *, struct section_offsets *));
127
1340861c
KH
128static void
129os9k_read_ofile_symtab PARAMS ((struct partial_symtab *));
130
131static void
132os9k_psymtab_to_symtab PARAMS ((struct partial_symtab *));
133
134static void
135os9k_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
136
137static void
138read_os9k_psymtab PARAMS ((struct section_offsets *, struct objfile *,
139 CORE_ADDR, int));
140
1340861c
KH
141static int
142fill_sym PARAMS ((FILE *, bfd *));
143
144static void
145os9k_symfile_init PARAMS ((struct objfile *));
146
147static void
148os9k_new_init PARAMS ((struct objfile *));
149
150static void
151os9k_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
152
153static void
154os9k_symfile_finish PARAMS ((struct objfile *));
155
156static void
157os9k_process_one_symbol PARAMS ((int, int, CORE_ADDR, char *,
158 struct section_offsets *, struct objfile *));
159
160static struct partial_symtab *
161os9k_start_psymtab PARAMS ((struct objfile *, struct section_offsets *, char *,
2ad5709f
FF
162 CORE_ADDR, int, int, struct partial_symbol **,
163 struct partial_symbol **));
1340861c
KH
164
165static struct partial_symtab *
166os9k_end_psymtab PARAMS ((struct partial_symtab *, char **, int, int, CORE_ADDR,
167 struct partial_symtab **, int));
168
169static void
d80ff70c
KH
170record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *,
171 struct section_offsets *));
1340861c
KH
172\f
173#define HANDLE_RBRAC(val) \
174 if ((val) > pst->texthigh) pst->texthigh = (val);
175
176#define SWAP_STBHDR(hdrp, abfd) \
177 { \
178 (hdrp)->fmtno = bfd_get_16(abfd, (unsigned char *)&(hdrp)->fmtno); \
179 (hdrp)->crc = bfd_get_32(abfd, (unsigned char *)&(hdrp)->crc); \
180 (hdrp)->offset = bfd_get_32(abfd, (unsigned char *)&(hdrp)->offset); \
181 (hdrp)->nsym = bfd_get_32(abfd, (unsigned char *)&(hdrp)->nsym); \
182 }
183#define SWAP_STBSYM(symp, abfd) \
184 { \
185 (symp)->value = bfd_get_32(abfd, (unsigned char *)&(symp)->value); \
186 (symp)->type = bfd_get_16(abfd, (unsigned char *)&(symp)->type); \
187 (symp)->stroff = bfd_get_32(abfd, (unsigned char *)&(symp)->stroff); \
188 }
189#define N_DATA 0
190#define N_BSS 1
191#define N_RDATA 2
192#define N_IDATA 3
193#define N_TEXT 4
194#define N_ABS 6
195
196static void
d80ff70c 197record_minimal_symbol (name, address, type, objfile, section_offsets)
1340861c
KH
198 char *name;
199 CORE_ADDR address;
200 int type;
201 struct objfile *objfile;
d80ff70c 202 struct section_offsets *section_offsets;
1340861c
KH
203{
204 enum minimal_symbol_type ms_type;
205
206 switch (type)
207 {
d80ff70c
KH
208 case N_TEXT:
209 ms_type = mst_text;
210 address += ANOFFSET(section_offsets, SECT_OFF_TEXT);
211 break;
212 case N_DATA:
213 ms_type = mst_data;
214 break;
215 case N_BSS:
216 ms_type = mst_bss;
217 break;
218 case N_RDATA:
219 ms_type = mst_bss;
220 break;
221 case N_IDATA:
222 ms_type = mst_data;
223 break;
224 case N_ABS:
225 ms_type = mst_abs;
226 break;
227 default:
228 ms_type = mst_unknown; break;
1340861c
KH
229 }
230
ace4b8d7 231 prim_record_minimal_symbol (name, address, ms_type, objfile);
1340861c
KH
232}
233
234/* read and process .stb file and store in minimal symbol table */
235typedef char mhhdr[80];
236struct stbhdr {
237 mhhdr comhdr;
238 char * name;
239 short fmtno;
240 int crc;
241 int offset;
242 int nsym;
243 char *pad;
244};
245struct stbsymbol {
246 int value;
247 short type;
248 int stroff;
249};
250#define STBSYMSIZE 10
251
1c95d7ab 252static void
d80ff70c 253read_minimal_symbols(objfile, section_offsets)
1340861c 254 struct objfile *objfile;
d80ff70c 255 struct section_offsets *section_offsets;
1340861c
KH
256{
257FILE *fp;
258bfd *abfd;
259struct stbhdr hdr;
260struct stbsymbol sym;
261int ch, i, j, off;
262char buf[64], buf1[128];
263
264 fp = objfile->auxf1;
265 if (fp == NULL) return;
266 abfd = objfile->obfd;
267 fread(&hdr.comhdr[0], sizeof(mhhdr), 1, fp);
268 i = 0;
269 ch = getc(fp);
270 while (ch != -1) {
271 buf[i] = (char)ch;
272 i++;
273 if (ch == 0) break;
274 ch = getc(fp);
275 };
d9389f37 276 if (i%2) ch=getc(fp);
1340861c
KH
277 hdr.name = &buf[0];
278
279 fread(&hdr.fmtno, sizeof(hdr.fmtno), 1, fp);
280 fread(&hdr.crc, sizeof(hdr.crc), 1, fp);
281 fread(&hdr.offset, sizeof(hdr.offset), 1, fp);
282 fread(&hdr.nsym, sizeof(hdr.nsym), 1, fp);
283 SWAP_STBHDR(&hdr, abfd);
284
285 /* read symbols */
286 init_minimal_symbol_collection();
287 off = hdr.offset;
288 for (i = hdr.nsym; i > 0; i--) {
289 fseek(fp, (long)off, 0);
290 fread(&sym.value, sizeof(sym.value), 1, fp);
291 fread(&sym.type, sizeof(sym.type), 1, fp);
292 fread(&sym.stroff, sizeof(sym.stroff), 1, fp);
293 SWAP_STBSYM (&sym, abfd);
294 fseek(fp, (long)sym.stroff, 0);
295 j = 0;
296 ch = getc(fp);
297 while (ch != -1) {
298 buf1[j] = (char)ch;
299 j++;
300 if (ch == 0) break;
301 ch = getc(fp);
302 };
d80ff70c 303 record_minimal_symbol(buf1, sym.value, sym.type&7, objfile, section_offsets);
1340861c
KH
304 off += STBSYMSIZE;
305 };
306 install_minimal_symbols (objfile);
1c95d7ab 307 return;
1340861c
KH
308}
309\f
310/* Scan and build partial symbols for a symbol file.
311 We have been initialized by a call to os9k_symfile_init, which
312 put all the relevant info into a "struct os9k_symfile_info",
313 hung off the objfile structure.
314
315 SECTION_OFFSETS contains offsets relative to which the symbols in the
316 various sections are (depending where the sections were actually loaded).
317 MAINLINE is true if we are reading the main symbol
318 table (as opposed to a shared lib or dynamically loaded file). */
319
320static void
321os9k_symfile_read (objfile, section_offsets, mainline)
322 struct objfile *objfile;
323 struct section_offsets *section_offsets;
324 int mainline; /* FIXME comments above */
325{
326 bfd *sym_bfd;
1340861c
KH
327 struct cleanup *back_to;
328
329 sym_bfd = objfile->obfd;
330 /* If we are reinitializing, or if we have never loaded syms yet, init */
331 if (mainline || objfile->global_psymbols.size == 0 ||
332 objfile->static_psymbols.size == 0)
a367db89 333 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
1340861c 334
a7f56d5a 335 free_pending_blocks ();
1340861c
KH
336 back_to = make_cleanup (really_free_pendings, 0);
337
338 make_cleanup (discard_minimal_symbols, 0);
d80ff70c 339 read_minimal_symbols (objfile, section_offsets);
1340861c
KH
340
341 /* Now that the symbol table data of the executable file are all in core,
342 process them and define symbols accordingly. */
343 read_os9k_psymtab (section_offsets, objfile,
f779e99f
ILT
344 DBX_TEXT_ADDR (objfile),
345 DBX_TEXT_SIZE (objfile));
1340861c 346
1340861c
KH
347 do_cleanups (back_to);
348}
349
350/* Initialize anything that needs initializing when a completely new
351 symbol file is specified (not just adding some symbols from another
352 file, e.g. a shared library). */
353
354static void
355os9k_new_init (ignore)
356 struct objfile *ignore;
357{
358 stabsread_new_init ();
359 buildsym_new_init ();
360 psymfile_depth = 0;
361/*
362 init_header_files ();
363*/
364}
365
366/* os9k_symfile_init ()
367 It is passed a struct objfile which contains, among other things,
368 the BFD for the file whose symbols are being read, and a slot for a pointer
369 to "private data" which we fill with goodies.
370
371 Since BFD doesn't know how to read debug symbols in a format-independent
372 way (and may never do so...), we have to do it ourselves. We will never
373 be called unless this is an a.out (or very similar) file.
374 FIXME, there should be a cleaner peephole into the BFD environment here. */
375
376static void
377os9k_symfile_init (objfile)
378 struct objfile *objfile;
379{
1340861c
KH
380 bfd *sym_bfd = objfile->obfd;
381 char *name = bfd_get_filename (sym_bfd);
d80ff70c 382 char dbgname[512], stbname[512];
1340861c
KH
383 FILE *symfile = 0;
384 FILE *minfile = 0;
f779e99f 385 asection *text_sect;
1340861c
KH
386
387 strcpy(dbgname, name);
388 strcat(dbgname, ".dbg");
389 strcpy(stbname, name);
390 strcat(stbname, ".stb");
391
392 if ((symfile = fopen(dbgname, "r")) == NULL) {
393 warning("Symbol file %s not found", dbgname);
394 }
395 objfile->auxf2 = symfile;
396
397 if ((minfile = fopen(stbname, "r")) == NULL) {
398 warning("Symbol file %s not found", stbname);
399 }
400 objfile->auxf1 = minfile;
401
402 /* Allocate struct to keep track of the symfile */
403 objfile->sym_stab_info = (PTR)
404 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
405 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
406
f779e99f
ILT
407 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
408 if (!text_sect)
1340861c 409 error ("Can't find .text section in file");
f779e99f
ILT
410 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
411 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
1340861c
KH
412
413 DBX_SYMBOL_SIZE (objfile) = 0; /* variable size symbol */
414 DBX_SYMCOUNT (objfile) = 0; /* used to be bfd_get_symcount(sym_bfd) */
415 DBX_SYMTAB_OFFSET (objfile) = 0; /* used to be SYMBOL_TABLE_OFFSET */
416}
417
418/* Perform any local cleanups required when we are done with a particular
419 objfile. I.E, we are in the process of discarding all symbol information
420 for an objfile, freeing up all memory held for it, and unlinking the
421 objfile struct from the global list of known objfiles. */
422
423static void
424os9k_symfile_finish (objfile)
425 struct objfile *objfile;
426{
427 if (objfile->sym_stab_info != NULL)
428 {
429 mfree (objfile -> md, objfile->sym_stab_info);
430 }
431/*
432 free_header_files ();
433*/
434}
435
436\f
d9389f37 437struct st_dbghdr {
1340861c
KH
438 int sync;
439 short rev;
440 int crc;
441 short os;
442 short cpu;
443};
d9389f37 444#define SYNC (int)0xefbefeca
1340861c
KH
445
446#define SWAP_DBGHDR(hdrp, abfd) \
447 { \
448 (hdrp)->sync = bfd_get_32(abfd, (unsigned char *)&(hdrp)->sync); \
449 (hdrp)->rev = bfd_get_16(abfd, (unsigned char *)&(hdrp)->rev); \
450 (hdrp)->crc = bfd_get_32(abfd, (unsigned char *)&(hdrp)->crc); \
451 (hdrp)->os = bfd_get_16(abfd, (unsigned char *)&(hdrp)->os); \
452 (hdrp)->cpu = bfd_get_16(abfd, (unsigned char *)&(hdrp)->cpu); \
453 }
454
455#define N_SYM_CMPLR 0
456#define N_SYM_SLINE 1
457#define N_SYM_SYM 2
458#define N_SYM_LBRAC 3
459#define N_SYM_RBRAC 4
460#define N_SYM_SE 5
461
462struct internal_symstruct {
463 short n_type;
464 short n_desc;
465 long n_value;
466 char * n_strx;
467};
468static struct internal_symstruct symbol;
469static struct internal_symstruct *symbuf = &symbol;
d9389f37
KH
470static char strbuf[4096];
471static struct st_dbghdr dbghdr;
472static short cmplrid;
473
474#define VER_PRE_ULTRAC ((short)4)
475#define VER_ULTRAC ((short)5)
1340861c
KH
476
477static int
478fill_sym (dbg_file, abfd)
479 FILE *dbg_file;
480 bfd *abfd;
481{
d9389f37 482short si, nmask;
1340861c
KH
483long li;
484int ii;
d9389f37 485char *p;
1340861c
KH
486
487 int nbytes = fread(&si, sizeof(si), 1, dbg_file);
488 if (nbytes == 0)
489 return 0;
490 if (nbytes < 0)
491 perror_with_name ("reading .dbg file.");
492 symbuf->n_desc = 0;
493 symbuf->n_value = 0;
494 symbuf->n_strx = NULL;
495 symbuf->n_type = bfd_get_16 (abfd, (unsigned char *)&si);
496 symbuf->n_type = 0xf & symbuf->n_type;
497 switch (symbuf->n_type)
498 {
499 case N_SYM_CMPLR:
500 fread(&si, sizeof(si), 1, dbg_file);
501 symbuf->n_desc = bfd_get_16(abfd, (unsigned char *)&si);
d9389f37 502 cmplrid = symbuf->n_desc & 0xff;
1340861c
KH
503 break;
504 case N_SYM_SLINE:
505 fread(&li, sizeof(li), 1, dbg_file);
506 symbuf->n_value = bfd_get_32(abfd, (unsigned char *)&li);
507 fread(&li, sizeof(li), 1, dbg_file);
508 li = bfd_get_32(abfd, (unsigned char *)&li);
509 symbuf->n_strx = (char *)(li >> 12);
510 symbuf->n_desc = li & 0xfff;
511 break;
512 case N_SYM_SYM:
513 fread(&li, sizeof(li), 1, dbg_file);
514 symbuf->n_value = bfd_get_32(abfd, (unsigned char *)&li);
515 si = 0;
516 do {
517 ii = getc(dbg_file);
518 strbuf[si++] = (char) ii;
519 } while (ii != 0 || si % 2 != 0);
520 symbuf->n_strx = strbuf;
d9389f37
KH
521 p = (char *) strchr (strbuf, ':');
522 if (!p) break;
523 if ((p[1] == 'F' || p[1] == 'f') && cmplrid == VER_PRE_ULTRAC)
524 {
525 fread(&si, sizeof(si), 1, dbg_file);
526 nmask = bfd_get_16(abfd, (unsigned char *)&si);
527 for (ii=0; ii<nmask; ii++)
528 fread(&si, sizeof(si), 1, dbg_file);
529 }
1340861c
KH
530 break;
531 case N_SYM_LBRAC:
532 fread(&li, sizeof(li), 1, dbg_file);
533 symbuf->n_value = bfd_get_32(abfd, (unsigned char *)&li);
534 break;
535 case N_SYM_RBRAC:
536 fread(&li, sizeof(li), 1, dbg_file);
537 symbuf->n_value = bfd_get_32(abfd, (unsigned char *)&li);
538 break;
539 case N_SYM_SE:
540 break;
541 }
542 return 1;
543}
544\f
1340861c
KH
545/* Given pointers to an a.out symbol table in core containing dbx
546 style data, setup partial_symtab's describing each source file for
547 which debugging information is available.
548 SYMFILE_NAME is the name of the file we are reading from
549 and SECTION_OFFSETS is the set of offsets for the various sections
550 of the file (a set of zeros if the mainline program). */
551
552static void
553read_os9k_psymtab (section_offsets, objfile, text_addr, text_size)
554 struct section_offsets *section_offsets;
555 struct objfile *objfile;
556 CORE_ADDR text_addr;
557 int text_size;
558{
559 register struct internal_symstruct *bufp = 0; /* =0 avoids gcc -Wall glitch*/
560 register char *namestring;
1340861c
KH
561 int past_first_source_file = 0;
562 CORE_ADDR last_o_file_start = 0;
1c95d7ab 563#if 0
1340861c 564 struct cleanup *back_to;
1c95d7ab 565#endif
1340861c
KH
566 bfd *abfd;
567 FILE *fp;
1340861c
KH
568
569 /* End of the text segment of the executable file. */
570 static CORE_ADDR end_of_text_addr;
571
572 /* Current partial symtab */
573 static struct partial_symtab *pst = 0;
574
575 /* List of current psymtab's include files */
576 char **psymtab_include_list;
577 int includes_allocated;
578 int includes_used;
579
580 /* Index within current psymtab dependency list */
581 struct partial_symtab **dependency_list;
582 int dependencies_used, dependencies_allocated;
583
584 includes_allocated = 30;
585 includes_used = 0;
586 psymtab_include_list = (char **) alloca (includes_allocated *
587 sizeof (char *));
588
589 dependencies_allocated = 30;
590 dependencies_used = 0;
591 dependency_list =
592 (struct partial_symtab **) alloca (dependencies_allocated *
593 sizeof (struct partial_symtab *));
594
595 last_source_file = NULL;
596
597#ifdef END_OF_TEXT_DEFAULT
598 end_of_text_addr = END_OF_TEXT_DEFAULT;
599#else
600 end_of_text_addr = text_addr + section_offsets->offsets[SECT_OFF_TEXT]
601 + text_size; /* Relocate */
602#endif
603
604 abfd = objfile->obfd;
605 fp = objfile->auxf2;
d80ff70c 606 if (!fp) return;
1340861c 607
d9389f37
KH
608 fread(&dbghdr.sync, sizeof(dbghdr.sync), 1, fp);
609 fread(&dbghdr.rev, sizeof(dbghdr.rev), 1, fp);
610 fread(&dbghdr.crc, sizeof(dbghdr.crc), 1, fp);
611 fread(&dbghdr.os, sizeof(dbghdr.os), 1, fp);
612 fread(&dbghdr.cpu, sizeof(dbghdr.cpu), 1, fp);
613 SWAP_DBGHDR(&dbghdr, abfd);
1340861c
KH
614
615 symnum = 0;
616 while(1)
617 {
618 int ret;
619 long cursymoffset;
620
621 /* Get the symbol for this run and pull out some info */
622 QUIT; /* allow this to be interruptable */
623 cursymoffset = ftell(objfile->auxf2);
624 ret = fill_sym(objfile->auxf2, abfd);
625 if (ret <= 0) break;
626 else symnum++;
627 bufp = symbuf;
628
629 /* Special case to speed up readin. */
630 if (bufp->n_type == (short)N_SYM_SLINE) continue;
631
632#define CUR_SYMBOL_VALUE bufp->n_value
633 /* partial-stab.h */
634
635 switch (bufp->n_type)
636 {
637 char *p;
638
639 case N_SYM_CMPLR:
640 continue;
641
642 case N_SYM_SE:
643 CUR_SYMBOL_VALUE += ANOFFSET(section_offsets, SECT_OFF_TEXT);
644 if (psymfile_depth == 1 && pst)
645 {
646 os9k_end_psymtab (pst, psymtab_include_list, includes_used,
647 symnum, CUR_SYMBOL_VALUE,
648 dependency_list, dependencies_used);
649 pst = (struct partial_symtab *) 0;
650 includes_used = 0;
651 dependencies_used = 0;
652 }
653 psymfile_depth--;
654 continue;
655
656 case N_SYM_SYM: /* Typedef or automatic variable. */
657 namestring = bufp->n_strx;
658 p = (char *) strchr (namestring, ':');
659 if (!p)
660 continue; /* Not a debugging symbol. */
661
662 /* Main processing section for debugging symbols which
663 the initial read through the symbol tables needs to worry
664 about. If we reach this point, the symbol which we are
665 considering is definitely one we are interested in.
666 p must also contain the (valid) index into the namestring
667 which indicates the debugging type symbol. */
668
669 switch (p[1])
670 {
671 case 'S' :
672 {
673 unsigned long valu;
674 enum language tmp_language;
d5336fc5
KH
675 char *str, *p;
676 int n;
1340861c 677
d80ff70c
KH
678 valu = CUR_SYMBOL_VALUE;
679 if (valu)
680 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1340861c
KH
681 past_first_source_file = 1;
682
d5336fc5
KH
683 p = strchr(namestring, ':');
684 if (p) n = p-namestring;
685 else n = strlen(namestring);
686 str = alloca(n+1);
687 strncpy(str, namestring, n);
688 str[n] = '\0';
689
1340861c
KH
690 if (psymfile_depth == 0) {
691 if (!pst)
692 pst = os9k_start_psymtab (objfile, section_offsets,
d5336fc5 693 str, valu,
1340861c
KH
694 cursymoffset,
695 symnum-1,
696 objfile -> global_psymbols.next,
697 objfile -> static_psymbols.next);
698 } else { /* this is a include file */
d5336fc5 699 tmp_language = deduce_language_from_filename (str);
1340861c
KH
700 if (tmp_language != language_unknown
701 && (tmp_language != language_c
702 || psymtab_language != language_cplus))
703 psymtab_language = tmp_language;
704
705/*
d5336fc5 706 if (pst && STREQ (str, pst->filename))
1340861c
KH
707 continue;
708 {
709 register int i;
710 for (i = 0; i < includes_used; i++)
d5336fc5 711 if (STREQ (str, psymtab_include_list[i]))
1340861c
KH
712 {
713 i = -1;
714 break;
715 }
716 if (i == -1)
717 continue;
718 }
719*/
720
d5336fc5 721 psymtab_include_list[includes_used++] = str;
1340861c
KH
722 if (includes_used >= includes_allocated)
723 {
724 char **orig = psymtab_include_list;
725
726 psymtab_include_list = (char **)
727 alloca ((includes_allocated *= 2) * sizeof (char *));
728 memcpy ((PTR)psymtab_include_list, (PTR)orig,
729 includes_used * sizeof (char *));
730 }
731
732 }
733 psymfile_depth++;
734 continue;
735 }
736
737 case 'v':
eae8aa30
FF
738 add_psymbol_to_list (namestring, p - namestring,
739 VAR_NAMESPACE, LOC_STATIC,
740 &objfile->static_psymbols,
741 0, CUR_SYMBOL_VALUE,
742 psymtab_language, objfile);
1340861c
KH
743 continue;
744 case 'V':
eae8aa30
FF
745 add_psymbol_to_list (namestring, p - namestring,
746 VAR_NAMESPACE, LOC_STATIC,
747 &objfile->global_psymbols,
748 0, CUR_SYMBOL_VALUE,
749 psymtab_language, objfile);
1340861c
KH
750 continue;
751
752 case 'T':
753 if (p != namestring) /* a name is there, not just :T... */
754 {
eae8aa30 755 add_psymbol_to_list (namestring, p - namestring,
1340861c 756 STRUCT_NAMESPACE, LOC_TYPEDEF,
eae8aa30
FF
757 &objfile->static_psymbols,
758 CUR_SYMBOL_VALUE, 0,
1340861c
KH
759 psymtab_language, objfile);
760 if (p[2] == 't')
761 {
762 /* Also a typedef with the same name. */
eae8aa30 763 add_psymbol_to_list (namestring, p - namestring,
1340861c 764 VAR_NAMESPACE, LOC_TYPEDEF,
eae8aa30
FF
765 &objfile->static_psymbols,
766 CUR_SYMBOL_VALUE, 0, psymtab_language,
1340861c
KH
767 objfile);
768 p += 1;
769 }
770 /* The semantics of C++ state that "struct foo { ... }"
771 also defines a typedef for "foo". Unfortuantely, cfront
772 never makes the typedef when translating from C++ to C.
773 We make the typedef here so that "ptype foo" works as
774 expected for cfront translated code. */
775 else if (psymtab_language == language_cplus)
776 {
777 /* Also a typedef with the same name. */
eae8aa30 778 add_psymbol_to_list (namestring, p - namestring,
1340861c 779 VAR_NAMESPACE, LOC_TYPEDEF,
eae8aa30
FF
780 &objfile->static_psymbols,
781 CUR_SYMBOL_VALUE, 0, psymtab_language,
1340861c
KH
782 objfile);
783 }
784 }
785 goto check_enum;
786 case 't':
787 if (p != namestring) /* a name is there, not just :T... */
788 {
eae8aa30 789 add_psymbol_to_list (namestring, p - namestring,
1340861c 790 VAR_NAMESPACE, LOC_TYPEDEF,
eae8aa30
FF
791 &objfile->static_psymbols,
792 CUR_SYMBOL_VALUE, 0,
1340861c
KH
793 psymtab_language, objfile);
794 }
795 check_enum:
796 /* If this is an enumerated type, we need to
797 add all the enum constants to the partial symbol
798 table. This does not cover enums without names, e.g.
799 "enum {a, b} c;" in C, but fortunately those are
800 rare. There is no way for GDB to find those from the
801 enum type without spending too much time on it. Thus
802 to solve this problem, the compiler needs to put out the
803 enum in a nameless type. GCC2 does this. */
804
805 /* We are looking for something of the form
806 <name> ":" ("t" | "T") [<number> "="] "e" <size>
807 {<constant> ":" <value> ","} ";". */
808
809 /* Skip over the colon and the 't' or 'T'. */
810 p += 2;
811 /* This type may be given a number. Also, numbers can come
812 in pairs like (0,26). Skip over it. */
813 while ((*p >= '0' && *p <= '9')
814 || *p == '(' || *p == ',' || *p == ')'
815 || *p == '=')
816 p++;
817
818 if (*p++ == 'e')
819 {
820 /* We have found an enumerated type. skip size */
821 while (*p >= '0' && *p <= '9') p++;
822 /* According to comments in read_enum_type
823 a comma could end it instead of a semicolon.
824 I don't know where that happens.
825 Accept either. */
826 while (*p && *p != ';' && *p != ',')
827 {
828 char *q;
829
830 /* Check for and handle cretinous dbx symbol name
831 continuation!
832 if (*p == '\\')
2dd30c72 833 p = next_symbol_text (objfile);
1340861c
KH
834 */
835
836 /* Point to the character after the name
837 of the enum constant. */
838 for (q = p; *q && *q != ':'; q++)
839 ;
840 /* Note that the value doesn't matter for
841 enum constants in psymtabs, just in symtabs. */
eae8aa30 842 add_psymbol_to_list (p, q - p,
1340861c 843 VAR_NAMESPACE, LOC_CONST,
eae8aa30
FF
844 &objfile->static_psymbols, 0,
845 0, psymtab_language, objfile);
1340861c
KH
846 /* Point past the name. */
847 p = q;
848 /* Skip over the value. */
849 while (*p && *p != ',')
850 p++;
851 /* Advance past the comma. */
852 if (*p)
853 p++;
854 }
855 }
856 continue;
857 case 'c':
858 /* Constant, e.g. from "const" in Pascal. */
eae8aa30 859 add_psymbol_to_list (namestring, p - namestring,
1340861c 860 VAR_NAMESPACE, LOC_CONST,
eae8aa30
FF
861 &objfile->static_psymbols, CUR_SYMBOL_VALUE,
862 0, psymtab_language, objfile);
1340861c
KH
863 continue;
864
865 case 'f':
866 CUR_SYMBOL_VALUE += ANOFFSET(section_offsets, SECT_OFF_TEXT);
867 if (pst && pst->textlow == 0)
868 pst->textlow = CUR_SYMBOL_VALUE;
869
eae8aa30 870 add_psymbol_to_list (namestring, p - namestring,
1340861c 871 VAR_NAMESPACE, LOC_BLOCK,
eae8aa30
FF
872 &objfile->static_psymbols, CUR_SYMBOL_VALUE,
873 0, psymtab_language, objfile);
1340861c
KH
874 continue;
875
876 case 'F':
877 CUR_SYMBOL_VALUE += ANOFFSET(section_offsets, SECT_OFF_TEXT);
878 if (pst && pst->textlow == 0)
879 pst->textlow = CUR_SYMBOL_VALUE;
880
eae8aa30 881 add_psymbol_to_list (namestring, p - namestring,
1340861c 882 VAR_NAMESPACE, LOC_BLOCK,
eae8aa30
FF
883 &objfile->global_psymbols, CUR_SYMBOL_VALUE,
884 0, psymtab_language, objfile);
1340861c
KH
885 continue;
886
887 case 'p':
888 case 'l':
d9389f37 889 case 's':
1340861c
KH
890 continue;
891
892 case ':':
893 /* It is a C++ nested symbol. We don't need to record it
894 (I don't think); if we try to look up foo::bar::baz,
895 then symbols for the symtab containing foo should get
896 read in, I think. */
897 /* Someone says sun cc puts out symbols like
898 /foo/baz/maclib::/usr/local/bin/maclib,
899 which would get here with a symbol type of ':'. */
900 continue;
901
902 default:
903 /* Unexpected symbol descriptor. The second and subsequent stabs
904 of a continued stab can show up here. The question is
905 whether they ever can mimic a normal stab--it would be
906 nice if not, since we certainly don't want to spend the
907 time searching to the end of every string looking for
908 a backslash. */
909
910 complain (&unknown_symchar_complaint, p[1]);
911 continue;
912 }
913
914 case N_SYM_RBRAC:
915 CUR_SYMBOL_VALUE += ANOFFSET(section_offsets, SECT_OFF_TEXT);
916#ifdef HANDLE_RBRAC
917 HANDLE_RBRAC(CUR_SYMBOL_VALUE);
918 continue;
919#endif
920 case N_SYM_LBRAC:
921 continue;
922
923 default:
924 /* If we haven't found it yet, ignore it. It's probably some
925 new type we don't know about yet. */
926 complain (&unknown_symtype_complaint,
927 local_hex_string ((unsigned long) bufp->n_type));
928 continue;
929 }
930 }
931
932 DBX_SYMCOUNT (objfile) = symnum;
933
934 /* If there's stuff to be cleaned up, clean it up. */
935 if (DBX_SYMCOUNT (objfile) > 0
936/*FIXME, does this have a bug at start address 0? */
937 && last_o_file_start
938 && objfile -> ei.entry_point < bufp->n_value
939 && objfile -> ei.entry_point >= last_o_file_start)
940 {
941 objfile -> ei.entry_file_lowpc = last_o_file_start;
942 objfile -> ei.entry_file_highpc = bufp->n_value;
943 }
944
945 if (pst)
946 {
947 os9k_end_psymtab (pst, psymtab_include_list, includes_used,
948 symnum, end_of_text_addr,
949 dependency_list, dependencies_used);
950 }
951/*
952 do_cleanups (back_to);
953*/
954}
955
956/* Allocate and partially fill a partial symtab. It will be
957 completely filled at the end of the symbol list.
958
959 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
960 is the address relative to which its symbols are (incremental) or 0
961 (normal). */
962
963
964static struct partial_symtab *
965os9k_start_psymtab (objfile, section_offsets,
966 filename, textlow, ldsymoff,ldsymcnt, global_syms, static_syms)
967 struct objfile *objfile;
968 struct section_offsets *section_offsets;
969 char *filename;
970 CORE_ADDR textlow;
971 int ldsymoff;
972 int ldsymcnt;
2ad5709f
FF
973 struct partial_symbol **global_syms;
974 struct partial_symbol **static_syms;
1340861c
KH
975{
976 struct partial_symtab *result =
977 start_psymtab_common(objfile, section_offsets,
978 filename, textlow, global_syms, static_syms);
979
980 result->read_symtab_private = (char *)
981 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
982
983 LDSYMOFF(result) = ldsymoff;
984 LDSYMCNT(result) = ldsymcnt;
985 result->read_symtab = os9k_psymtab_to_symtab;
986
987 /* Deduce the source language from the filename for this psymtab. */
988 psymtab_language = deduce_language_from_filename (filename);
989 return result;
990}
991
992/* Close off the current usage of PST.
993 Returns PST or NULL if the partial symtab was empty and thrown away.
994 FIXME: List variables and peculiarities of same. */
995
996static struct partial_symtab *
997os9k_end_psymtab (pst, include_list, num_includes, capping_symbol_cnt,
998 capping_text, dependency_list, number_dependencies)
999 struct partial_symtab *pst;
1000 char **include_list;
1001 int num_includes;
1002 int capping_symbol_cnt;
1003 CORE_ADDR capping_text;
1004 struct partial_symtab **dependency_list;
1005 int number_dependencies;
1006/* struct partial_symbol *capping_global, *capping_static;*/
1007{
1008 int i;
1009 struct partial_symtab *p1;
1010 struct objfile *objfile = pst -> objfile;
1011
1012 if (capping_symbol_cnt != -1)
1013 LDSYMCNT(pst) = capping_symbol_cnt - LDSYMCNT(pst);
1014
1015 /* Under Solaris, the N_SO symbols always have a value of 0,
1016 instead of the usual address of the .o file. Therefore,
1017 we have to do some tricks to fill in texthigh and textlow.
1018 The first trick is in partial-stab.h: if we see a static
1019 or global function, and the textlow for the current pst
1020 is still 0, then we use that function's address for
1021 the textlow of the pst.
1022
1023 Now, to fill in texthigh, we remember the last function seen
1024 in the .o file (also in partial-stab.h). Also, there's a hack in
1025 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1026 to here via the misc_info field. Therefore, we can fill in
1027 a reliable texthigh by taking the address plus size of the
1028 last function in the file.
1029
1030 Unfortunately, that does not cover the case where the last function
1031 in the file is static. See the paragraph below for more comments
1032 on this situation.
1033
1034 Finally, if we have a valid textlow for the current file, we run
1035 down the partial_symtab_list filling in previous texthighs that
1036 are still unknown. */
1037
1038 if (pst->texthigh == 0 && last_function_name) {
1039 char *p;
1040 int n;
1041 struct minimal_symbol *minsym;
1042
1043 p = strchr (last_function_name, ':');
1044 if (p == NULL)
1045 p = last_function_name;
1046 n = p - last_function_name;
1047 p = alloca (n + 1);
1048 strncpy (p, last_function_name, n);
1049 p[n] = 0;
1050
2d336b1b 1051 minsym = lookup_minimal_symbol (p, NULL, objfile);
1340861c
KH
1052
1053 if (minsym) {
1054 pst->texthigh = SYMBOL_VALUE_ADDRESS(minsym)+(long)MSYMBOL_INFO(minsym);
1055 } else {
1056 /* This file ends with a static function, and it's
1057 difficult to imagine how hard it would be to track down
1058 the elf symbol. Luckily, most of the time no one will notice,
1059 since the next file will likely be compiled with -g, so
1060 the code below will copy the first fuction's start address
1061 back to our texthigh variable. (Also, if this file is the
1062 last one in a dynamically linked program, texthigh already
1063 has the right value.) If the next file isn't compiled
1064 with -g, then the last function in this file winds up owning
1065 all of the text space up to the next -g file, or the end (minus
1066 shared libraries). This only matters for single stepping,
1067 and even then it will still work, except that it will single
1068 step through all of the covered functions, instead of setting
1069 breakpoints around them as it usualy does. This makes it
1070 pretty slow, but at least it doesn't fail.
1071
1072 We can fix this with a fairly big change to bfd, but we need
1073 to coordinate better with Cygnus if we want to do that. FIXME. */
1074 }
1075 last_function_name = NULL;
1076 }
1077
1078 /* this test will be true if the last .o file is only data */
1079 if (pst->textlow == 0)
1080 pst->textlow = pst->texthigh;
1081
1082 /* If we know our own starting text address, then walk through all other
1083 psymtabs for this objfile, and if any didn't know their ending text
1084 address, set it to our starting address. Take care to not set our
1085 own ending address to our starting address, nor to set addresses on
1086 `dependency' files that have both textlow and texthigh zero. */
1087 if (pst->textlow) {
1088 ALL_OBJFILE_PSYMTABS (objfile, p1) {
1089 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) {
1090 p1->texthigh = pst->textlow;
1091 /* if this file has only data, then make textlow match texthigh */
1092 if (p1->textlow == 0)
1093 p1->textlow = p1->texthigh;
1094 }
1095 }
1096 }
1097
1098 /* End of kludge for patching Solaris textlow and texthigh. */
1099
1100 pst->n_global_syms =
1101 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1102 pst->n_static_syms =
1103 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1104
1105 pst->number_of_dependencies = number_dependencies;
1106 if (number_dependencies)
1107 {
1108 pst->dependencies = (struct partial_symtab **)
1109 obstack_alloc (&objfile->psymbol_obstack,
1110 number_dependencies * sizeof (struct partial_symtab *));
1111 memcpy (pst->dependencies, dependency_list,
1112 number_dependencies * sizeof (struct partial_symtab *));
1113 }
1114 else
1115 pst->dependencies = 0;
1116
1117 for (i = 0; i < num_includes; i++)
1118 {
1119 struct partial_symtab *subpst =
1120 allocate_psymtab (include_list[i], objfile);
1121
1122 subpst->section_offsets = pst->section_offsets;
1123 subpst->read_symtab_private =
1124 (char *) obstack_alloc (&objfile->psymbol_obstack,
1125 sizeof (struct symloc));
1126 LDSYMOFF(subpst) =
1127 LDSYMCNT(subpst) =
1128 subpst->textlow =
1129 subpst->texthigh = 0;
1130
1131 /* We could save slight bits of space by only making one of these,
1132 shared by the entire set of include files. FIXME-someday. */
1133 subpst->dependencies = (struct partial_symtab **)
1134 obstack_alloc (&objfile->psymbol_obstack,
1135 sizeof (struct partial_symtab *));
1136 subpst->dependencies[0] = pst;
1137 subpst->number_of_dependencies = 1;
1138
1139 subpst->globals_offset =
1140 subpst->n_global_syms =
1141 subpst->statics_offset =
1142 subpst->n_static_syms = 0;
1143
1144 subpst->readin = 0;
1145 subpst->symtab = 0;
1146 subpst->read_symtab = pst->read_symtab;
1147 }
1148
1149 sort_pst_symbols (pst);
1150
1151 /* If there is already a psymtab or symtab for a file of this name,
1152 remove it.
1153 (If there is a symtab, more drastic things also happen.)
1154 This happens in VxWorks. */
1155 free_named_symtabs (pst->filename);
1156
1157 if (num_includes == 0
1158 && number_dependencies == 0
1159 && pst->n_global_syms == 0
1160 && pst->n_static_syms == 0) {
1161 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1162 it is on the obstack, but we can forget to chain it on the list. */
1163 struct partial_symtab *prev_pst;
1164
1165 /* First, snip it out of the psymtab chain */
1166
1167 if (pst->objfile->psymtabs == pst)
1168 pst->objfile->psymtabs = pst->next;
1169 else
1170 for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
1171 if (prev_pst->next == pst)
1172 prev_pst->next = pst->next;
1173
1174 /* Next, put it on a free list for recycling */
1175 pst->next = pst->objfile->free_psymtabs;
1176 pst->objfile->free_psymtabs = pst;
1177
1178 /* Indicate that psymtab was thrown away. */
1179 pst = (struct partial_symtab *)NULL;
1180 }
1181 return pst;
1182}
1183\f
1184static void
1185os9k_psymtab_to_symtab_1 (pst)
1186 struct partial_symtab *pst;
1187{
1188 struct cleanup *old_chain;
1189 int i;
1190
1191 if (!pst)
1192 return;
1193
1194 if (pst->readin)
1195 {
1196 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1197 pst->filename);
1198 return;
1199 }
1200
1201 /* Read in all partial symtabs on which this one is dependent */
1202 for (i = 0; i < pst->number_of_dependencies; i++)
1203 if (!pst->dependencies[i]->readin)
1204 {
1205 /* Inform about additional files that need to be read in. */
1206 if (info_verbose)
1207 {
1208 fputs_filtered (" ", gdb_stdout);
1209 wrap_here ("");
1210 fputs_filtered ("and ", gdb_stdout);
1211 wrap_here ("");
1212 printf_filtered ("%s...", pst->dependencies[i]->filename);
1213 wrap_here (""); /* Flush output */
1214 gdb_flush (gdb_stdout);
1215 }
1216 os9k_psymtab_to_symtab_1 (pst->dependencies[i]);
1217 }
1218
1219 if (LDSYMCNT(pst)) /* Otherwise it's a dummy */
1220 {
1221 /* Init stuff necessary for reading in symbols */
1222 stabsread_init ();
1223 buildsym_init ();
1224 old_chain = make_cleanup (really_free_pendings, 0);
1225
1226 /* Read in this file's symbols */
1227 os9k_read_ofile_symtab (pst);
1228 sort_symtab_syms (pst->symtab);
1229 do_cleanups (old_chain);
1230 }
1231
1232 pst->readin = 1;
1233}
1234
1235/* Read in all of the symbols for a given psymtab for real.
1236 Be verbose about it if the user wants that. */
1237
1238static void
1239os9k_psymtab_to_symtab (pst)
1240 struct partial_symtab *pst;
1241{
1242 bfd *sym_bfd;
1243
1244 if (!pst)
1245 return;
1246
1247 if (pst->readin)
1248 {
1249 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1250 pst->filename);
1251 return;
1252 }
1253
1254 if (LDSYMCNT(pst) || pst->number_of_dependencies)
1255 {
1256 /* Print the message now, before reading the string table,
1257 to avoid disconcerting pauses. */
1258 if (info_verbose)
1259 {
1260 printf_filtered ("Reading in symbols for %s...", pst->filename);
1261 gdb_flush (gdb_stdout);
1262 }
1263
1264 sym_bfd = pst->objfile->obfd;
1265 os9k_psymtab_to_symtab_1 (pst);
1266
1267 /* Match with global symbols. This only needs to be done once,
1268 after all of the symtabs and dependencies have been read in. */
1269 scan_file_globals (pst->objfile);
1270
1271 /* Finish up the debug error message. */
1272 if (info_verbose)
1273 printf_filtered ("done.\n");
1274 }
1275}
1276
1277/* Read in a defined section of a specific object file's symbols. */
1278static void
1279os9k_read_ofile_symtab (pst)
1280 struct partial_symtab *pst;
1281{
1282 register struct internal_symstruct *bufp;
1283 unsigned char type;
1284 unsigned max_symnum;
1285 register bfd *abfd;
1286 struct objfile *objfile;
1287 int sym_offset; /* Offset to start of symbols to read */
1288 CORE_ADDR text_offset; /* Start of text segment for symbols */
1289 int text_size; /* Size of text segment for symbols */
1290 struct section_offsets *section_offsets;
1291 FILE *dbg_file;
1292
1293 objfile = pst->objfile;
1294 sym_offset = LDSYMOFF(pst);
1295 max_symnum = LDSYMCNT(pst);
1296 text_offset = pst->textlow;
1297 text_size = pst->texthigh - pst->textlow;
1298 section_offsets = pst->section_offsets;
1299
1300 current_objfile = objfile;
1301 subfile_stack = NULL;
1302 last_source_file = NULL;
1303
1304 abfd = objfile->obfd;
1305 dbg_file = objfile->auxf2;
1306
1307#if 0
1308 /* It is necessary to actually read one symbol *before* the start
1309 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1310 occurs before the N_SO symbol.
1311 Detecting this in read_dbx_symtab
1312 would slow down initial readin, so we look for it here instead. */
1313 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1314 {
1315 fseek (objefile->auxf2, sym_offset, SEEK_CUR);
1316 fill_sym(objfile->auxf2, abfd);
1317 bufp = symbuf;
1318
1319 processing_gcc_compilation = 0;
1320 if (bufp->n_type == N_TEXT)
1321 {
1322 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1323 processing_gcc_compilation = 1;
1324 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1325 processing_gcc_compilation = 2;
1326 }
1327
1328 /* Try to select a C++ demangling based on the compilation unit
1329 producer. */
1330
1331 if (processing_gcc_compilation)
1332 {
1333 if (AUTO_DEMANGLING)
1334 {
1335 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1336 }
1337 }
1338 }
1339 else
1340 {
1341 /* The N_SO starting this symtab is the first symbol, so we
1342 better not check the symbol before it. I'm not this can
1343 happen, but it doesn't hurt to check for it. */
1344 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
1345 processing_gcc_compilation = 0;
1346 }
25200748 1347#endif /* 0 */
1340861c
KH
1348
1349 fseek(dbg_file, (long)sym_offset, 0);
1350/*
1351 if (bufp->n_type != (unsigned char)N_SYM_SYM)
1352 error("First symbol in segment of executable not a source symbol");
1353*/
1354
1355 for (symnum = 0; symnum < max_symnum; symnum++)
1356 {
1357 QUIT; /* Allow this to be interruptable */
1358 fill_sym(dbg_file, abfd);
1359 bufp = symbuf;
1360 type = bufp->n_type;
1361
d5336fc5
KH
1362 os9k_process_one_symbol ((int)type, (int)bufp->n_desc,
1363 (CORE_ADDR)bufp->n_value, bufp->n_strx, section_offsets, objfile);
1340861c
KH
1364
1365 /* We skip checking for a new .o or -l file; that should never
1366 happen in this routine. */
1367#if 0
1368 else if (type == N_TEXT)
1369 {
1370 /* I don't think this code will ever be executed, because
1371 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1372 the N_SO symbol which starts this source file.
1373 However, there is no reason not to accept
1374 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1375
1376 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1377 processing_gcc_compilation = 1;
1378 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1379 processing_gcc_compilation = 2;
1380
1381 if (AUTO_DEMANGLING)
1382 {
1383 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1384 }
1385 }
1386 else if (type & N_EXT || type == (unsigned char)N_TEXT
1387 || type == (unsigned char)N_NBTEXT
1388 ) {
1389 /* Global symbol: see if we came across a dbx defintion for
1390 a corresponding symbol. If so, store the value. Remove
1391 syms from the chain when their values are stored, but
1392 search the whole chain, as there may be several syms from
1393 different files with the same name. */
1394 /* This is probably not true. Since the files will be read
1395 in one at a time, each reference to a global symbol will
1396 be satisfied in each file as it appears. So we skip this
1397 section. */
1398 ;
1399 }
25200748 1400#endif /* 0 */
1340861c
KH
1401 }
1402
1403 current_objfile = NULL;
1404
1405 /* In a Solaris elf file, this variable, which comes from the
1406 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1407 which comes from pst->textlow is correct. */
1408 if (last_source_start_addr == 0)
1409 last_source_start_addr = text_offset;
436d4143 1410 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT);
1340861c
KH
1411 end_stabs ();
1412}
1413
1414\f
1415/* This handles a single symbol from the symbol-file, building symbols
1416 into a GDB symtab. It takes these arguments and an implicit argument.
1417
1418 TYPE is the type field of the ".stab" symbol entry.
1419 DESC is the desc field of the ".stab" entry.
1420 VALU is the value field of the ".stab" entry.
1421 NAME is the symbol name, in our address space.
1422 SECTION_OFFSETS is a set of amounts by which the sections of this object
1423 file were relocated when it was loaded into memory.
1424 All symbols that refer
1425 to memory locations need to be offset by these amounts.
1426 OBJFILE is the object file from which we are reading symbols.
1427 It is used in end_symtab. */
1428
1429static void
1430os9k_process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1431 int type, desc;
1432 CORE_ADDR valu;
1433 char *name;
1434 struct section_offsets *section_offsets;
1435 struct objfile *objfile;
1436{
1437 register struct context_stack *new;
1438 /* The stab type used for the definition of the last function.
1439 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1440 static int function_stab_type = 0;
1441
1442#if 0
1443 /* Something is wrong if we see real data before
1444 seeing a source file name. */
1445 if (last_source_file == NULL && type != (unsigned char)N_SO)
1446 {
1447 /* Ignore any symbols which appear before an N_SO symbol. Currently
1448 no one puts symbols there, but we should deal gracefully with the
1449 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1450 but this should not be an error (). */
1451 return;
1452 }
25200748 1453#endif /* 0 */
1340861c
KH
1454
1455 switch (type)
1456 {
1457 case N_SYM_LBRAC:
1458 /* On most machines, the block addresses are relative to the
1459 N_SO, the linker did not relocate them (sigh). */
d9389f37 1460 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1340861c
KH
1461 new = push_context (desc, valu);
1462 break;
1463
1464 case N_SYM_RBRAC:
d9389f37 1465 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1340861c
KH
1466 new = pop_context();
1467
25200748
JK
1468#if !defined (OS9K_VARIABLES_INSIDE_BLOCK)
1469#define OS9K_VARIABLES_INSIDE_BLOCK(desc, gcc_p) 1
1340861c
KH
1470#endif
1471
25200748 1472 if (!OS9K_VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1340861c
KH
1473 local_symbols = new->locals;
1474
1475 if (context_stack_depth > 1)
1476 {
1477 /* This is not the outermost LBRAC...RBRAC pair in the function,
1478 its local symbols preceded it, and are the ones just recovered
1479 from the context stack. Define the block for them (but don't
1480 bother if the block contains no symbols. Should we complain
1481 on blocks without symbols? I can't think of any useful purpose
1482 for them). */
1483 if (local_symbols != NULL)
1484 {
1485 /* Muzzle a compiler bug that makes end < start. (which
1486 compilers? Is this ever harmful?). */
1487 if (new->start_addr > valu)
1488 {
1489 complain (&lbrac_rbrac_complaint);
1490 new->start_addr = valu;
1491 }
1492 /* Make a block for the local symbols within. */
1493 finish_block (0, &local_symbols, new->old_blocks,
1494 new->start_addr, valu, objfile);
1495 }
1496 }
1497 else
1498 {
1499 if (context_stack_depth == 0)
1500 {
1501 within_function = 0;
1502 /* Make a block for the local symbols within. */
1503 finish_block (new->name, &local_symbols, new->old_blocks,
1504 new->start_addr, valu, objfile);
1505 }
1506 else
1507 {
1508 /* attach local_symbols to the end of new->locals */
1509 if (!new->locals) new->locals = local_symbols;
1510 else {
1511 struct pending *p;
1512
1513 p = new->locals;
1514 while (p->next) p = p->next;
1515 p->next = local_symbols;
1516 }
1517 }
1518 }
1519
25200748 1520 if (OS9K_VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1340861c
KH
1521 /* Now pop locals of block just finished. */
1522 local_symbols = new->locals;
1523 break;
1524
1525
1526 case N_SYM_SLINE:
1527 /* This type of "symbol" really just records
1528 one line-number -- core-address correspondence.
4cfb23a9 1529 Enter it in the line list for this symbol table. */
1340861c 1530 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
d9389f37 1531 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
4cfb23a9 1532 /* FIXME: loses if sizeof (char *) > sizeof (int) */
1340861c
KH
1533 record_line (current_subfile, (int)name, valu);
1534 break;
1535
1536 /* The following symbol types need to have the appropriate offset added
1537 to their value; then we process symbol definitions in the name. */
1538 case N_SYM_SYM:
1539
1540 if (name)
1541 {
1542 char deftype;
1543 char *dirn, *n;
1544 char *p = strchr (name, ':');
1545 if (p == NULL)
1546 deftype = '\0';
1547 else
1548 deftype = p[1];
1549
1550
1551 switch (deftype)
1552 {
1553 case 'S':
1554 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1555 n = strrchr(name, '/');
1556 if (n != NULL) {
1557 *n = '\0';
1558 n++;
1559 dirn = name;
1560 } else {
1561 n = name;
1562 dirn = NULL;
1563 }
1564 *p = '\0';
1565 if (symfile_depth++ == 0) {
1566 if (last_source_file) {
436d4143 1567 end_symtab (valu, objfile, SECT_OFF_TEXT);
1340861c
KH
1568 end_stabs ();
1569 }
1570 start_stabs ();
25200748 1571 os9k_stabs = 1;
1340861c
KH
1572 start_symtab (n, dirn, valu);
1573 } else {
1574 push_subfile();
1575 start_subfile (n, dirn!=NULL ? dirn : current_subfile->dirname);
1576 }
1577 break;
1578
1579 case 'f':
1580 case 'F':
1581 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1582 function_stab_type = type;
1583
1584 within_function = 1;
1585 new = push_context (0, valu);
25200748 1586 new->name = define_symbol (valu, name, desc, type, objfile);
1340861c
KH
1587 break;
1588
1589 case 'V':
1590 case 'v':
1591 valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
25200748 1592 define_symbol (valu, name, desc, type, objfile);
1340861c
KH
1593 break;
1594
1595 default:
25200748 1596 define_symbol (valu, name, desc, type, objfile);
1340861c
KH
1597 break;
1598 }
1599 }
1600 break;
1601
1602 case N_SYM_SE:
1603 if (--symfile_depth != 0)
1604 start_subfile(pop_subfile(), current_subfile->dirname);
1605 break;
1606
1607 default:
1608 complain (&unknown_symtype_complaint,
1609 local_hex_string((unsigned long) type));
1610 /* FALLTHROUGH */
1611 break;
1612
1613 case N_SYM_CMPLR:
1614 break;
1615 }
1616 previous_stab_code = type;
1617}
1340861c 1618
1340861c
KH
1619static struct sym_fns os9k_sym_fns =
1620{
1621 bfd_target_os9k_flavour,
1622 os9k_new_init, /* sym_new_init: init anything gbl to entire symtab */
1623 os9k_symfile_init, /* sym_init: read initial info, setup for sym_read() */
1624 os9k_symfile_read, /* sym_read: read a symbol file into symtab */
1625 os9k_symfile_finish, /* sym_finish: finished with file, cleanup */
e74acce4
MA
1626 default_symfile_offsets,
1627 /* sym_offsets: parse user's offsets to internal form*/
1340861c
KH
1628 NULL /* next: pointer to next struct sym_fns */
1629};
1630
1631void
1632_initialize_os9kread ()
1633{
1634 add_symtab_fns(&os9k_sym_fns);
1635}
This page took 0.208537 seconds and 4 git commands to generate.