1 /* Read a symbol table in MIPS' format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major
4 work by Per Bothner and John Gilmore at Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This module provides three functions: mipscoff_symfile_init,
23 which initializes to read a symbol file; mipscoff_new_init, which
24 discards existing cached information when all symbols are being
25 discarded; and mipscoff_symfile_read, which reads a symbol table
28 mipscoff_symfile_read only does the minimum work necessary for letting the
29 user "name" things symbolically; it does not read the entire symtab.
30 Instead, it reads the external and static symbols and puts them in partial
31 symbol tables. When more extensive information is requested of a
32 file, the corresponding partial symbol table is mutated into a full
33 fledged symbol table by going back and reading the symbols
34 for real. mipscoff_psymtab_to_symtab() is called indirectly through
35 a pointer in the psymtab to do this.
37 ECOFF symbol tables are mostly written in the byte order of the
38 target machine. However, one section of the table (the auxiliary
39 symbol information) is written in the host byte order. There is a
40 bit in the other symbol info which describes which host byte order
41 was used. ECOFF thereby takes the trophy from Intel `b.out' for
42 the most brain-dead adaptation of a file format to byte order.
44 This module can read all four of the known byte-order combinations,
45 on any type of host. However, it does make (and check) the assumption
46 that the external form of a symbol table structure (on disk)
47 occupies the same number of bytes as the internal form (in a struct).
48 Fixing this is possible but requires larger structural changes. */
50 #define TM_FILE_OVERRIDE
60 #include <sys/param.h>
64 #include "coff/mips.h"
65 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
68 #include "coff/ecoff-ext.h"
71 struct external_filehdr f
;
72 struct external_aouthdr a
;
75 /* These must match the corresponding definition in gcc/config/xm-mips.h.
76 At some point, these should probably go into a shared include file,
77 but currently gcc and gdb do not share any directories. */
79 #define CODE_MASK 0x8F300
80 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
81 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
82 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
83 #define STABS_SYMBOL "@stabs"
85 /* Each partial symbol table entry contains a pointer to private data for the
86 read_symtab() function to use when expanding a partial symbol table entry
87 to a full symbol table entry.
89 For mipsread this structure contains the index of the FDR that this psymtab
90 represents and a pointer to the symbol table header HDRR from the symbol
91 file that the psymtab was created from. */
93 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
94 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
95 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
100 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
101 int extern_count
; /* Size of extern_tab. */
104 /* Things we import explicitly from other modules */
106 extern int info_verbose
;
107 extern struct block
*block_for_pc();
108 extern void sort_symtab_syms();
110 /* Various complaints about symbol reading that don't abort the process */
112 struct complaint bad_file_number_complaint
=
113 {"bad file number %d", 0, 0};
115 struct complaint unknown_ext_complaint
=
116 {"unknown external symbol %s", 0, 0};
118 struct complaint unknown_sym_complaint
=
119 {"unknown local symbol %s", 0, 0};
121 struct complaint unknown_st_complaint
=
122 {"with type %d", 0, 0};
124 struct complaint block_overflow_complaint
=
125 {"block containing %s overfilled", 0, 0};
127 struct complaint basic_type_complaint
=
128 {"cannot map MIPS basic type 0x%x", 0, 0};
130 struct complaint unknown_type_qual_complaint
=
131 {"unknown type qualifier 0x%x", 0, 0};
133 struct complaint array_bitsize_complaint
=
134 {"size of array target type not known, assuming %d bits", 0, 0};
136 struct complaint bad_tag_guess_complaint
=
137 {"guessed tag type incorrectly", 0, 0};
139 /* Macros and extra defs */
141 /* Already-parsed symbols are marked specially */
143 #define stParsed stType
145 /* Puns: hard to find whether -g was used and how */
147 #define MIN_GLEVEL GLEVEL_0
148 #define compare_glevel(a,b) \
149 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
150 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
152 /* When looking at .o files, avoid tripping over bad addresses */
154 #define SAFE_TEXT_ADDR 0x400000
155 #define SAFE_DATA_ADDR 0x10000000
157 #define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR)
159 /* Things that really are local to this module */
161 /* GDB symtable for the current compilation unit */
163 static struct symtab
*cur_stab
;
165 /* MIPS symtab header for the current file */
167 static HDRR
*cur_hdr
;
169 /* Pointer to current file decriptor record, and its index */
174 /* Index of current symbol */
178 /* Note how much "debuggable" this image is. We would like
179 to see at least one FDR with full symbols */
184 /* When examining .o files, report on undefined symbols */
186 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
188 /* Pseudo symbol to use when putting stabs into the symbol table. */
190 static char stabs_symbol
[] = STABS_SYMBOL
;
192 /* Extra builtin types */
194 struct type
*builtin_type_complex
;
195 struct type
*builtin_type_double_complex
;
196 struct type
*builtin_type_fixed_dec
;
197 struct type
*builtin_type_float_dec
;
198 struct type
*builtin_type_string
;
200 /* Forward declarations */
203 fixup_symtab
PARAMS ((HDRR
*, char *, int, bfd
*));
206 read_mips_symtab
PARAMS ((struct objfile
*, int));
209 read_the_mips_symtab
PARAMS ((bfd
*, int, CORE_ADDR
));
212 upgrade_type
PARAMS ((struct type
**, int, union aux_ent
*, int));
215 parse_partial_symbols
PARAMS ((int, struct objfile
*));
218 cross_ref
PARAMS ((union aux_ext
*, struct type
**, int, char **, int));
221 fixup_sigtramp
PARAMS ((void));
223 static struct symbol
*
224 new_symbol
PARAMS ((char *));
227 new_type
PARAMS ((char *));
229 static struct block
*
230 new_block
PARAMS ((int));
232 static struct symtab
*
233 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
235 static struct linetable
*
236 new_linetable
PARAMS ((int));
238 static struct blockvector
*
239 new_bvect
PARAMS ((int));
242 parse_type
PARAMS ((union aux_ext
*, int *, int));
244 static struct symbol
*
245 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
246 enum address_class
));
248 static struct block
*
249 shrink_block
PARAMS ((struct block
*, struct symtab
*));
252 xzalloc
PARAMS ((unsigned int));
255 sort_blocks
PARAMS ((struct symtab
*));
258 compare_blocks
PARAMS ((struct block
**, struct block
**));
260 static struct partial_symtab
*
261 new_psymtab
PARAMS ((char *, struct objfile
*));
264 static struct partial_symtab
*
265 parse_fdr
PARAMS ((int, int, struct objfile
*));
269 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
272 add_block
PARAMS ((struct block
*, struct symtab
*));
275 add_symbol
PARAMS ((struct symbol
*, struct block
*));
278 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
280 static struct linetable
*
281 shrink_linetable
PARAMS ((struct linetable
*));
284 mips_next_symbol_text
PARAMS ((void));
286 /* Things we export to other modules */
288 /* Address bounds for the signal trampoline in inferior, if any */
289 /* FIXME: Nothing really seems to use this. Why is it here? */
291 CORE_ADDR sigtramp_address
, sigtramp_end
;
294 mipscoff_new_init (ignore
)
295 struct objfile
*ignore
;
300 mipscoff_symfile_init (objfile
)
301 struct objfile
*objfile
;
303 if (objfile
-> sym_private
!= NULL
)
305 mfree (objfile
-> md
, objfile
-> sym_private
);
307 objfile
-> sym_private
= NULL
;
311 mipscoff_symfile_read (objfile
, addr
, mainline
)
312 struct objfile
*objfile
;
316 bfd
*abfd
= objfile
-> obfd
;
319 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
320 desc
= fileno ((FILE *)(abfd
->iostream
)); /* Raw file descriptor */
323 init_minimal_symbol_collection ();
324 make_cleanup (discard_minimal_symbols
, 0);
326 /* Now that the executable file is positioned at symbol table,
327 process it and define symbols accordingly. */
329 read_mips_symtab(objfile
, desc
);
331 /* Install any minimal symbols that have been collected as the current
332 minimal symbols for this objfile. */
334 install_minimal_symbols (objfile
);
337 /* Perform any local cleanups required when we are done with a particular
338 objfile. I.E, we are in the process of discarding all symbol information
339 for an objfile, freeing up all memory held for it, and unlinking the
340 objfile struct from the global list of known objfiles. */
343 mipscoff_symfile_finish (objfile
)
344 struct objfile
*objfile
;
346 if (objfile
-> sym_private
!= NULL
)
348 mfree (objfile
-> md
, objfile
-> sym_private
);
351 /* If we have a file symbol header lying around, blow it away. */
360 /* Allocate zeroed memory */
366 PTR p
= xmalloc(size
);
372 /* Exported procedure: Builds a symtab from the PST partial one.
373 Restores the environment in effect when PST was created, delegates
374 most of the work to an ancillary procedure, and sorts
375 and reorders the symtab list at the end */
378 mipscoff_psymtab_to_symtab(pst
)
379 struct partial_symtab
*pst
;
386 printf_filtered("Reading in symbols for %s...", pst
->filename
);
389 /* Restore the header and list of pending typedefs */
390 cur_hdr
= CUR_HDR(pst
);
392 next_symbol_text_func
= mips_next_symbol_text
;
394 psymtab_to_symtab_1(pst
, pst
->filename
);
396 /* Match with global symbols. This only needs to be done once,
397 after all of the symtabs and dependencies have been read in. */
398 scan_file_globals (pst
->objfile
);
401 printf_filtered("done.\n");
404 /* Exported procedure: Is PC in the signal trampoline code */
407 in_sigtramp(pc
, ignore
)
409 char *ignore
; /* function name */
411 if (sigtramp_address
== 0)
413 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
416 /* File-level interface functions */
418 /* Read the symtab information from file FSYM into memory. Also,
419 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
422 read_the_mips_symtab(abfd
, fsym
, end_of_text_segp
)
425 CORE_ADDR
*end_of_text_segp
;
427 int stsize
, st_hdrsize
;
429 struct hdr_ext hdr_ext
;
431 /* Header for executable/object file we read symbols from */
432 struct coff_exec filhdr
;
434 /* We need some info from the initial headers */
436 myread(fsym
, (char *)&filhdr
, sizeof filhdr
);
438 if (end_of_text_segp
)
440 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
441 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
443 /* Find and read the symbol table header */
444 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
445 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
449 lseek(fsym
, st_filptr
, L_SET
);
450 if (st_hdrsize
!= sizeof (hdr_ext
)) { /* Profanity check */
451 error ("Wrong header size: %d, not %d", st_hdrsize
,
454 if (read(fsym
, &hdr_ext
, st_hdrsize
) != st_hdrsize
)
456 ecoff_swap_hdr_in (abfd
, &hdr_ext
, &st_hdr
);
458 /* Find out how large the symbol table is */
459 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
460 + st_hdr
.iextMax
* cbEXTR
;
462 /* Allocate space for the symbol table. Read it in. */
463 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
465 memcpy((PTR
)cur_hdr
, (PTR
)&hdr_ext
, st_hdrsize
);
466 if (read(fsym
, (char *) cur_hdr
+ st_hdrsize
, stsize
) != stsize
)
469 /* Fixup file_pointers in it */
470 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
471 st_filptr
+ st_hdrsize
, abfd
);
475 error("Short read on %s", bfd_get_filename (abfd
));
479 /* Turn all file-relative pointers in the symtab described by HDR
480 into memory pointers, given that the symtab itself is located
481 at DATA in memory and F_PTR in the file.
483 Byte-swap all the data structures, in place, while we are at it --
484 except AUX entries, which we leave in their original byte order.
485 They will be swapped as they are used instead. (FIXME: we ought to
486 do all the data structures that way.) */
489 fixup_symtab (hdr
, data
, f_ptr
, abfd
)
500 struct rfd_ext
*rbase
;
502 /* This function depends on the external and internal forms
503 of the MIPS symbol table taking identical space. Check this
504 assumption at compile-time. */
505 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
506 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
507 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
508 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
509 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
510 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
511 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
512 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
513 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
514 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
515 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
516 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
518 /* Swap in the header record. */
519 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
522 * These fields are useless (and empty) by now:
523 * hdr->cbDnOffset, hdr->cbOptOffset
524 * We use them for other internal purposes.
527 hdr
->cbOptOffset
= 0;
530 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
544 /* Fix all the RFD's. */
545 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
546 for (i
= 0; i
< hdr
->crfd
; i
++) {
547 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
550 /* Fix all string pointers inside the symtab, and
551 the FDR records. Also fix other miscellany. */
553 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
554 register unsigned code_offset
;
556 /* Header itself, and strings */
557 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
559 /* Swap in the FDR */
560 ecoff_swap_fdr_in (abfd
, fh
, fh
);
562 fh
->issBase
+= hdr
->cbSsOffset
;
564 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
567 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
569 /* FIXME! Probably don't want to do this here! */
570 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
571 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
572 ecoff_swap_sym_in (abfd
, sh
, sh
);
574 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
580 /* cannot fix fh->ipdFirst because it is a short */
581 #define IPDFIRST(h,fh) \
582 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
584 /* Optional symbols (actually used for partial_symtabs) */
590 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
591 /* Relative file descriptor table */
592 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
596 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
598 /* Procedure symbols. (XXX This should be done later) */
599 code_offset
= fh
->adr
;
600 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
601 unsigned name
, only_ext
;
603 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
604 ecoff_swap_pdr_in (abfd
, pr
, pr
);
606 /* Simple rule to find files linked "-x" */
607 only_ext
= fh
->rss
== -1;
609 if (pr
->isym
== -1) {
610 /* static function */
614 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
615 sh
= &((EXTR
*)name
)->asym
;
619 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
620 /* Included code ? */
621 if (s_idx
== 0 && pr
->adr
!= 0)
622 code_offset
-= pr
->adr
;
625 /* Turn index into a pointer */
628 /* Fix line numbers */
629 pr
->cbLineOffset
+= fh
->cbLineOffset
;
631 /* Relocate address */
633 pr
->adr
+= code_offset
;
637 /* External symbols: swap in, and fix string */
638 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
639 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
640 ecoff_swap_ext_in (abfd
, esh
, esh
);
641 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
646 /* Find a file descriptor given its index RF relative to a file CF */
654 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
655 /* Object files do not have the RFD table, all refs are absolute */
657 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
658 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
659 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
662 /* Return a safer print NAME for a file descriptor */
668 if (name
== (char *) -1)
669 return "<stripped file>";
670 if (UNSAFE_DATA_ADDR(name
))
676 /* Read in and parse the symtab of the file DESC. INCREMENTAL says
677 whether we are adding to the general symtab or not.
678 FIXME: INCREMENTAL is currently always zero, though it should not be. */
681 read_mips_symtab (objfile
, desc
)
682 struct objfile
*objfile
;
685 CORE_ADDR end_of_text_seg
;
687 read_the_mips_symtab(objfile
->obfd
, desc
, &end_of_text_seg
);
689 parse_partial_symbols(end_of_text_seg
, objfile
);
693 * Check to make sure file was compiled with -g.
694 * If not, warn the user of this limitation.
696 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
697 if (max_gdbinfo
== 0)
699 "\n%s not compiled with -g, debugging support is limited.\n",
702 "You should compile with -g2 or -g3 for best debugging support.\n");
708 /* Local utilities */
710 /* Map of FDR indexes to partial symtabs */
713 struct partial_symtab
*pst
; /* the psymtab proper */
714 int n_globals
; /* exported globals (external symbols) */
715 int globals_offset
; /* cumulative */
719 /* Utility stack, used to nest procedures and blocks properly.
720 It is a doubly linked list, to avoid too many alloc/free.
721 Since we might need it quite a few times it is NOT deallocated
724 static struct parse_stack
{
725 struct parse_stack
*next
, *prev
;
726 struct symtab
*cur_st
; /* Current symtab. */
727 struct block
*cur_block
; /* Block in it. */
728 int blocktype
; /* What are we parsing. */
729 int maxsyms
; /* Max symbols in this block. */
730 struct type
*cur_type
; /* Type we parse fields for. */
731 int cur_field
; /* Field number in cur_type. */
732 int procadr
; /* Start addres of this procedure */
733 int numargs
; /* Its argument count */
734 } *top_stack
; /* Top stack ptr */
737 /* Enter a new lexical context */
739 static push_parse_stack()
741 struct parse_stack
*new;
743 /* Reuse frames if possible */
744 if (top_stack
&& top_stack
->prev
)
745 new = top_stack
->prev
;
747 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
748 /* Initialize new frame with previous content */
750 register struct parse_stack
*prev
= new->prev
;
753 top_stack
->prev
= new;
755 new->next
= top_stack
;
760 /* Exit a lexical context */
762 static pop_parse_stack()
767 top_stack
= top_stack
->next
;
771 /* Cross-references might be to things we haven't looked at
772 yet, e.g. type references. To avoid too many type
773 duplications we keep a quick fixup table, an array
774 of lists of references indexed by file descriptor */
776 static struct mips_pending
{
777 struct mips_pending
*next
; /* link */
778 SYMR
*s
; /* the symbol */
779 struct type
*t
; /* its partial type descriptor */
783 /* Check whether we already saw symbol SH in file FH as undefined */
786 struct mips_pending
*is_pending_symbol(fh
, sh
)
790 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
791 register struct mips_pending
*p
;
793 /* Linear search is ok, list is typically no more than 10 deep */
794 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
800 /* Add a new undef symbol SH of type T */
803 add_pending(fh
, sh
, t
)
808 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
809 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
811 /* Make sure we do not make duplicates */
813 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
816 p
->next
= pending_list
[f_idx
];
817 pending_list
[f_idx
] = p
;
819 sh
->reserved
= 1; /* for quick check */
822 /* Throw away undef entries when done with file index F_IDX */
823 /* FIXME -- storage leak. This is never called!!! --gnu */
828 register struct mips_pending
*p
, *q
;
830 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
834 pending_list
[f_idx
] = 0;
838 prepend_tag_kind(tag_name
, type_code
)
848 case TYPE_CODE_STRUCT
:
851 case TYPE_CODE_UNION
:
858 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
859 strlen(prefix
) + strlen(tag_name
) + 1);
860 sprintf(result
, "%s%s", prefix
, tag_name
);
865 /* Parsing Routines proper. */
867 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
868 For blocks, procedures and types we open a new lexical context.
869 This is basically just a big switch on the symbol's type.
870 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
871 BIGEND says whether aux symbols are big-endian or little-endian.
872 Return count of SYMR's handled (normally one). */
875 parse_symbol(sh
, ax
, bigend
)
886 /* When a symbol is cross-referenced from other files/symbols
887 we mark it explicitly */
888 int pend
= (sh
->reserved
== 1);
889 enum address_class
class;
897 case stGlobal
: /* external symbol, goes into global block */
899 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
901 s
= new_symbol(sh
->iss
);
902 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
905 case stStatic
: /* static data, goes into current block. */
907 b
= top_stack
->cur_block
;
908 s
= new_symbol(sh
->iss
);
909 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
912 case stLocal
: /* local variable, goes into current block */
913 if (sh
->sc
== scRegister
) {
914 class = LOC_REGISTER
;
916 sh
->value
+= FP0_REGNUM
-32;
919 b
= top_stack
->cur_block
;
920 s
= new_symbol(sh
->iss
);
921 SYMBOL_VALUE(s
) = sh
->value
;
923 data
: /* Common code for symbols describing data */
924 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
925 SYMBOL_CLASS(s
) = class;
928 /* Type could be missing in a number of cases */
929 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
930 sh
->index
== 0xfffff)
931 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
933 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
934 /* Value of a data symbol is its memory address */
937 case stParam
: /* arg to procedure, goes into current block */
939 top_stack
->numargs
++;
941 name
= (char*)sh
->iss
;
942 /* Special GNU C++ name. */
943 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
945 s
= new_symbol(name
);
947 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
948 if (sh
->sc
== scRegister
) {
949 SYMBOL_CLASS(s
) = LOC_REGPARM
;
951 sh
->value
+= FP0_REGNUM
-32;
953 SYMBOL_CLASS(s
) = LOC_ARG
;
954 SYMBOL_VALUE(s
) = sh
->value
;
955 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
956 add_symbol(s
, top_stack
->cur_block
);
958 /* FIXME: This has not been tested. See dbxread.c */
959 /* Add the type of this parameter to the function/procedure
960 type of this block. */
961 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
965 case stLabel
: /* label, goes into current block */
966 s
= new_symbol(sh
->iss
);
967 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
968 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
969 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
970 SYMBOL_TYPE(s
) = builtin_type_int
;
971 add_symbol(s
, top_stack
->cur_block
);
974 case stProc
: /* Procedure, usually goes into global block */
975 case stStaticProc
: /* Static procedure, goes into current block */
976 s
= new_symbol(sh
->iss
);
977 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
978 SYMBOL_CLASS(s
) = LOC_BLOCK
;
979 /* Type of the return value */
980 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
981 t
= builtin_type_int
;
983 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
984 b
= top_stack
->cur_block
;
985 if (sh
->st
== stProc
) {
986 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
987 /* The next test should normally be true,
988 but provides a hook for nested functions
989 (which we don't want to make global). */
990 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
991 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
995 /* Make a type for the procedure itself */
997 /* FIXME: This has not been tested yet! See dbxread.c */
998 /* Generate a template for the type of this function. The
999 types of the arguments will be added as we read the symbol
1001 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1003 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1006 /* Create and enter a new lexical context */
1007 b
= new_block(top_stack
->maxsyms
);
1008 SYMBOL_BLOCK_VALUE(s
) = b
;
1009 BLOCK_FUNCTION(b
) = s
;
1010 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1011 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1012 add_block(b
, top_stack
->cur_st
);
1014 /* Not if we only have partial info */
1015 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1019 top_stack
->cur_block
= b
;
1020 top_stack
->blocktype
= sh
->st
;
1021 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1022 top_stack
->cur_field
= -1;
1023 top_stack
->procadr
= sh
->value
;
1024 top_stack
->numargs
= 0;
1026 sh
->value
= (long) SYMBOL_TYPE(s
);
1030 #ifndef btVoid /* btVoid was added late. */
1033 /* These new symbol types have been recently added to SGI machines. */
1047 case stBlock
: /* Either a lexical block, or some type */
1049 top_stack
->blocktype
= stBlock
;
1050 if (sh
->sc
== scInfo
) { /* structure/union/enum def */
1052 sh
->st
== stStruct
? TYPE_CODE_STRUCT
1053 : sh
->st
== stUnion
? TYPE_CODE_UNION
1054 : sh
->st
== stEnum
? TYPE_CODE_ENUM
1061 s
= new_symbol(sh
->iss
);
1062 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1063 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1064 SYMBOL_VALUE(s
) = 0;
1065 add_symbol(s
, top_stack
->cur_block
);
1067 /* First count the number of fields. */
1068 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1069 if (tsym
->st
== stMember
) {
1070 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1071 /* If the type of the member is Nil (or Void)
1072 assume the tag is an enumeration. */
1073 if (tsym
->index
== indexNil
)
1074 type_code
= TYPE_CODE_ENUM
;
1076 ecoff_swap_tir_in (bigend
,
1077 &ax
[tsym
->index
].a_ti
,
1079 if (tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1080 type_code
= TYPE_CODE_ENUM
;
1083 if (tsym
->value
> max_value
)
1084 max_value
= tsym
->value
;
1086 else if (tsym
->st
== stBlock
1087 || tsym
->st
== stUnion
1088 || tsym
->st
== stEnum
1089 || tsym
->st
== stStruct
1090 || tsym
->st
== stParsed
) {
1091 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1092 if (tsym
->index
!= 0)
1093 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1097 /* There is no guaranteed way to distinguish struct,
1098 unions, and enums at this point. This is a bug in the
1099 original design (that has been fixed with the
1100 recent addition of the stStruct, stUnion, and stEnum
1101 symbol types.) The way you can tell is if/when you
1102 see a variable or field of that type: In that case
1103 the variable's type (in the AUX table) says if the
1104 type is struct, union, or enum,
1105 and points back to the stBlock here.
1106 So you can patch the tag kind up later - but only
1107 if there actually is a variable or field of that type.
1109 So until we know for sure, we will guess at this point.
1111 If the first member has index==indexNil or a void type,
1112 assume we have an enumeration.
1113 Otherwise, if there is more than one member, and all
1114 the members have offset 0, assume we have a union.
1115 Otherwise, assume we have a struct.
1117 The heuristic could guess wrong in the case of
1118 of an enumeration with no members or a union
1119 with one (or zero) members, or when all except the
1120 last field of a struct have width zero.
1121 These are uncommon and/or illegal situations, and
1122 in any case guessing wrong probably doesn't matter much.
1124 But if we later do find out we were wrong,
1125 we fixup the tag kind. Members of an enumeration
1126 must be handled differently from struct/union fields,
1127 and that is harder to patch up, but luckily we
1128 shouldn't need to. (If there are any enumeration
1129 members, we can tell for sure it's an enum here.) */
1131 if (type_code
== TYPE_CODE_UNDEF
)
1132 if (nfields
> 1 && max_value
== 0)
1133 type_code
= TYPE_CODE_UNION
;
1135 type_code
= TYPE_CODE_STRUCT
;
1137 /* If this type was expected, use its partial definition */
1139 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1141 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1144 TYPE_CODE(t
) = type_code
;
1145 TYPE_LENGTH(t
) = sh
->value
;
1146 TYPE_NFIELDS(t
) = nfields
;
1147 TYPE_FIELDS(t
) = f
= (struct field
*)
1148 obstack_alloc (¤t_objfile
-> type_obstack
,
1149 nfields
* sizeof (struct field
));
1151 if (type_code
== TYPE_CODE_ENUM
) {
1152 /* This is a non-empty enum. */
1153 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1154 struct symbol
*enum_sym
;
1155 f
->bitpos
= tsym
->value
;
1157 f
->name
= (char*)tsym
->iss
;
1160 enum_sym
= (struct symbol
*)
1161 obstack_alloc (¤t_objfile
->symbol_obstack
,
1162 sizeof (struct symbol
));
1163 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1164 SYMBOL_NAME (enum_sym
) = f
->name
;
1165 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1166 SYMBOL_TYPE (enum_sym
) = t
;
1167 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1168 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1169 add_symbol(enum_sym
, top_stack
->cur_block
);
1171 /* Skip the stMembers that we've handled. */
1177 /* make this the current type */
1178 top_stack
->cur_type
= t
;
1179 top_stack
->cur_field
= 0;
1180 /* Mark that symbol has a type, and say which one */
1181 sh
->value
= (long) t
;
1183 /* beginnning of (code) block. Value of symbol
1184 is the displacement from procedure start */
1185 b
= new_block(top_stack
->maxsyms
);
1186 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1187 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1188 top_stack
->cur_block
= b
;
1189 add_block(b
, top_stack
->cur_st
);
1193 case stEnd
: /* end (of anything) */
1194 if (sh
->sc
== scInfo
) {
1195 /* Finished with type */
1196 top_stack
->cur_type
= 0;
1197 } else if (sh
->sc
== scText
&&
1198 (top_stack
->blocktype
== stProc
||
1199 top_stack
->blocktype
== stStaticProc
)) {
1200 /* Finished with procedure */
1201 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1202 struct mips_extra_func_info
*e
;
1206 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1208 /* Make up special symbol to contain procedure specific
1210 s
= new_symbol(".gdbinfo.");
1211 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1212 SYMBOL_CLASS(s
) = LOC_CONST
;
1213 SYMBOL_TYPE(s
) = builtin_type_void
;
1214 e
= (struct mips_extra_func_info
*)
1215 obstack_alloc (¤t_objfile
->symbol_obstack
,
1216 sizeof (struct mips_extra_func_info
));
1217 SYMBOL_VALUE(s
) = (int)e
;
1218 e
->numargs
= top_stack
->numargs
;
1219 add_symbol(s
, top_stack
->cur_block
);
1221 /* Reallocate symbols, saving memory */
1222 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1224 /* f77 emits proc-level with address bounds==[0,0],
1225 So look for such child blocks, and patch them. */
1226 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1227 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1228 if (BLOCK_SUPERBLOCK(b_bad
) == b
1229 && BLOCK_START(b_bad
) == top_stack
->procadr
1230 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1231 BLOCK_START(b_bad
) = BLOCK_START(b
);
1232 BLOCK_END(b_bad
) = BLOCK_END(b
);
1235 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1236 /* End of (code) block. The value of the symbol
1237 is the displacement from the procedure`s start
1238 address of the end of this block. */
1239 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1240 (void) shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1242 pop_parse_stack(); /* restore previous lexical context */
1245 case stMember
: /* member of struct or union */
1246 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1247 f
->name
= (char*)sh
->iss
;
1248 f
->bitpos
= sh
->value
;
1250 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1253 case stTypedef
: /* type definition */
1254 s
= new_symbol(sh
->iss
);
1255 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1256 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1257 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1258 add_symbol(s
, top_stack
->cur_block
);
1259 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1260 sh
->value
= (long) SYMBOL_TYPE(s
);
1263 case stFile
: /* file name */
1265 top_stack
->blocktype
= sh
->st
;
1268 /* I`ve never seen these for C */
1270 break; /* register relocation */
1272 break; /* forwarding address */
1274 break; /* constant */
1276 error("Unknown symbol type %x.", sh
->st
);
1282 /* Parse the type information provided in the raw AX entries for
1283 the symbol SH. Return the bitfield size in BS, in case.
1284 We must byte-swap the AX entries before we use them; BIGEND says whether
1285 they are big-endian or little-endian (from fh->fBigendian). */
1287 static struct type
*
1288 parse_type(ax
, bs
, bigend
)
1293 /* Null entries in this map are treated specially */
1294 static struct type
**map_bt
[] =
1296 &builtin_type_void
, /* btNil */
1298 &builtin_type_char
, /* btChar */
1299 &builtin_type_unsigned_char
, /* btUChar */
1300 &builtin_type_short
, /* btShort */
1301 &builtin_type_unsigned_short
, /* btUShort */
1302 &builtin_type_int
, /* btInt */
1303 &builtin_type_unsigned_int
, /* btUInt */
1304 &builtin_type_long
, /* btLong */
1305 &builtin_type_unsigned_long
, /* btULong */
1306 &builtin_type_float
, /* btFloat */
1307 &builtin_type_double
, /* btDouble */
1314 &builtin_type_complex
, /* btComplex */
1315 &builtin_type_double_complex
, /* btDComplex */
1317 &builtin_type_fixed_dec
, /* btFixedDec */
1318 &builtin_type_float_dec
, /* btFloatDec */
1319 &builtin_type_string
, /* btString */
1322 &builtin_type_void
, /* btVoid */
1326 struct type
*tp
= 0;
1331 /* Use aux as a type information record, map its basic type. */
1333 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1334 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1335 complain (&basic_type_complaint
, t
->bt
);
1336 return builtin_type_int
;
1338 if (map_bt
[t
->bt
]) {
1339 tp
= *map_bt
[t
->bt
];
1343 /* Cannot use builtin types -- build our own */
1346 tp
= lookup_pointer_type (builtin_type_void
);
1350 type_code
= TYPE_CODE_STRUCT
;
1354 type_code
= TYPE_CODE_UNION
;
1358 type_code
= TYPE_CODE_ENUM
;
1362 type_code
= TYPE_CODE_RANGE
;
1366 type_code
= TYPE_CODE_SET
;
1371 complain (&basic_type_complaint
, t
->bt
);
1372 return builtin_type_int
;
1376 /* Skip over any further type qualifiers (FIXME). */
1378 /* This is the way it would work if the compiler worked */
1382 ecoff_swap_tir_in (bigend
, ax
, t1
);
1383 } while (t1
->continued
);
1386 /* Move on to next aux */
1390 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1394 /* All these types really point to some (common) MIPS type
1395 definition, and only the type-qualifiers fully identify
1396 them. We'll make the same effort at sharing. */
1397 if (t
->bt
== btIndirect
||
1398 t
->bt
== btStruct
||
1401 t
->bt
== btTypedef
||
1404 char name
[256], *pn
;
1406 /* Try to cross reference this type */
1407 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1408 /* reading .o file ? */
1409 if (UNSAFE_DATA_ADDR(tp
))
1410 tp
= init_type(type_code
, 0, 0, 0, (struct objfile
*) NULL
);
1411 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1412 sprintf(name
, fmt
, pn
);
1414 /* Usually, TYPE_CODE(tp) is already type_code. The main
1415 exception is if we guessed wrong re struct/union/enum. */
1416 if (TYPE_CODE(tp
) != type_code
) {
1417 complain (&bad_tag_guess_complaint
, 0);
1418 TYPE_CODE(tp
) = type_code
;
1420 if (TYPE_NAME(tp
) == NULL
|| strcmp(TYPE_NAME(tp
), name
) != 0)
1421 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1422 ¤t_objfile
-> type_obstack
);
1425 /* Deal with range types */
1426 if (t
->bt
== btRange
) {
1427 TYPE_NFIELDS (tp
) = 2;
1429 (struct field
*) obstack_alloc (¤t_objfile
-> type_obstack
,
1430 2 * sizeof (struct field
));
1431 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1432 ¤t_objfile
-> type_obstack
);
1433 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1435 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1436 ¤t_objfile
-> type_obstack
);
1437 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1441 /* Parse all the type qualifiers now. If there are more
1442 than 6 the game will continue in the next aux */
1444 #define PARSE_TQ(tq) \
1445 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1447 again
: PARSE_TQ(tq0
);
1457 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1463 /* Make up a complex type from a basic one. Type is passed by
1464 reference in TPP and side-effected as necessary. The type
1465 qualifier TQ says how to handle the aux symbols at AX for
1466 the symbol SX we are currently analyzing. BIGEND says whether
1467 aux symbols are big-endian or little-endian.
1468 Returns the number of aux symbols we parsed. */
1471 upgrade_type(tpp
, tq
, ax
, bigend
)
1480 /* Used in array processing */
1489 t
= lookup_pointer_type (*tpp
);
1494 t
= lookup_function_type (*tpp
);
1500 t
= init_type(TYPE_CODE_ARRAY
, 0, 0, 0, (struct objfile
*) NULL
);
1501 TYPE_TARGET_TYPE(t
) = *tpp
;
1503 /* Determine and record the domain type (type of index) */
1504 ecoff_swap_rndx_in (bigend
, ax
, &rndx
);
1509 rf
= AUX_GET_ISYM (bigend
, ax
);
1512 fh
= get_rfd(cur_fd
, rf
);
1514 /* Fields are kept in an array */
1515 /* FIXME - Memory leak! */
1516 if (TYPE_NFIELDS(t
))
1517 TYPE_FIELDS(t
) = (struct field
*)
1518 xrealloc((PTR
) TYPE_FIELDS(t
),
1519 (TYPE_NFIELDS(t
)+1) * sizeof(struct field
));
1521 TYPE_FIELDS(t
) = (struct field
*)
1522 xzalloc(sizeof(struct field
));
1523 f
= &(TYPE_FIELD(t
,TYPE_NFIELDS(t
)));
1525 memset((PTR
)f
, 0, sizeof(struct field
));
1527 /* XXX */ f
->type
= parse_type(id
+ (union aux_ext
*)fh
->iauxBase
,
1528 &f
->bitsize
, bigend
);
1531 lower
= AUX_GET_DNLOW (bigend
, ax
);
1533 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1535 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1537 /* Check whether supplied array element bit size matches
1538 the known size of the element type. If this complaint
1539 ends up not happening, we can remove this code. It's
1540 here because we aren't sure we understand this *&%&$
1542 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1544 /* Most likely an undefined type */
1546 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1549 complain (&array_bitsize_complaint
, rf
);
1551 TYPE_LENGTH(t
) = (upper
< 0) ? 0 :
1552 (upper
- lower
+ 1) * (rf
>> 3);
1557 /* Volatile -- currently ignored */
1561 complain (&unknown_type_qual_complaint
, tq
);
1567 /* Parse a procedure descriptor record PR. Note that the procedure
1568 is parsed _after_ the local symbols, now we just make up the
1569 extra information we need into a special symbol that we insert
1570 in the procedure's main block. Note also that images that
1571 have been partially stripped (ld -x) have been deprived
1572 of local symbols, and we have to cope with them here.
1573 The procedure's code ends at BOUND */
1576 parse_procedure(pr
, bound
)
1579 struct symbol
*s
, *i
;
1580 SYMR
*sh
= (SYMR
*)pr
->isym
;
1582 struct mips_extra_func_info
*e
;
1586 /* Make up a name for static procedures. Sigh. */
1587 if (sh
== (SYMR
*)-1) {
1588 sprintf(name
,".static_procedure@%x",pr
->adr
);
1589 sh_name
= savestring(name
, strlen(name
));
1593 sh_name
= (char*)sh
->iss
;
1594 s
= mylookup_symbol(sh_name
, top_stack
->cur_block
,
1595 VAR_NAMESPACE
, LOC_BLOCK
);
1598 b
= SYMBOL_BLOCK_VALUE(s
);
1600 s
= new_symbol(sh_name
);
1601 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1602 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1603 /* Donno its type, hope int is ok */
1604 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1605 add_symbol(s
, top_stack
->cur_block
);
1606 /* Wont have symbols for this one */
1608 SYMBOL_BLOCK_VALUE(s
) = b
;
1609 BLOCK_FUNCTION(b
) = s
;
1610 BLOCK_START(b
) = pr
->adr
;
1611 BLOCK_END(b
) = bound
;
1612 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1613 add_block(b
, top_stack
->cur_st
);
1616 s
= mylookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, LOC_CONST
);
1620 e
= (struct mips_extra_func_info
*)SYMBOL_VALUE(s
);
1622 e
->pdr
.isym
= (long)s
;
1626 /* Parse the external symbol ES. Just call parse_symbol() after
1627 making sure we know where the aux are for it. For procedures,
1628 parsing of the PDRs has already provided all the needed
1629 information, we only parse them if SKIP_PROCEDURES is false,
1630 and only if this causes no symbol duplication.
1631 BIGEND says whether aux entries are big-endian or little-endian.
1633 This routine clobbers top_stack->cur_block and ->cur_st. */
1636 parse_external(es
, skip_procedures
, bigend
)
1638 int skip_procedures
;
1643 if (es
->ifd
!= ifdNil
) {
1645 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1646 ax
= (union aux_ext
*)cur_fdr
->iauxBase
;
1648 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1651 top_stack
->cur_st
= cur_stab
;
1652 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
1655 /* Reading .o files */
1656 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1658 switch (es
->asym
.st
) {
1660 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1661 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1662 case stLabel
: what
= "label"; n_undef_labels
++; break;
1663 default : what
= "symbol"; break;
1667 printf_filtered("Warning: %s `%s' is undefined (in %s)\n", what
,
1668 es
->asym
.iss
, fdr_name((char *)cur_fdr
->rss
));
1672 switch (es
->asym
.st
) {
1674 /* If we have full symbols we do not need more */
1675 if (skip_procedures
)
1677 if (mylookup_symbol (es
->asym
.iss
, top_stack
->cur_block
,
1678 VAR_NAMESPACE
, LOC_BLOCK
))
1684 * Note that the case of a symbol with indexNil
1685 * must be handled anyways by parse_symbol().
1687 parse_symbol(&es
->asym
, ax
, bigend
);
1694 /* Parse the line number info for file descriptor FH into
1695 GDB's linetable LT. MIPS' encoding requires a little bit
1696 of magic to get things out. Note also that MIPS' line
1697 numbers can go back and forth, apparently we can live
1698 with that and do not need to reorder our linetables */
1703 struct linetable
*lt
;
1705 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1707 int delta
, count
, lineno
= 0;
1713 /* Scan by procedure descriptors */
1715 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1718 /* No code for this one */
1719 if (pr
->iline
== ilineNil
||
1720 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1723 * Aurgh! To know where to stop expanding we
1726 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1727 if (pr
[l
].iline
!= -1)
1729 if (l
== (fh
->cpd
- j
))
1734 * When procedures are moved around the linenumbers
1735 * are attributed to the next procedure up
1737 if (pr
->iline
>= halt
) continue;
1739 base
= (unsigned char*)pr
->cbLineOffset
;
1740 l
= pr
->adr
>> 2; /* in words */
1741 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1742 for (lineno
= pr
->lnLow
; l
< halt
;) {
1743 count
= *base
& 0x0f;
1744 delta
= *base
++ >> 4;
1748 delta
= (base
[0] << 8) | base
[1];
1749 if (delta
>= 0x8000)
1753 lineno
+= delta
;/* first delta is 0 */
1754 k
= add_line(lt
, lineno
, l
, k
);
1761 /* Master parsing procedure for first-pass reading of file symbols
1762 into a partial_symtab.
1764 Parses the symtab described by the global symbolic header CUR_HDR.
1765 END_OF_TEXT_SEG gives the address just after the text segment for
1766 the symtab we are reading. */
1769 parse_partial_symbols(end_of_text_seg
, objfile
)
1770 int end_of_text_seg
;
1771 struct objfile
*objfile
;
1774 /* int stat_idx, h_max;*/
1775 HDRR
*hdr
= cur_hdr
;
1776 /* Running pointers */
1780 struct partial_symtab
*pst
;
1782 int past_first_source_file
= 0;
1784 /* List of current psymtab's include files */
1785 char **psymtab_include_list
;
1786 int includes_allocated
;
1789 struct pst_map
* fdr_to_pst
;
1790 /* Index within current psymtab dependency list */
1791 struct partial_symtab
**dependency_list
;
1792 int dependencies_used
, dependencies_allocated
;
1793 struct cleanup
*old_chain
;
1795 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1796 sizeof(EXTR
*) * hdr
->iextMax
);
1798 includes_allocated
= 30;
1800 psymtab_include_list
= (char **) alloca (includes_allocated
*
1802 next_symbol_text_func
= mips_next_symbol_text
;
1804 dependencies_allocated
= 30;
1805 dependencies_used
= 0;
1807 (struct partial_symtab
**) alloca (dependencies_allocated
*
1808 sizeof (struct partial_symtab
*));
1810 last_source_file
= 0;
1815 * Only parse the Local and External symbols, and the Relative FDR.
1816 * Fixup enough of the loader symtab to be able to use it.
1817 * Allocate space only for the file's portions we need to
1822 max_glevel
= MIN_GLEVEL
;
1824 /* Allocate the map FDR -> PST.
1825 Minor hack: -O3 images might claim some global data belongs
1826 to FDR -1. We`ll go along with that */
1827 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1828 old_chain
= make_cleanup (free
, fdr_to_pst
);
1831 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1832 fdr_to_pst
[-1].pst
= pst
;
1836 /* Pass 1 over external syms: Presize and partition the list */
1837 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1838 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1839 fdr_to_pst
[esh
->ifd
].n_globals
++;
1842 /* Pass 1.5 over files: partition out global symbol space */
1844 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1845 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1846 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1847 fdr_to_pst
[f_idx
].n_globals
= 0;
1850 /* Pass 2 over external syms: fill in external symbols */
1851 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1852 enum minimal_symbol_type ms_type
= mst_text
;
1853 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1855 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1856 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1858 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1861 switch (esh
->asym
.st
) {
1870 ms_type
= mst_unknown
;
1871 complain (&unknown_ext_complaint
,
1872 (char *)(esh
->asym
.iss
));
1874 prim_record_minimal_symbol ((char *)esh
->asym
.iss
,
1879 /* Pass 3 over files, over local syms: fill in static symbols */
1880 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1881 struct partial_symtab
*save_pst
;
1883 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1885 if (fh
->csym
== 0) {
1886 fdr_to_pst
[f_idx
].pst
= NULL
;
1889 pst
= start_psymtab_common (objfile
, 0, (char*)fh
->rss
,
1890 fh
->cpd
? fh
->adr
: 0,
1891 objfile
->global_psymbols
.next
,
1892 objfile
->static_psymbols
.next
);
1893 pst
->read_symtab_private
= (char *)
1894 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1897 /* Make everything point to everything. */
1898 FDR_IDX(pst
) = f_idx
;
1899 fdr_to_pst
[f_idx
].pst
= pst
;
1900 fh
->ioptBase
= (int)pst
;
1902 CUR_HDR(pst
) = cur_hdr
;
1904 /* The way to turn this into a symtab is to call... */
1905 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1907 pst
->texthigh
= pst
->textlow
;
1909 #if 0 /* This is done in start_psymtab_common */
1910 pst
->globals_offset
= global_psymbols
.next
- global_psymbols
.list
;
1911 pst
->statics_offset
= static_psymbols
.next
- static_psymbols
.list
;
1913 pst
->n_global_syms
= 0;
1914 pst
->n_static_syms
= 0;
1917 /* The second symbol must be @stab.
1918 This symbol is emitted by mips-tfile to signal
1919 that the current object file uses encapsulated stabs
1920 instead of mips ecoff for local symbols.
1921 (It is the second symbol because the first symbol is
1922 the stFile used to signal the start of a file). */
1924 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
),
1925 stabs_symbol
) == 0) {
1926 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1929 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1930 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1931 if (!MIPS_IS_STAB(sh
)) {
1932 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
1933 long procaddr
= sh
->value
;
1934 sh
= AUX_GET_ISYM (fh
->fBigendian
,
1935 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
1936 + (SYMR
*) fh
->isymBase
- 1;
1937 if (sh
->st
== stEnd
) {
1938 long high
= procaddr
+ sh
->value
;
1939 if (high
> pst
->texthigh
)
1940 pst
->texthigh
= high
;
1945 #define SET_NAMESTRING() namestring = (char*)sh->iss
1946 #define CUR_SYMBOL_TYPE type_code
1947 #define CUR_SYMBOL_VALUE sh->value
1948 #define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
1950 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
1951 #define addr 0 /* FIXME, should be offset of addresses */
1952 #define HANDLE_RBRAC(val) \
1953 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
1954 #include "partial-stab.h"
1959 register struct partial_symbol
*psym
;
1960 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
1963 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1965 if (MIPS_IS_STAB(sh
)) {
1970 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
1971 sh
->index
== 0xfffff) {
1972 /* FIXME, premature? */
1977 name
= (char *)(sh
->iss
);
1982 case stProc
: /* Asm labels apparently */
1983 case stStaticProc
: /* Function */
1984 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
1985 VAR_NAMESPACE
, LOC_BLOCK
,
1986 objfile
->static_psymbols
, sh
->value
);
1987 /* Skip over procedure to next one. */
1988 cur_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
1989 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
1990 procaddr
= sh
->value
;
1992 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
1993 if (sh
->st
!= stEnd
)
1995 high
= procaddr
+ sh
->value
;
1996 if (high
> pst
->texthigh
)
1997 pst
->texthigh
= high
;
1999 case stStatic
: /* Variable */
2002 case stTypedef
: /* Typedef */
2003 class = LOC_TYPEDEF
;
2005 case stConstant
: /* Constant decl */
2011 case stBlock
: /* { }, str, un, enum*/
2012 if (sh
->sc
== scInfo
) {
2013 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2014 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2015 objfile
->static_psymbols
, sh
->value
);
2017 /* Skip over the block */
2018 cur_sdx
= sh
->index
;
2020 case stFile
: /* File headers */
2021 case stLabel
: /* Labels */
2022 case stEnd
: /* Ends of files */
2025 /* Both complaints are valid: one gives symbol name,
2026 the other the offending symbol type. */
2027 complain (&unknown_sym_complaint
, (char *)sh
->iss
);
2028 complain (&unknown_st_complaint
, sh
->st
);
2032 /* Use this gdb symbol */
2033 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2034 VAR_NAMESPACE
, class,
2035 objfile
->static_psymbols
, sh
->value
);
2037 cur_sdx
++; /* Go to next file symbol */
2040 /* Now do enter the external symbols. */
2041 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2042 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2043 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2044 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2045 for (; --cur_sdx
>= 0; ext_ptr
++) {
2046 enum address_class
class;
2047 if ((*ext_ptr
)->ifd
!= f_idx
)
2049 sh
= &(*ext_ptr
)->asym
;
2058 complain (&unknown_ext_complaint
, sh
->iss
);
2063 if (objfile
->global_psymbols
.next
>=
2064 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2065 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2066 psym
= objfile
->global_psymbols
.next
++;
2067 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2068 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2069 SYMBOL_CLASS (psym
) = class;
2070 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2074 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2075 -1, save_pst
->texthigh
,
2076 dependency_list
, dependencies_used
);
2077 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2078 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2080 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2081 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2085 /* Mark the last code address, and remember it for later */
2086 hdr
->cbDnOffset
= end_of_text_seg
;
2088 /* Now scan the FDRs for dependencies */
2089 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2091 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2092 pst
= fdr_to_pst
[f_idx
].pst
;
2094 /* This should catch stabs-in-ecoff. */
2098 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2099 /* ...then presumably a .h file: drop reverse depends .h->.c */
2100 for (; s_id0
< fh
->crfd
; s_id0
++) {
2101 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2103 s_id0
++; /* Skip self-dependency */
2108 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2109 pst
->dependencies
= (struct partial_symtab
**)
2110 obstack_alloc (&objfile
->psymbol_obstack
,
2111 pst
->number_of_dependencies
*
2112 sizeof (struct partial_symtab
*));
2113 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2114 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2115 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2116 complain(&bad_file_number_complaint
, *rh
);
2118 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2121 do_cleanups (old_chain
);
2126 /* Do the initial analisys of the F_IDX-th file descriptor.
2127 Allocates a partial symtab for it, and builds the list
2128 of dependent files by recursion. LEV says at which level
2129 of recursion we are called (to pretty up debug traces) */
2131 static struct partial_symtab
*
2132 parse_fdr(f_idx
, lev
, objfile
)
2135 struct objfile
*objfile
;
2138 register struct partial_symtab
*pst
;
2141 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2143 /* Use this to indicate into which symtab this file was parsed */
2145 return (struct partial_symtab
*) fh
->ioptBase
;
2147 /* Debuggability level */
2148 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2149 max_glevel
= fh
->glevel
;
2151 /* Make a new partial_symtab */
2152 pst
= new_psymtab(fh
->rss
, objfile
);
2157 pst
->textlow
= fh
->adr
;
2158 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2161 /* Make everything point to everything. */
2162 FDR_IDX(pst
) = f_idx
;
2163 fdr_to_pst
[f_idx
].pst
= pst
;
2164 fh
->ioptBase
= (int)pst
;
2166 /* Analyze its dependencies */
2171 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2172 /* ...then presumably a .h file: drop reverse depends .h->.c */
2173 for (; s_id0
< fh
->crfd
; s_id0
++) {
2174 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2176 s_id0
++; /* Skip self-dependency */
2181 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2182 pst
->dependencies
= (struct partial_symtab
**)
2183 obstack_alloc (&objfile
->psymbol_obstack
,
2184 pst
->number_of_dependencies
*
2185 sizeof (struct partial_symtab
*));
2186 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2187 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2189 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2197 mips_next_symbol_text ()
2200 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2203 /* Ancillary function to psymtab_to_symtab(). Does all the work
2204 for turning the partial symtab PST into a symtab, recurring
2205 first on all dependent psymtabs. The argument FILENAME is
2206 only passed so we can see in debug stack traces what file
2210 psymtab_to_symtab_1(pst
, filename
)
2211 struct partial_symtab
*pst
;
2219 struct linetable
*lines
;
2225 /* How many symbols will we need */
2226 /* FIXME, this does not count enum values. */
2227 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2228 if (FDR_IDX(pst
) == -1) {
2232 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2233 f_max
+= fh
->csym
+ fh
->cpd
;
2234 maxlines
= 2 * fh
->cline
;
2237 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2240 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)
2245 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
,
2248 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2249 lines
= LINETABLE(st
);
2250 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2251 if (pending_list
== 0) {
2252 pending_list
= (struct mips_pending
**)
2253 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2254 cur_hdr
->cbOptOffset
= (int)pending_list
;
2258 /* Read in all partial symbtabs on which this one is dependent.
2259 NOTE that we do have circular dependencies, sigh. We solved
2260 that by setting pst->readin before this point. */
2262 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2263 if (!pst
->dependencies
[i
]->readin
) {
2264 /* Inform about additional files to be read in. */
2267 fputs_filtered (" ", stdout
);
2269 fputs_filtered ("and ", stdout
);
2271 printf_filtered ("%s...",
2272 pst
->dependencies
[i
]->filename
);
2273 wrap_here (""); /* Flush output */
2276 /* We only pass the filename for debug purposes */
2277 psymtab_to_symtab_1(pst
->dependencies
[i
],
2278 pst
->dependencies
[i
]->filename
);
2282 /* Now read the symbols for this symtab */
2284 current_objfile
= pst
-> objfile
;
2286 cur_fd
= FDR_IDX(pst
);
2289 /* Get a new lexical context */
2292 top_stack
->cur_st
= cur_stab
;
2293 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(cur_stab
),
2295 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2296 BLOCK_END(top_stack
->cur_block
) = 0;
2297 top_stack
->blocktype
= stFile
;
2298 top_stack
->maxsyms
= 2*f_max
;
2299 top_stack
->cur_type
= 0;
2300 top_stack
->procadr
= 0;
2301 top_stack
->numargs
= 0;
2304 /* Parse locals and procedures */
2309 /* Parse local symbols first */
2314 current_objfile
= NULL
;
2317 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2318 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2319 char *name
= (char*)sh
->iss
;
2320 CORE_ADDR valu
= sh
->value
;
2321 if (MIPS_IS_STAB(sh
)) {
2322 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2323 process_one_symbol (type_code
, 0, valu
, name
, /*FIXME*/ 0);
2325 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2326 /* Handle encoded stab line number. */
2327 record_line (current_subfile
, sh
->index
, valu
);
2330 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2333 /* BOUND is the highest core address of this file's procedures */
2334 int bound
= cur_fd
== cur_hdr
->ifdMax
- 1 ? cur_hdr
->cbDnOffset
2336 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2337 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2338 cur_sdx
+= parse_symbol(sh
, (union aux_ent
*)fh
->iauxBase
,
2342 /* Procedures next, note we need to look-ahead to
2343 find out where the procedure's code ends */
2346 for (i
= 0; i
< fh
->cpd
-1; i
++) {
2347 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2348 parse_procedure(pr
, pr
[1].adr
); /* next proc up */
2351 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2352 parse_procedure(pr
, bound
); /* next file up */
2354 /* Linenumbers. At the end, check if we can save memory */
2355 parse_lines(fh
, lines
);
2356 if (lines
->nitems
< fh
->cline
)
2357 lines
= shrink_linetable(lines
);
2363 LINETABLE(st
) = lines
;
2365 /* .. and our share of externals.
2366 XXX use the global list to speed up things here. how ?
2367 FIXME, Maybe quit once we have found the right number of ext's? */
2368 /* parse_external clobbers top_stack->cur_block and ->cur_st here. */
2369 top_stack
->blocktype
= stFile
;
2370 top_stack
->maxsyms
=
2371 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2373 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2374 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2375 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2377 /* If there are undefined, tell the user */
2378 if (n_undef_symbols
) {
2379 printf_filtered("File %s contains %d unresolved references:",
2380 st
->filename
, n_undef_symbols
);
2381 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2382 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2383 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2389 /* Sort the symbol table now, we are done adding symbols to it.*/
2390 sort_symtab_syms(st
);
2394 /* Now link the psymtab and the symtab. */
2397 current_objfile
= NULL
;
2400 /* Ancillary parsing procedures. */
2402 /* Lookup the type at relative index RN. Return it in TPP
2403 if found and in any event come up with its name PNAME.
2404 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2405 Return value says how many aux symbols we ate. */
2408 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2411 int type_code
; /* Use to alloc new type if none is found. */
2419 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2421 /* Escape index means 'the next one' */
2422 if (rn
->rfd
== 0xfff) {
2424 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2431 *pname
= "<undefined>";
2434 * Find the relative file descriptor and the symbol in it
2436 FDR
*fh
= get_rfd(cur_fd
, rf
);
2441 * If we have processed this symbol then we left a forwarding
2442 * pointer to the corresponding GDB symbol. If not, we`ll put
2443 * it in a list of pending symbols, to be processed later when
2444 * the file f will be. In any event, we collect the name for
2445 * the type here. Which is why we made a first pass at
2448 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2450 /* Careful, we might be looking at .o files */
2451 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2454 /* Have we parsed it ? */
2455 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2456 t
= (struct type
*) sh
->value
;
2459 /* Avoid duplicates */
2460 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2464 *tpp
= init_type(type_code
, 0, 0, 0, (struct objfile
*) NULL
);
2465 add_pending(fh
, sh
, *tpp
);
2470 /* We used one auxent normally, two if we got a "next one" rf. */
2475 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2476 keeping the symtab sorted */
2478 static struct symbol
*
2479 mylookup_symbol (name
, block
, namespace, class)
2481 register struct block
*block
;
2482 enum namespace namespace;
2483 enum address_class
class;
2485 register int bot
, top
, inc
;
2486 register struct symbol
*sym
;
2489 top
= BLOCK_NSYMS(block
);
2492 sym
= BLOCK_SYM(block
, bot
);
2493 if (SYMBOL_NAME(sym
)[0] == inc
2494 && SYMBOL_NAMESPACE(sym
) == namespace
2495 && SYMBOL_CLASS(sym
) == class
2496 && !strcmp(SYMBOL_NAME(sym
), name
))
2500 block
= BLOCK_SUPERBLOCK (block
);
2502 return mylookup_symbol (name
, block
, namespace, class);
2507 /* Add a new symbol S to a block B.
2508 Infrequently, we will need to reallocate the block to make it bigger.
2509 We only detect this case when adding to top_stack->cur_block, since
2510 that's the only time we know how big the block is. FIXME. */
2517 int nsyms
= BLOCK_NSYMS(b
)++;
2518 struct block
*origb
;
2519 struct parse_stack
*stackp
;
2521 if (b
== top_stack
->cur_block
&&
2522 nsyms
>= top_stack
->maxsyms
) {
2523 complain (&block_overflow_complaint
, s
->name
);
2524 /* In this case shrink_block is actually grow_block, since
2525 BLOCK_NSYMS(b) is larger than its current size. */
2527 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2529 /* Now run through the stack replacing pointers to the
2530 original block. shrink_block has already done this
2531 for the blockvector and BLOCK_FUNCTION. */
2532 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2533 if (stackp
->cur_block
== origb
) {
2534 stackp
->cur_block
= b
;
2535 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2539 BLOCK_SYM(b
,nsyms
) = s
;
2542 /* Add a new block B to a symtab S */
2549 struct blockvector
*bv
= BLOCKVECTOR(s
);
2551 bv
= (struct blockvector
*)xrealloc((PTR
) bv
,
2552 sizeof(struct blockvector
) +
2553 BLOCKVECTOR_NBLOCKS(bv
)
2554 * sizeof(bv
->block
));
2555 if (bv
!= BLOCKVECTOR(s
))
2556 BLOCKVECTOR(s
) = bv
;
2558 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2561 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2562 MIPS' linenumber encoding might need more than one byte
2563 to describe it, LAST is used to detect these continuation lines */
2566 add_line(lt
, lineno
, adr
, last
)
2567 struct linetable
*lt
;
2573 last
= -2; /* make sure we record first line */
2575 if (last
== lineno
) /* skip continuation lines */
2578 lt
->item
[lt
->nitems
].line
= lineno
;
2579 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2583 /* Sorting and reordering procedures */
2585 /* Blocks with a smaller low bound should come first */
2588 compare_blocks(b1
, b2
)
2589 struct block
**b1
, **b2
;
2591 register int addr_diff
;
2593 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2595 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2599 /* Sort the blocks of a symtab S.
2600 Reorder the blocks in the blockvector by code-address,
2601 as required by some MI search routines */
2607 struct blockvector
*bv
= BLOCKVECTOR(s
);
2609 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2611 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2612 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2613 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2614 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2618 * This is very unfortunate: normally all functions are compiled in
2619 * the order they are found, but if the file is compiled -O3 things
2620 * are very different. It would be nice to find a reliable test
2621 * to detect -O3 images in advance.
2623 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2624 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2625 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2626 sizeof(struct block
*),
2630 register CORE_ADDR high
= 0;
2631 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2633 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2634 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2635 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2636 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2639 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2640 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2642 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2643 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2644 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2645 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2649 /* Constructor/restructor/destructor procedures */
2651 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2652 MAXSYMS and linenumbers MAXLINES we'll put in it */
2656 new_symtab(name
, maxsyms
, maxlines
, objfile
)
2660 struct objfile
*objfile
;
2662 struct symtab
*s
= allocate_symtab (name
, objfile
);
2664 LINETABLE(s
) = new_linetable(maxlines
);
2666 /* All symtabs must have at least two blocks */
2667 BLOCKVECTOR(s
) = new_bvect(2);
2668 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2669 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2670 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2671 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2673 s
->free_code
= free_linetable
;
2678 /* Allocate a new partial_symtab NAME */
2680 static struct partial_symtab
*
2681 new_psymtab(name
, objfile
)
2683 struct objfile
*objfile
;
2685 struct partial_symtab
*psymtab
;
2687 /* FIXME -- why (char *) -1 rather than NULL? */
2688 psymtab
= allocate_psymtab (name
== (char *) -1 ? "<no name>" : name
,
2691 /* Keep a backpointer to the file's symbols */
2693 psymtab
-> read_symtab_private
= (char *)
2694 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2695 CUR_HDR(psymtab
) = cur_hdr
;
2697 /* The way to turn this into a symtab is to call... */
2698 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
2703 /* Allocate a linetable array of the given SIZE. Since the struct
2704 already includes one item, we subtract one when calculating the
2705 proper size to allocate. */
2707 static struct linetable
*
2711 struct linetable
*l
;
2713 size
= (size
-1) * sizeof(l
->item
) + sizeof(struct linetable
);
2714 l
= (struct linetable
*)xmalloc(size
);
2719 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2720 I am not so sure about the 3.4 ones.
2722 Since the struct linetable already includes one item, we subtract one when
2723 calculating the proper size to allocate. */
2725 static struct linetable
*
2726 shrink_linetable(lt
)
2727 struct linetable
* lt
;
2730 return (struct linetable
*) xrealloc ((PTR
)lt
,
2731 sizeof(struct linetable
)
2732 + (lt
->nitems
- 1) * sizeof(lt
->item
));
2735 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2738 struct blockvector
*
2742 struct blockvector
*bv
;
2745 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2746 bv
= (struct blockvector
*) xzalloc(size
);
2748 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2753 /* Allocate and zero a new block of MAXSYMS symbols */
2760 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2762 return (struct block
*)xzalloc (size
);
2765 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2766 Shrink_block can also be used by add_symbol to grow a block. */
2768 static struct block
*
2774 struct blockvector
*bv
= BLOCKVECTOR(s
);
2777 /* Just reallocate it and fix references to the old one */
2779 new = (struct block
*) xrealloc ((PTR
)b
, sizeof(struct block
) +
2780 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2782 /* Should chase pointers to old one. Fortunately, that`s just
2783 the block`s function and inferior blocks */
2784 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2785 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2786 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2787 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2788 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2789 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2790 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2794 /* Create a new symbol with printname NAME */
2801 struct symbol
*s
= (struct symbol
*)
2802 obstack_alloc (¤t_objfile
->symbol_obstack
, sizeof (struct symbol
));
2804 memset ((PTR
)s
, 0, sizeof (*s
));
2805 SYMBOL_NAME(s
) = name
;
2809 /* Create a new type with printname NAME */
2818 t
= alloc_type (current_objfile
);
2819 TYPE_NAME(t
) = name
;
2820 TYPE_CPLUS_SPECIFIC(t
) = (struct cplus_struct_type
*)
2821 &cplus_struct_default
;
2826 /* Things used for calling functions in the inferior.
2827 These functions are exported to our companion
2828 mips-tdep.c file and are here because they play
2829 with the symbol-table explicitly. */
2831 /* Sigtramp: make sure we have all the necessary information
2832 about the signal trampoline code. Since the official code
2833 from MIPS does not do so, we make up that information ourselves.
2834 If they fix the library (unlikely) this code will neutralize itself. */
2841 struct block
*b
, *b0
;
2843 sigtramp_address
= -1;
2845 /* We know it is sold as sigvec */
2846 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2848 /* Most programs do not play with signals */
2852 b0
= SYMBOL_BLOCK_VALUE(s
);
2854 /* A label of sigvec, to be more precise */
2855 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
2857 /* But maybe this program uses its own version of sigvec */
2861 sigtramp_address
= SYMBOL_VALUE(s
);
2862 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
2864 /* Did we or MIPSco fix the library ? */
2865 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
2868 /* But what symtab does it live in ? */
2869 st
= find_pc_symtab(SYMBOL_VALUE(s
));
2872 * Ok, there goes the fix: turn it into a procedure, with all the
2873 * needed info. Note we make it a nested procedure of sigvec,
2874 * which is the way the (assembly) code is actually written.
2876 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
2877 SYMBOL_CLASS(s
) = LOC_BLOCK
;
2878 SYMBOL_TYPE(s
) = init_type(TYPE_CODE_FUNC
, 4, 0, 0, (struct objfile
*) NULL
);
2879 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
2881 /* Need a block to allocate .gdbinfo. in */
2883 SYMBOL_BLOCK_VALUE(s
) = b
;
2884 BLOCK_START(b
) = sigtramp_address
;
2885 BLOCK_END(b
) = sigtramp_end
;
2886 BLOCK_FUNCTION(b
) = s
;
2887 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
2891 /* Make a .gdbinfo. for it */
2893 struct mips_extra_func_info
*e
=
2894 (struct mips_extra_func_info
*)
2895 xzalloc(sizeof(struct mips_extra_func_info
));
2897 e
->numargs
= 0; /* the kernel thinks otherwise */
2898 /* align_longword(sigcontext + SIGFRAME) */
2899 e
->pdr
.frameoffset
= 0x150;
2900 e
->pdr
.framereg
= SP_REGNUM
;
2902 e
->pdr
.regmask
= -2;
2903 e
->pdr
.regoffset
= -(41 * sizeof(int));
2904 e
->pdr
.fregmask
= -1;
2905 e
->pdr
.fregoffset
= -(37 * sizeof(int));
2906 e
->pdr
.isym
= (long)s
;
2908 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
2909 s
= new_symbol(".gdbinfo.");
2910 SYMBOL_VALUE(s
) = (int) e
;
2911 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2912 SYMBOL_CLASS(s
) = LOC_CONST
;
2913 SYMBOL_TYPE(s
) = builtin_type_void
;
2914 current_objfile
= NULL
;
2917 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
2920 /* Initialization */
2922 static struct sym_fns ecoff_sym_fns
=
2924 "ecoff", /* sym_name: name or name prefix of BFD target type */
2925 5, /* sym_namelen: number of significant sym_name chars */
2926 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2927 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
2928 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
2929 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
2930 NULL
/* next: pointer to next struct sym_fns */
2934 _initialize_mipsread ()
2936 add_symtab_fns (&ecoff_sym_fns
);
2938 /* Missing basic types */
2939 builtin_type_string
=
2940 init_type (TYPE_CODE_PASCAL_ARRAY
,
2942 (struct objfile
*) NULL
);
2943 builtin_type_complex
=
2944 init_type(TYPE_CODE_FLT
,
2945 2 * sizeof(float), 0, "complex",
2946 (struct objfile
*) NULL
);
2947 builtin_type_double_complex
=
2948 init_type(TYPE_CODE_FLT
,
2949 2 * sizeof(double), 0, "double_complex",
2950 (struct objfile
*) NULL
);
2951 builtin_type_fixed_dec
=
2952 init_type(TYPE_CODE_INT
, sizeof(int),
2954 (struct objfile
*) NULL
);
2955 builtin_type_float_dec
=
2956 init_type(TYPE_CODE_FLT
, sizeof(double),
2957 0, "floating_decimal",
2958 (struct objfile
*) NULL
);