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
62 #include <sys/types.h>
67 #include <sys/param.h>
71 #include "coff/mips.h" /* COFF-like aspects of ecoff files */
72 #include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
74 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
75 #include "aout/aout64.h"
76 #include "aout/stab_gnu.h" /* STABS information */
79 struct external_filehdr f
;
80 struct external_aouthdr a
;
83 /* These must match the corresponding definition in gcc/config/xm-mips.h.
84 At some point, these should probably go into a shared include file,
85 but currently gcc and gdb do not share any directories. */
87 #define CODE_MASK 0x8F300
88 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
89 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
90 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
91 #define STABS_SYMBOL "@stabs"
93 /* Each partial symbol table entry contains a pointer to private data for the
94 read_symtab() function to use when expanding a partial symbol table entry
95 to a full symbol table entry.
97 For mipsread this structure contains the index of the FDR that this psymtab
98 represents and a pointer to the symbol table header HDRR from the symbol
99 file that the psymtab was created from. */
101 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
102 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
103 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
108 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
109 int extern_count
; /* Size of extern_tab. */
112 /* Things we import explicitly from other modules */
114 extern int info_verbose
;
116 /* Various complaints about symbol reading that don't abort the process */
118 struct complaint bad_file_number_complaint
=
119 {"bad file number %d", 0, 0};
121 struct complaint index_complaint
=
122 {"bad aux index at symbol %s", 0, 0};
124 struct complaint aux_index_complaint
=
125 {"bad proc end in aux found from symbol %s", 0, 0};
127 struct complaint unknown_ext_complaint
=
128 {"unknown external symbol %s", 0, 0};
130 struct complaint unknown_sym_complaint
=
131 {"unknown local symbol %s", 0, 0};
133 struct complaint unknown_st_complaint
=
134 {"with type %d", 0, 0};
136 struct complaint block_overflow_complaint
=
137 {"block containing %s overfilled", 0, 0};
139 struct complaint basic_type_complaint
=
140 {"cannot map MIPS basic type 0x%x", 0, 0};
142 struct complaint unknown_type_qual_complaint
=
143 {"unknown type qualifier 0x%x", 0, 0};
145 struct complaint array_bitsize_complaint
=
146 {"size of array target type not known, assuming %d bits", 0, 0};
148 struct complaint bad_tag_guess_complaint
=
149 {"guessed tag type of %s incorrectly", 0, 0};
151 struct complaint block_member_complaint
=
152 {"declaration block contains unhandled symbol type %d", 0, 0};
154 struct complaint stEnd_complaint
=
155 {"stEnd with storage class %d not handled", 0, 0};
157 struct complaint unknown_mips_symtype_complaint
=
158 {"unknown symbol type 0x%x", 0, 0};
160 struct complaint stab_unknown_complaint
=
161 {"unknown stabs symbol %s", 0, 0};
163 struct complaint pdr_for_nonsymbol_complaint
=
164 {"PDR for %s, but no symbol", 0, 0};
166 struct complaint pdr_static_symbol_complaint
=
167 {"can't handle PDR for static proc at 0x%x", 0, 0};
169 /* Macros and extra defs */
171 /* Already-parsed symbols are marked specially */
173 #define stParsed stType
175 /* Puns: hard to find whether -g was used and how */
177 #define MIN_GLEVEL GLEVEL_0
178 #define compare_glevel(a,b) \
179 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
180 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
182 /* When looking at .o files, avoid tripping over bad addresses */
184 #define SAFE_TEXT_ADDR 0x400000
185 #define SAFE_DATA_ADDR 0x10000000
187 #define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR)
189 /* Things that really are local to this module */
191 /* MIPS symtab header for the current file */
193 static HDRR
*cur_hdr
;
195 /* Pointer to current file decriptor record, and its index */
200 /* Index of current symbol */
204 /* Note how much "debuggable" this image is. We would like
205 to see at least one FDR with full symbols */
210 /* When examining .o files, report on undefined symbols */
212 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
214 /* Pseudo symbol to use when putting stabs into the symbol table. */
216 static char stabs_symbol
[] = STABS_SYMBOL
;
218 /* Extra builtin types */
220 struct type
*builtin_type_complex
;
221 struct type
*builtin_type_double_complex
;
222 struct type
*builtin_type_fixed_dec
;
223 struct type
*builtin_type_float_dec
;
224 struct type
*builtin_type_string
;
226 /* Forward declarations */
229 fixup_symtab
PARAMS ((HDRR
*, char *, int, bfd
*));
232 read_mips_symtab
PARAMS ((struct objfile
*));
235 read_the_mips_symtab
PARAMS ((bfd
*, CORE_ADDR
*));
238 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
241 parse_partial_symbols
PARAMS ((int, struct objfile
*));
244 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
248 fixup_sigtramp
PARAMS ((void));
250 static struct symbol
*
251 new_symbol
PARAMS ((char *));
254 new_type
PARAMS ((char *));
256 static struct block
*
257 new_block
PARAMS ((int));
259 static struct symtab
*
260 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
262 static struct linetable
*
263 new_linetable
PARAMS ((int));
265 static struct blockvector
*
266 new_bvect
PARAMS ((int));
269 parse_type
PARAMS ((union aux_ext
*, int *, int));
271 static struct symbol
*
272 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
273 enum address_class
));
275 static struct block
*
276 shrink_block
PARAMS ((struct block
*, struct symtab
*));
279 xzalloc
PARAMS ((unsigned int));
282 sort_blocks
PARAMS ((struct symtab
*));
285 compare_blocks
PARAMS ((const void *, const void *));
287 static struct partial_symtab
*
288 new_psymtab
PARAMS ((char *, struct objfile
*));
291 static struct partial_symtab
*
292 parse_fdr
PARAMS ((int, int, struct objfile
*));
296 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
299 add_block
PARAMS ((struct block
*, struct symtab
*));
302 add_symbol
PARAMS ((struct symbol
*, struct block
*));
305 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
307 static struct linetable
*
308 shrink_linetable
PARAMS ((struct linetable
*));
311 mips_next_symbol_text
PARAMS ((void));
313 /* Things we export to other modules */
315 /* Address bounds for the signal trampoline in inferior, if any */
316 /* FIXME: Nothing really seems to use this. Why is it here? */
318 CORE_ADDR sigtramp_address
, sigtramp_end
;
321 mipscoff_new_init (ignore
)
322 struct objfile
*ignore
;
327 mipscoff_symfile_init (objfile
)
328 struct objfile
*objfile
;
330 if (objfile
-> sym_private
!= NULL
)
332 mfree (objfile
-> md
, objfile
-> sym_private
);
334 objfile
-> sym_private
= NULL
;
338 mipscoff_symfile_read (objfile
, addr
, mainline
)
339 struct objfile
*objfile
;
343 bfd
*abfd
= objfile
-> obfd
;
345 init_minimal_symbol_collection ();
346 make_cleanup (discard_minimal_symbols
, 0);
348 /* Now that the executable file is positioned at symbol table,
349 process it and define symbols accordingly. */
351 read_mips_symtab(objfile
);
353 /* Install any minimal symbols that have been collected as the current
354 minimal symbols for this objfile. */
356 install_minimal_symbols (objfile
);
359 /* Perform any local cleanups required when we are done with a particular
360 objfile. I.E, we are in the process of discarding all symbol information
361 for an objfile, freeing up all memory held for it, and unlinking the
362 objfile struct from the global list of known objfiles. */
365 mipscoff_symfile_finish (objfile
)
366 struct objfile
*objfile
;
368 if (objfile
-> sym_private
!= NULL
)
370 mfree (objfile
-> md
, objfile
-> sym_private
);
373 /* If we have a file symbol header lying around, blow it away. */
382 /* Allocate zeroed memory */
388 PTR p
= xmalloc(size
);
394 /* Exported procedure: Builds a symtab from the PST partial one.
395 Restores the environment in effect when PST was created, delegates
396 most of the work to an ancillary procedure, and sorts
397 and reorders the symtab list at the end */
400 mipscoff_psymtab_to_symtab(pst
)
401 struct partial_symtab
*pst
;
408 printf_filtered("Reading in symbols for %s...", pst
->filename
);
411 /* Restore the header and list of pending typedefs */
412 cur_hdr
= CUR_HDR(pst
);
414 next_symbol_text_func
= mips_next_symbol_text
;
416 psymtab_to_symtab_1(pst
, pst
->filename
);
418 /* Match with global symbols. This only needs to be done once,
419 after all of the symtabs and dependencies have been read in. */
420 scan_file_globals (pst
->objfile
);
423 printf_filtered("done.\n");
426 /* Exported procedure: Is PC in the signal trampoline code */
429 in_sigtramp(pc
, ignore
)
431 char *ignore
; /* function name */
433 if (sigtramp_address
== 0)
435 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
438 /* File-level interface functions */
440 /* Read the symtab information from file ABFD into memory. Also,
441 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
444 read_the_mips_symtab(abfd
, end_of_text_segp
)
446 CORE_ADDR
*end_of_text_segp
;
448 int stsize
, st_hdrsize
;
450 struct hdr_ext hdr_ext
;
452 /* Header for executable/object file we read symbols from */
453 struct coff_exec filhdr
;
456 /* We need some info from the initial headers */
457 val
= bfd_seek(abfd
, 0L, L_SET
);
458 val
= bfd_read((PTR
)&filhdr
, sizeof filhdr
, 1, abfd
);
460 if (end_of_text_segp
)
462 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
463 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
465 /* Find and read the symbol table header */
466 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
467 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
471 bfd_seek (abfd
, st_filptr
, L_SET
);
472 if (st_hdrsize
!= sizeof (hdr_ext
)) { /* Profanity check */
473 error ("Wrong header size: %d, not %d", st_hdrsize
,
476 if (bfd_read((PTR
)&hdr_ext
, st_hdrsize
, 1, abfd
) != st_hdrsize
)
478 ecoff_swap_hdr_in (abfd
, &hdr_ext
, &st_hdr
);
480 /* Find out how large the symbol table is */
481 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
482 + st_hdr
.iextMax
* cbEXTR
;
484 /* Allocate space for the symbol table. Read it in. */
485 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
487 memcpy((PTR
)cur_hdr
, (PTR
)&hdr_ext
, st_hdrsize
);
488 if (bfd_read((char *)cur_hdr
+ st_hdrsize
, stsize
, 1, abfd
) != stsize
)
491 /* Fixup file_pointers in it */
492 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
493 st_filptr
+ st_hdrsize
, abfd
);
497 error("Short read on %s", bfd_get_filename (abfd
));
501 /* Turn all file-relative pointers in the symtab described by HDR
502 into memory pointers, given that the symtab itself is located
503 at DATA in memory and F_PTR in the file.
505 Byte-swap all the data structures, in place, while we are at it --
506 except AUX entries, which we leave in their original byte order.
507 They will be swapped as they are used instead. (FIXME: we ought to
508 do all the data structures that way.) */
511 fixup_symtab (hdr
, data
, f_ptr
, abfd
)
522 struct rfd_ext
*rbase
;
524 /* This function depends on the external and internal forms
525 of the MIPS symbol table taking identical space. Check this
526 assumption at compile-time. */
527 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
528 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
529 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
530 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
531 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
532 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
533 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
534 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
535 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
536 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
537 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
538 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
540 /* Swap in the header record. */
541 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
544 * These fields are useless (and empty) by now:
545 * hdr->cbDnOffset, hdr->cbOptOffset
546 * We use them for other internal purposes.
549 hdr
->cbOptOffset
= 0;
552 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
566 /* Fix all the RFD's. */
567 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
568 for (i
= 0; i
< hdr
->crfd
; i
++) {
569 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
572 /* Fix all string pointers inside the symtab, and
573 the FDR records. Also fix other miscellany. */
575 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
576 register unsigned code_offset
;
578 /* Header itself, and strings */
579 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
581 /* Swap in the FDR */
582 ecoff_swap_fdr_in (abfd
, fh
, fh
);
584 fh
->issBase
+= hdr
->cbSsOffset
;
586 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
589 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
591 /* FIXME! Probably don't want to do this here! */
592 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
593 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
594 ecoff_swap_sym_in (abfd
, sh
, sh
);
596 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
602 /* cannot fix fh->ipdFirst because it is a short */
603 #define IPDFIRST(h,fh) \
604 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
606 /* Optional symbols (actually used for partial_symtabs) */
612 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
613 /* Relative file descriptor table */
614 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
618 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
620 /* Procedure symbols. (XXX This should be done later) */
621 code_offset
= fh
->adr
;
622 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
623 unsigned name
, only_ext
;
625 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
626 ecoff_swap_pdr_in (abfd
, pr
, pr
);
628 /* Simple rule to find files linked "-x" */
629 only_ext
= fh
->rss
== -1;
631 if (pr
->isym
== -1) {
632 /* static function */
636 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
637 sh
= &((EXTR
*)name
)->asym
;
641 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
642 /* Included code ? */
643 if (s_idx
== 0 && pr
->adr
!= 0)
644 code_offset
-= pr
->adr
;
647 /* Turn index into a pointer */
650 /* Fix line numbers */
651 pr
->cbLineOffset
+= fh
->cbLineOffset
;
653 /* Relocate address */
655 pr
->adr
+= code_offset
;
659 /* External symbols: swap in, and fix string */
660 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
661 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
662 ecoff_swap_ext_in (abfd
, esh
, esh
);
663 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
668 /* Find a file descriptor given its index RF relative to a file CF */
676 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
677 /* Object files do not have the RFD table, all refs are absolute */
679 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
680 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
681 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
684 /* Return a safer print NAME for a file descriptor */
690 if (name
== (char *) -1)
691 return "<stripped file>";
692 if (UNSAFE_DATA_ADDR(name
))
698 /* Read in and parse the symtab of the file DESC. INCREMENTAL says
699 whether we are adding to the general symtab or not.
700 FIXME: INCREMENTAL is currently always zero, though it should not be. */
703 read_mips_symtab (objfile
)
704 struct objfile
*objfile
;
706 CORE_ADDR end_of_text_seg
;
708 read_the_mips_symtab(objfile
->obfd
, &end_of_text_seg
);
710 parse_partial_symbols(end_of_text_seg
, objfile
);
714 * Check to make sure file was compiled with -g.
715 * If not, warn the user of this limitation.
717 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
718 if (max_gdbinfo
== 0)
720 "\n%s not compiled with -g, debugging support is limited.\n",
723 "You should compile with -g2 or -g3 for best debugging support.\n");
729 /* Local utilities */
731 /* Map of FDR indexes to partial symtabs */
734 struct partial_symtab
*pst
; /* the psymtab proper */
735 int n_globals
; /* exported globals (external symbols) */
736 int globals_offset
; /* cumulative */
740 /* Utility stack, used to nest procedures and blocks properly.
741 It is a doubly linked list, to avoid too many alloc/free.
742 Since we might need it quite a few times it is NOT deallocated
745 static struct parse_stack
{
746 struct parse_stack
*next
, *prev
;
747 struct symtab
*cur_st
; /* Current symtab. */
748 struct block
*cur_block
; /* Block in it. */
749 int blocktype
; /* What are we parsing. */
750 int maxsyms
; /* Max symbols in this block. */
751 struct type
*cur_type
; /* Type we parse fields for. */
752 int cur_field
; /* Field number in cur_type. */
753 int procadr
; /* Start addres of this procedure */
754 int numargs
; /* Its argument count */
755 } *top_stack
; /* Top stack ptr */
758 /* Enter a new lexical context */
763 struct parse_stack
*new;
765 /* Reuse frames if possible */
766 if (top_stack
&& top_stack
->prev
)
767 new = top_stack
->prev
;
769 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
770 /* Initialize new frame with previous content */
772 register struct parse_stack
*prev
= new->prev
;
775 top_stack
->prev
= new;
777 new->next
= top_stack
;
782 /* Exit a lexical context */
790 top_stack
= top_stack
->next
;
794 /* Cross-references might be to things we haven't looked at
795 yet, e.g. type references. To avoid too many type
796 duplications we keep a quick fixup table, an array
797 of lists of references indexed by file descriptor */
799 static struct mips_pending
{
800 struct mips_pending
*next
; /* link */
801 SYMR
*s
; /* the symbol */
802 struct type
*t
; /* its partial type descriptor */
806 /* Check whether we already saw symbol SH in file FH as undefined */
808 static struct mips_pending
*
809 is_pending_symbol(fh
, sh
)
813 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
814 register struct mips_pending
*p
;
816 /* Linear search is ok, list is typically no more than 10 deep */
817 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
823 /* Add a new undef symbol SH of type T */
826 add_pending(fh
, sh
, t
)
831 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
832 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
834 /* Make sure we do not make duplicates */
836 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
839 p
->next
= pending_list
[f_idx
];
840 pending_list
[f_idx
] = p
;
842 sh
->reserved
= 1; /* for quick check */
845 /* Throw away undef entries when done with file index F_IDX */
846 /* FIXME -- storage leak. This is never called!!! --gnu */
852 register struct mips_pending
*p
, *q
;
854 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
858 pending_list
[f_idx
] = 0;
862 prepend_tag_kind(tag_name
, type_code
)
864 enum type_code type_code
;
872 case TYPE_CODE_STRUCT
:
875 case TYPE_CODE_UNION
:
882 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
883 strlen(prefix
) + strlen(tag_name
) + 1);
884 sprintf(result
, "%s%s", prefix
, tag_name
);
889 /* Parsing Routines proper. */
891 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
892 For blocks, procedures and types we open a new lexical context.
893 This is basically just a big switch on the symbol's type.
894 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
895 BIGEND says whether aux symbols are big-endian or little-endian.
896 Return count of SYMR's handled (normally one). */
899 parse_symbol(sh
, ax
, bigend
)
910 /* When a symbol is cross-referenced from other files/symbols
911 we mark it explicitly */
912 int pend
= (sh
->reserved
== 1);
913 enum address_class
class;
921 case stGlobal
: /* external symbol, goes into global block */
923 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
925 s
= new_symbol((char *)sh
->iss
);
926 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
929 case stStatic
: /* static data, goes into current block. */
931 b
= top_stack
->cur_block
;
932 s
= new_symbol((char *)sh
->iss
);
933 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
936 case stLocal
: /* local variable, goes into current block */
937 if (sh
->sc
== scRegister
) {
938 class = LOC_REGISTER
;
940 sh
->value
+= FP0_REGNUM
-32;
943 b
= top_stack
->cur_block
;
944 s
= new_symbol((char *)sh
->iss
);
945 SYMBOL_VALUE(s
) = sh
->value
;
947 data
: /* Common code for symbols describing data */
948 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
949 SYMBOL_CLASS(s
) = class;
952 /* Type could be missing in a number of cases */
953 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
954 sh
->index
== 0xfffff)
955 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
957 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
958 /* Value of a data symbol is its memory address */
961 case stParam
: /* arg to procedure, goes into current block */
963 top_stack
->numargs
++;
965 name
= (char*)sh
->iss
;
966 /* Special GNU C++ name. */
967 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
968 name
= "this"; /* FIXME, not alloc'd in obstack */
969 s
= new_symbol(name
);
971 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
972 if (sh
->sc
== scRegister
) {
973 SYMBOL_CLASS(s
) = LOC_REGPARM
;
975 sh
->value
+= FP0_REGNUM
-32;
977 SYMBOL_CLASS(s
) = LOC_ARG
;
978 SYMBOL_VALUE(s
) = sh
->value
;
979 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
980 add_symbol(s
, top_stack
->cur_block
);
982 /* FIXME: This has not been tested. See dbxread.c */
983 /* Add the type of this parameter to the function/procedure
984 type of this block. */
985 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
989 case stLabel
: /* label, goes into current block */
990 s
= new_symbol((char *)sh
->iss
);
991 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
992 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
993 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
994 SYMBOL_TYPE(s
) = builtin_type_int
;
995 add_symbol(s
, top_stack
->cur_block
);
998 case stProc
: /* Procedure, usually goes into global block */
999 case stStaticProc
: /* Static procedure, goes into current block */
1000 s
= new_symbol((char *)sh
->iss
);
1001 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1002 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1003 /* Type of the return value */
1004 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1005 t
= builtin_type_int
;
1007 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
1008 b
= top_stack
->cur_block
;
1009 if (sh
->st
== stProc
) {
1010 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1011 /* The next test should normally be true,
1012 but provides a hook for nested functions
1013 (which we don't want to make global). */
1014 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
1015 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
1019 /* Make a type for the procedure itself */
1021 /* FIXME: This has not been tested yet! See dbxread.c */
1022 /* Generate a template for the type of this function. The
1023 types of the arguments will be added as we read the symbol
1025 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1027 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1030 /* Create and enter a new lexical context */
1031 b
= new_block(top_stack
->maxsyms
);
1032 SYMBOL_BLOCK_VALUE(s
) = b
;
1033 BLOCK_FUNCTION(b
) = s
;
1034 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1035 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1036 add_block(b
, top_stack
->cur_st
);
1038 /* Not if we only have partial info */
1039 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1043 top_stack
->cur_block
= b
;
1044 top_stack
->blocktype
= sh
->st
;
1045 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1046 top_stack
->cur_field
= -1;
1047 top_stack
->procadr
= sh
->value
;
1048 top_stack
->numargs
= 0;
1050 sh
->value
= (long) SYMBOL_TYPE(s
);
1053 /* Beginning of code for structure, union, and enum definitions.
1054 They all share a common set of local variables, defined here. */
1056 enum type_code type_code
;
1062 case stStruct
: /* Start a block defining a struct type */
1063 type_code
= TYPE_CODE_STRUCT
;
1064 goto structured_common
;
1066 case stUnion
: /* Start a block defining a union type */
1067 type_code
= TYPE_CODE_UNION
;
1068 goto structured_common
;
1070 case stEnum
: /* Start a block defining an enum type */
1071 type_code
= TYPE_CODE_ENUM
;
1072 goto structured_common
;
1074 case stBlock
: /* Either a lexical block, or some type */
1075 if (sh
->sc
!= scInfo
)
1076 goto case_stBlock_code
; /* Lexical block */
1078 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
1080 /* Common code for handling struct, union, enum, and/or as-yet-
1081 unknown-type blocks of info about structured data. `type_code'
1082 has been set to the proper TYPE_CODE, if we know it. */
1085 top_stack
->blocktype
= stBlock
;
1087 s
= new_symbol((char *)sh
->iss
);
1088 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1089 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1090 SYMBOL_VALUE(s
) = 0;
1091 add_symbol(s
, top_stack
->cur_block
);
1093 /* First count the number of fields and the highest value. */
1096 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1098 if (tsym
->st
== stMember
) {
1099 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1100 /* If the type of the member is Nil (or Void),
1101 assume the tag is an enumeration. */
1102 if (tsym
->index
== indexNil
)
1103 type_code
= TYPE_CODE_ENUM
;
1105 ecoff_swap_tir_in (bigend
,
1106 &ax
[tsym
->index
].a_ti
,
1108 if (tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1109 type_code
= TYPE_CODE_ENUM
;
1112 if (tsym
->value
> max_value
)
1113 max_value
= tsym
->value
;
1115 else if (tsym
->st
== stBlock
1116 || tsym
->st
== stUnion
1117 || tsym
->st
== stEnum
1118 || tsym
->st
== stStruct
1119 || tsym
->st
== stParsed
) {
1120 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1121 if (tsym
->index
!= 0)
1122 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1125 else complain (&block_member_complaint
, (char *)tsym
->st
);
1128 /* In an stBlock, there is no way to distinguish structs,
1129 unions, and enums at this point. This is a bug in the
1130 original design (that has been fixed with the
1131 recent addition of the stStruct, stUnion, and stEnum
1132 symbol types.) The way you can tell is if/when you
1133 see a variable or field of that type. In that case
1134 the variable's type (in the AUX table) says if the
1135 type is struct, union, or enum,
1136 and points back to the stBlock here.
1137 So you can patch the tag kind up later - but only
1138 if there actually is a variable or field of that type.
1140 So until we know for sure, we will guess at this point.
1142 If the first member has index==indexNil or a void type,
1143 assume we have an enumeration.
1144 Otherwise, if there is more than one member, and all
1145 the members have offset 0, assume we have a union.
1146 Otherwise, assume we have a struct.
1148 The heuristic could guess wrong in the case of
1149 of an enumeration with no members or a union
1150 with one (or zero) members, or when all except the
1151 last field of a struct have width zero.
1152 These are uncommon and/or illegal situations, and
1153 in any case guessing wrong probably doesn't matter much.
1155 But if we later do find out we were wrong,
1156 we fixup the tag kind. Members of an enumeration
1157 must be handled differently from struct/union fields,
1158 and that is harder to patch up, but luckily we
1159 shouldn't need to. (If there are any enumeration
1160 members, we can tell for sure it's an enum here.) */
1162 if (type_code
== TYPE_CODE_UNDEF
)
1163 if (nfields
> 1 && max_value
== 0)
1164 type_code
= TYPE_CODE_UNION
;
1166 type_code
= TYPE_CODE_STRUCT
;
1168 /* If this type was expected, use its partial definition */
1170 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1172 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1175 TYPE_CODE(t
) = type_code
;
1176 TYPE_LENGTH(t
) = sh
->value
;
1177 TYPE_NFIELDS(t
) = nfields
;
1178 TYPE_FIELDS(t
) = f
= (struct field
*)
1179 obstack_alloc (¤t_objfile
-> type_obstack
,
1180 nfields
* sizeof (struct field
));
1182 if (type_code
== TYPE_CODE_ENUM
) {
1183 /* This is a non-empty enum. */
1184 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1185 struct symbol
*enum_sym
;
1186 f
->bitpos
= tsym
->value
;
1188 f
->name
= (char*)tsym
->iss
;
1191 enum_sym
= (struct symbol
*)
1192 obstack_alloc (¤t_objfile
->symbol_obstack
,
1193 sizeof (struct symbol
));
1194 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1195 SYMBOL_NAME (enum_sym
) = f
->name
;
1196 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1197 SYMBOL_TYPE (enum_sym
) = t
;
1198 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1199 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1200 add_symbol(enum_sym
, top_stack
->cur_block
);
1202 /* Skip the stMembers that we've handled. */
1208 /* make this the current type */
1209 top_stack
->cur_type
= t
;
1210 top_stack
->cur_field
= 0;
1211 /* Mark that symbol has a type, and say which one */
1212 sh
->value
= (long) t
;
1215 /* End of local variables shared by struct, union, enum, and
1216 block (as yet unknown struct/union/enum) processing. */
1220 /* beginnning of (code) block. Value of symbol
1221 is the displacement from procedure start */
1223 top_stack
->blocktype
= stBlock
;
1224 b
= new_block(top_stack
->maxsyms
);
1225 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1226 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1227 top_stack
->cur_block
= b
;
1228 add_block(b
, top_stack
->cur_st
);
1231 case stEnd
: /* end (of anything) */
1232 if (sh
->sc
== scInfo
) {
1233 /* Finished with type */
1234 top_stack
->cur_type
= 0;
1235 } else if (sh
->sc
== scText
&&
1236 (top_stack
->blocktype
== stProc
||
1237 top_stack
->blocktype
== stStaticProc
)) {
1238 /* Finished with procedure */
1239 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1240 struct mips_extra_func_info
*e
;
1244 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1246 /* Make up special symbol to contain procedure specific
1248 s
= new_symbol(".gdbinfo.");
1249 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1250 SYMBOL_CLASS(s
) = LOC_CONST
;
1251 SYMBOL_TYPE(s
) = builtin_type_void
;
1252 e
= (struct mips_extra_func_info
*)
1253 obstack_alloc (¤t_objfile
->symbol_obstack
,
1254 sizeof (struct mips_extra_func_info
));
1255 SYMBOL_VALUE(s
) = (int)e
;
1256 e
->numargs
= top_stack
->numargs
;
1257 add_symbol(s
, top_stack
->cur_block
);
1259 /* Reallocate symbols, saving memory */
1260 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1262 /* f77 emits proc-level with address bounds==[0,0],
1263 So look for such child blocks, and patch them. */
1264 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1265 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1266 if (BLOCK_SUPERBLOCK(b_bad
) == b
1267 && BLOCK_START(b_bad
) == top_stack
->procadr
1268 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1269 BLOCK_START(b_bad
) = BLOCK_START(b
);
1270 BLOCK_END(b_bad
) = BLOCK_END(b
);
1273 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1274 /* End of (code) block. The value of the symbol
1275 is the displacement from the procedure`s start
1276 address of the end of this block. */
1277 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1278 (void) shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1279 } else complain (&stEnd_complaint
, (char *)sh
->sc
);
1281 pop_parse_stack(); /* restore previous lexical context */
1284 case stMember
: /* member of struct or union */
1285 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1286 f
->name
= (char*)sh
->iss
;
1287 f
->bitpos
= sh
->value
;
1289 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1292 case stTypedef
: /* type definition */
1293 s
= new_symbol((char *)sh
->iss
);
1294 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1295 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1296 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1297 add_symbol(s
, top_stack
->cur_block
);
1298 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1299 sh
->value
= (long) SYMBOL_TYPE(s
);
1302 case stFile
: /* file name */
1304 top_stack
->blocktype
= sh
->st
;
1307 /* I`ve never seen these for C */
1309 break; /* register relocation */
1311 break; /* forwarding address */
1313 break; /* constant */
1315 complain(&unknown_mips_symtype_complaint
, (char *)sh
->st
);
1322 /* Parse the type information provided in the raw AX entries for
1323 the symbol SH. Return the bitfield size in BS, in case.
1324 We must byte-swap the AX entries before we use them; BIGEND says whether
1325 they are big-endian or little-endian (from fh->fBigendian). */
1327 static struct type
*
1328 parse_type(ax
, bs
, bigend
)
1333 /* Null entries in this map are treated specially */
1334 static struct type
**map_bt
[] =
1336 &builtin_type_void
, /* btNil */
1338 &builtin_type_char
, /* btChar */
1339 &builtin_type_unsigned_char
, /* btUChar */
1340 &builtin_type_short
, /* btShort */
1341 &builtin_type_unsigned_short
, /* btUShort */
1342 &builtin_type_int
, /* btInt */
1343 &builtin_type_unsigned_int
, /* btUInt */
1344 &builtin_type_long
, /* btLong */
1345 &builtin_type_unsigned_long
, /* btULong */
1346 &builtin_type_float
, /* btFloat */
1347 &builtin_type_double
, /* btDouble */
1354 &builtin_type_complex
, /* btComplex */
1355 &builtin_type_double_complex
, /* btDComplex */
1357 &builtin_type_fixed_dec
, /* btFixedDec */
1358 &builtin_type_float_dec
, /* btFloatDec */
1359 &builtin_type_string
, /* btString */
1362 &builtin_type_void
, /* btVoid */
1363 &builtin_type_long_long
, /* btLongLong */
1364 &builtin_type_unsigned_long_long
,/* btULongLong */
1368 struct type
*tp
= 0;
1371 enum type_code type_code
;
1373 /* Use aux as a type information record, map its basic type. */
1375 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1376 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1377 complain (&basic_type_complaint
, (char *)t
->bt
);
1378 return builtin_type_int
;
1380 if (map_bt
[t
->bt
]) {
1381 tp
= *map_bt
[t
->bt
];
1385 /* Cannot use builtin types -- build our own */
1388 tp
= lookup_pointer_type (builtin_type_void
);
1392 type_code
= TYPE_CODE_STRUCT
;
1396 type_code
= TYPE_CODE_UNION
;
1400 type_code
= TYPE_CODE_ENUM
;
1404 type_code
= TYPE_CODE_RANGE
;
1408 type_code
= TYPE_CODE_SET
;
1413 complain (&basic_type_complaint
, (char *)t
->bt
);
1414 return builtin_type_int
;
1418 /* Skip over any further type qualifiers (FIXME). */
1420 /* This is the way it would work if the compiler worked */
1424 ecoff_swap_tir_in (bigend
, ax
, t1
);
1425 } while (t1
->continued
);
1428 /* Move on to next aux */
1432 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1436 /* All these types really point to some (common) MIPS type
1437 definition, and only the type-qualifiers fully identify
1438 them. We'll make the same effort at sharing. */
1439 if (t
->bt
== btIndirect
||
1440 t
->bt
== btStruct
||
1443 t
->bt
== btTypedef
||
1446 char name
[256], *pn
;
1448 /* Try to cross reference this type */
1449 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1450 /* reading .o file ? */
1451 if (UNSAFE_DATA_ADDR(tp
))
1452 tp
= init_type(type_code
, 0, 0, (char *) NULL
,
1453 (struct objfile
*) NULL
);
1454 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1455 sprintf(name
, fmt
, pn
);
1457 /* Usually, TYPE_CODE(tp) is already type_code. The main
1458 exception is if we guessed wrong re struct/union/enum. */
1459 if (TYPE_CODE(tp
) != type_code
) {
1460 complain (&bad_tag_guess_complaint
, name
);
1461 TYPE_CODE(tp
) = type_code
;
1463 if (TYPE_NAME(tp
) == NULL
|| strcmp(TYPE_NAME(tp
), name
) != 0)
1464 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1465 ¤t_objfile
-> type_obstack
);
1468 /* Deal with range types */
1469 if (t
->bt
== btRange
) {
1470 TYPE_NFIELDS (tp
) = 2;
1472 (struct field
*) obstack_alloc (¤t_objfile
-> type_obstack
,
1473 2 * sizeof (struct field
));
1474 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1475 ¤t_objfile
-> type_obstack
);
1476 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1478 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1479 ¤t_objfile
-> type_obstack
);
1480 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1484 /* Parse all the type qualifiers now. If there are more
1485 than 6 the game will continue in the next aux */
1487 #define PARSE_TQ(tq) \
1488 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1490 again
: PARSE_TQ(tq0
);
1500 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1506 /* Make up a complex type from a basic one. Type is passed by
1507 reference in TPP and side-effected as necessary. The type
1508 qualifier TQ says how to handle the aux symbols at AX for
1509 the symbol SX we are currently analyzing. BIGEND says whether
1510 aux symbols are big-endian or little-endian.
1511 Returns the number of aux symbols we parsed. */
1514 upgrade_type(tpp
, tq
, ax
, bigend
)
1523 /* Used in array processing */
1532 t
= lookup_pointer_type (*tpp
);
1537 t
= lookup_function_type (*tpp
);
1543 t
= init_type(TYPE_CODE_ARRAY
, 0, 0, (char *) NULL
,
1544 (struct objfile
*) NULL
);
1545 TYPE_TARGET_TYPE(t
) = *tpp
;
1547 /* Determine and record the domain type (type of index) */
1548 ecoff_swap_rndx_in (bigend
, ax
, &rndx
);
1553 rf
= AUX_GET_ISYM (bigend
, ax
);
1556 fh
= get_rfd(cur_fd
, rf
);
1558 /* Fields are kept in an array */
1559 /* FIXME - Memory leak! */
1560 if (TYPE_NFIELDS(t
))
1561 TYPE_FIELDS(t
) = (struct field
*)
1562 xrealloc((PTR
) TYPE_FIELDS(t
),
1563 (TYPE_NFIELDS(t
)+1) * sizeof(struct field
));
1565 TYPE_FIELDS(t
) = (struct field
*)
1566 xzalloc(sizeof(struct field
));
1567 f
= &(TYPE_FIELD(t
,TYPE_NFIELDS(t
)));
1569 memset((PTR
)f
, 0, sizeof(struct field
));
1571 /* XXX */ f
->type
= parse_type(id
+ (union aux_ext
*)fh
->iauxBase
,
1572 &f
->bitsize
, bigend
);
1575 lower
= AUX_GET_DNLOW (bigend
, ax
);
1577 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1579 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1581 /* Check whether supplied array element bit size matches
1582 the known size of the element type. If this complaint
1583 ends up not happening, we can remove this code. It's
1584 here because we aren't sure we understand this *&%&$
1586 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1588 /* Most likely an undefined type */
1590 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1593 complain (&array_bitsize_complaint
, (char *)rf
);
1595 TYPE_LENGTH(t
) = (upper
< 0) ? 0 :
1596 (upper
- lower
+ 1) * (rf
>> 3);
1601 /* Volatile -- currently ignored */
1605 /* Const -- currently ignored */
1609 complain (&unknown_type_qual_complaint
, (char *)tq
);
1615 /* Parse a procedure descriptor record PR. Note that the procedure
1616 is parsed _after_ the local symbols, now we just insert the extra
1617 information we need into a special ".gdbinfo." symbol that has already
1618 been placed in the procedure's main block. Note also that images that
1619 have been partially stripped (ld -x) have been deprived
1620 of local symbols, and we have to cope with them here.
1621 The procedure's code ends at BOUND */
1624 parse_procedure (pr
, bound
, have_stabs
)
1629 struct symbol
*s
, *i
;
1630 SYMR
*sh
= (SYMR
*)pr
->isym
;
1632 struct mips_extra_func_info
*e
;
1636 /* Static procedure at address pr->adr. Sigh. */
1637 if (sh
== (SYMR
*)-1) {
1638 complain (&pdr_static_symbol_complaint
, (char *)pr
->adr
);
1641 sh_name
= (char*)sh
->iss
;
1643 s
= lookup_symbol(sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1645 s
= mylookup_symbol(sh_name
, top_stack
->cur_block
,
1646 VAR_NAMESPACE
, LOC_BLOCK
);
1649 b
= SYMBOL_BLOCK_VALUE(s
);
1651 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1655 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1656 s
= new_symbol(sh_name
);
1657 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1658 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1659 /* Donno its type, hope int is ok */
1660 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1661 add_symbol(s
, top_stack
->cur_block
);
1662 /* Wont have symbols for this one */
1664 SYMBOL_BLOCK_VALUE(s
) = b
;
1665 BLOCK_FUNCTION(b
) = s
;
1666 BLOCK_START(b
) = pr
->adr
;
1667 BLOCK_END(b
) = bound
;
1668 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1669 add_block(b
, top_stack
->cur_st
);
1673 i
= mylookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, LOC_CONST
);
1677 e
= (struct mips_extra_func_info
*)SYMBOL_VALUE(i
);
1679 e
->pdr
.isym
= (long)s
;
1683 /* Parse the external symbol ES. Just call parse_symbol() after
1684 making sure we know where the aux are for it. For procedures,
1685 parsing of the PDRs has already provided all the needed
1686 information, we only parse them if SKIP_PROCEDURES is false,
1687 and only if this causes no symbol duplication.
1688 BIGEND says whether aux entries are big-endian or little-endian.
1690 This routine clobbers top_stack->cur_block and ->cur_st. */
1693 parse_external(es
, skip_procedures
, bigend
)
1695 int skip_procedures
;
1700 if (es
->ifd
!= ifdNil
) {
1702 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1703 ax
= (union aux_ext
*)cur_fdr
->iauxBase
;
1705 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1709 /* Reading .o files */
1710 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1712 switch (es
->asym
.st
) {
1714 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1715 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1716 case stLabel
: what
= "label"; n_undef_labels
++; break;
1717 default : what
= "symbol"; break;
1720 /* FIXME: Turn this into a complaint? */
1722 printf_filtered("Warning: %s `%s' is undefined (in %s)\n",
1723 what
, es
->asym
.iss
, fdr_name((char *)cur_fdr
->rss
));
1727 switch (es
->asym
.st
) {
1729 /* If we have full symbols we do not need more */
1730 if (skip_procedures
)
1732 if (mylookup_symbol ((char *)es
->asym
.iss
, top_stack
->cur_block
,
1733 VAR_NAMESPACE
, LOC_BLOCK
))
1739 * Note that the case of a symbol with indexNil
1740 * must be handled anyways by parse_symbol().
1742 parse_symbol(&es
->asym
, ax
, bigend
);
1749 /* Parse the line number info for file descriptor FH into
1750 GDB's linetable LT. MIPS' encoding requires a little bit
1751 of magic to get things out. Note also that MIPS' line
1752 numbers can go back and forth, apparently we can live
1753 with that and do not need to reorder our linetables */
1758 struct linetable
*lt
;
1760 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1762 int delta
, count
, lineno
= 0;
1768 /* Scan by procedure descriptors */
1770 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1773 /* No code for this one */
1774 if (pr
->iline
== ilineNil
||
1775 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1778 * Aurgh! To know where to stop expanding we
1781 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1782 if (pr
[l
].iline
!= -1)
1784 if (l
== (fh
->cpd
- j
))
1789 * When procedures are moved around the linenumbers
1790 * are attributed to the next procedure up
1792 if (pr
->iline
>= halt
) continue;
1794 base
= (unsigned char*)pr
->cbLineOffset
;
1795 l
= pr
->adr
>> 2; /* in words */
1796 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1797 for (lineno
= pr
->lnLow
; l
< halt
;) {
1798 count
= *base
& 0x0f;
1799 delta
= *base
++ >> 4;
1803 delta
= (base
[0] << 8) | base
[1];
1804 if (delta
>= 0x8000)
1808 lineno
+= delta
;/* first delta is 0 */
1809 k
= add_line(lt
, lineno
, l
, k
);
1815 /* Master parsing procedure for first-pass reading of file symbols
1816 into a partial_symtab.
1818 Parses the symtab described by the global symbolic header CUR_HDR.
1819 END_OF_TEXT_SEG gives the address just after the text segment for
1820 the symtab we are reading. */
1823 parse_partial_symbols (end_of_text_seg
, objfile
)
1824 int end_of_text_seg
;
1825 struct objfile
*objfile
;
1828 HDRR
*hdr
= cur_hdr
;
1829 /* Running pointers */
1833 struct partial_symtab
*pst
;
1835 int past_first_source_file
= 0;
1837 /* List of current psymtab's include files */
1838 char **psymtab_include_list
;
1839 int includes_allocated
;
1842 struct pst_map
* fdr_to_pst
;
1843 /* Index within current psymtab dependency list */
1844 struct partial_symtab
**dependency_list
;
1845 int dependencies_used
, dependencies_allocated
;
1846 struct cleanup
*old_chain
;
1848 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1849 sizeof(EXTR
*) * hdr
->iextMax
);
1851 includes_allocated
= 30;
1853 psymtab_include_list
= (char **) alloca (includes_allocated
*
1855 next_symbol_text_func
= mips_next_symbol_text
;
1857 dependencies_allocated
= 30;
1858 dependencies_used
= 0;
1860 (struct partial_symtab
**) alloca (dependencies_allocated
*
1861 sizeof (struct partial_symtab
*));
1863 last_source_file
= 0;
1868 * Only parse the Local and External symbols, and the Relative FDR.
1869 * Fixup enough of the loader symtab to be able to use it.
1870 * Allocate space only for the file's portions we need to
1875 max_glevel
= MIN_GLEVEL
;
1877 /* Allocate the map FDR -> PST.
1878 Minor hack: -O3 images might claim some global data belongs
1879 to FDR -1. We`ll go along with that */
1880 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1881 old_chain
= make_cleanup (free
, fdr_to_pst
);
1884 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1885 fdr_to_pst
[-1].pst
= pst
;
1889 /* Pass 1 over external syms: Presize and partition the list */
1890 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1891 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1892 fdr_to_pst
[esh
->ifd
].n_globals
++;
1895 /* Pass 1.5 over files: partition out global symbol space */
1897 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1898 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1899 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1900 fdr_to_pst
[f_idx
].n_globals
= 0;
1903 /* Pass 2 over external syms: fill in external symbols */
1904 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1905 enum minimal_symbol_type ms_type
= mst_text
;
1906 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1908 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1909 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1911 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1914 switch (esh
->asym
.st
) {
1923 ms_type
= mst_unknown
;
1924 complain (&unknown_ext_complaint
, (char *)esh
->asym
.iss
);
1926 prim_record_minimal_symbol ((char *)esh
->asym
.iss
,
1931 /* Pass 3 over files, over local syms: fill in static symbols */
1932 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1933 struct partial_symtab
*save_pst
;
1935 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1937 if (fh
->csym
== 0) {
1938 fdr_to_pst
[f_idx
].pst
= NULL
;
1941 pst
= start_psymtab_common (objfile
, 0, (char*)fh
->rss
,
1942 fh
->cpd
? fh
->adr
: 0,
1943 objfile
->global_psymbols
.next
,
1944 objfile
->static_psymbols
.next
);
1945 pst
->read_symtab_private
= (char *)
1946 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1949 /* Make everything point to everything. */
1950 FDR_IDX(pst
) = f_idx
;
1951 fdr_to_pst
[f_idx
].pst
= pst
;
1952 fh
->ioptBase
= (int)pst
;
1954 CUR_HDR(pst
) = cur_hdr
;
1956 /* The way to turn this into a symtab is to call... */
1957 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1959 pst
->texthigh
= pst
->textlow
;
1961 #if 0 /* This is done in start_psymtab_common */
1962 pst
->globals_offset
= global_psymbols
.next
- global_psymbols
.list
;
1963 pst
->statics_offset
= static_psymbols
.next
- static_psymbols
.list
;
1965 pst
->n_global_syms
= 0;
1966 pst
->n_static_syms
= 0;
1969 /* The second symbol must be @stab.
1970 This symbol is emitted by mips-tfile to signal
1971 that the current object file uses encapsulated stabs
1972 instead of mips ecoff for local symbols.
1973 (It is the second symbol because the first symbol is
1974 the stFile used to signal the start of a file). */
1976 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
),
1977 stabs_symbol
) == 0) {
1978 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1981 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1982 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1983 if (!MIPS_IS_STAB(sh
)) {
1984 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
1985 long procaddr
= sh
->value
;
1986 sh
= AUX_GET_ISYM (fh
->fBigendian
,
1987 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
1988 + (SYMR
*) fh
->isymBase
- 1;
1989 if (sh
->st
== stEnd
) {
1990 long high
= procaddr
+ sh
->value
;
1991 if (high
> pst
->texthigh
)
1992 pst
->texthigh
= high
;
1997 #define SET_NAMESTRING() namestring = (char*)sh->iss
1998 #define CUR_SYMBOL_TYPE type_code
1999 #define CUR_SYMBOL_VALUE sh->value
2000 #define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
2002 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2003 #define addr 0 /* FIXME, should be offset of addresses */
2004 #define HANDLE_RBRAC(val) \
2005 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2006 #include "partial-stab.h"
2011 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2013 enum address_class
class;
2014 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2016 if (MIPS_IS_STAB(sh
)) {
2021 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
2022 sh
->index
== 0xfffff) {
2023 /* FIXME, premature? */
2028 name
= (char *)(sh
->iss
);
2035 case stProc
: /* Asm labels apparently */
2036 case stStaticProc
: /* Function */
2037 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2038 VAR_NAMESPACE
, LOC_BLOCK
,
2039 objfile
->static_psymbols
, sh
->value
);
2040 /* Skip over procedure to next one. */
2041 if (sh
->index
>= hdr
->iauxMax
)
2043 /* Should not happen, but does when cross-compiling
2044 with the MIPS compiler. FIXME -- pull later. */
2045 complain (&index_complaint
, name
);
2046 new_sdx
= cur_sdx
+1; /* Don't skip at all */
2049 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2050 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
2051 procaddr
= sh
->value
;
2053 if (new_sdx
<= cur_sdx
)
2055 /* This should not happen either... FIXME. */
2056 complain (&aux_index_complaint
, name
);
2057 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2061 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
2062 if (sh
->st
!= stEnd
)
2064 high
= procaddr
+ sh
->value
;
2065 if (high
> pst
->texthigh
)
2066 pst
->texthigh
= high
;
2069 case stStatic
: /* Variable */
2073 case stTypedef
: /* Typedef */
2074 class = LOC_TYPEDEF
;
2077 case stConstant
: /* Constant decl */
2084 case stBlock
: /* { }, str, un, enum*/
2085 if (sh
->sc
== scInfo
) {
2086 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2087 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2088 objfile
->static_psymbols
, sh
->value
);
2090 /* Skip over the block */
2091 cur_sdx
= sh
->index
;
2094 case stFile
: /* File headers */
2095 case stLabel
: /* Labels */
2096 case stEnd
: /* Ends of files */
2100 /* Both complaints are valid: one gives symbol name,
2101 the other the offending symbol type. */
2102 complain (&unknown_sym_complaint
, (char *)sh
->iss
);
2103 complain (&unknown_st_complaint
, (char *)sh
->st
);
2107 /* Use this gdb symbol */
2108 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2109 VAR_NAMESPACE
, class,
2110 objfile
->static_psymbols
, sh
->value
);
2112 cur_sdx
++; /* Go to next file symbol */
2115 /* Now do enter the external symbols. */
2116 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2117 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2118 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2119 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2120 for (; --cur_sdx
>= 0; ext_ptr
++) {
2121 register struct partial_symbol
*psym
;
2122 enum address_class
class;
2124 if ((*ext_ptr
)->ifd
!= f_idx
)
2126 sh
= &(*ext_ptr
)->asym
;
2135 complain (&unknown_ext_complaint
, (char *)sh
->iss
);
2136 /* Fall through, pretend it's global. */
2141 if (objfile
->global_psymbols
.next
>=
2142 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2143 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2144 psym
= objfile
->global_psymbols
.next
++;
2145 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2146 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2147 SYMBOL_CLASS (psym
) = class;
2148 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2152 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2153 -1, save_pst
->texthigh
,
2154 dependency_list
, dependencies_used
);
2155 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2156 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2158 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2159 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2163 /* Mark the last code address, and remember it for later */
2164 hdr
->cbDnOffset
= end_of_text_seg
;
2166 /* Now scan the FDRs for dependencies */
2167 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2169 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2170 pst
= fdr_to_pst
[f_idx
].pst
;
2172 /* This should catch stabs-in-ecoff. */
2176 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2177 /* ...then presumably a .h file: drop reverse depends .h->.c */
2178 for (; s_id0
< fh
->crfd
; s_id0
++) {
2179 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2181 s_id0
++; /* Skip self-dependency */
2186 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2187 pst
->dependencies
= (struct partial_symtab
**)
2188 obstack_alloc (&objfile
->psymbol_obstack
,
2189 pst
->number_of_dependencies
*
2190 sizeof (struct partial_symtab
*));
2191 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2192 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2193 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2194 complain(&bad_file_number_complaint
, (char *)*rh
);
2196 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2199 do_cleanups (old_chain
);
2204 /* Do the initial analisys of the F_IDX-th file descriptor.
2205 Allocates a partial symtab for it, and builds the list
2206 of dependent files by recursion. LEV says at which level
2207 of recursion we are called (to pretty up debug traces) */
2209 static struct partial_symtab
*
2210 parse_fdr(f_idx
, lev
, objfile
)
2213 struct objfile
*objfile
;
2216 register struct partial_symtab
*pst
;
2219 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2221 /* Use this to indicate into which symtab this file was parsed */
2223 return (struct partial_symtab
*) fh
->ioptBase
;
2225 /* Debuggability level */
2226 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2227 max_glevel
= fh
->glevel
;
2229 /* Make a new partial_symtab */
2230 pst
= new_psymtab(fh
->rss
, objfile
);
2235 pst
->textlow
= fh
->adr
;
2236 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2239 /* Make everything point to everything. */
2240 FDR_IDX(pst
) = f_idx
;
2241 fdr_to_pst
[f_idx
].pst
= pst
;
2242 fh
->ioptBase
= (int)pst
;
2244 /* Analyze its dependencies */
2249 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2250 /* ...then presumably a .h file: drop reverse depends .h->.c */
2251 for (; s_id0
< fh
->crfd
; s_id0
++) {
2252 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2254 s_id0
++; /* Skip self-dependency */
2259 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2260 pst
->dependencies
= (struct partial_symtab
**)
2261 obstack_alloc (&objfile
->psymbol_obstack
,
2262 pst
->number_of_dependencies
*
2263 sizeof (struct partial_symtab
*));
2264 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2265 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2267 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2275 mips_next_symbol_text ()
2278 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2281 /* Ancillary function to psymtab_to_symtab(). Does all the work
2282 for turning the partial symtab PST into a symtab, recurring
2283 first on all dependent psymtabs. The argument FILENAME is
2284 only passed so we can see in debug stack traces what file
2287 This function has a split personality, based on whether the
2288 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2289 The flow of control and even the memory allocation differs. FIXME. */
2292 psymtab_to_symtab_1(pst
, filename
)
2293 struct partial_symtab
*pst
;
2299 struct linetable
*lines
;
2306 /* Read in all partial symbtabs on which this one is dependent.
2307 NOTE that we do have circular dependencies, sigh. We solved
2308 that by setting pst->readin before this point. */
2310 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2311 if (!pst
->dependencies
[i
]->readin
) {
2312 /* Inform about additional files to be read in. */
2315 fputs_filtered (" ", stdout
);
2317 fputs_filtered ("and ", stdout
);
2319 printf_filtered ("%s...",
2320 pst
->dependencies
[i
]->filename
);
2321 wrap_here (""); /* Flush output */
2324 /* We only pass the filename for debug purposes */
2325 psymtab_to_symtab_1(pst
->dependencies
[i
],
2326 pst
->dependencies
[i
]->filename
);
2329 /* Now read the symbols for this symtab */
2331 current_objfile
= pst
->objfile
;
2332 cur_fd
= FDR_IDX(pst
);
2333 fh
= (cur_fd
== -1) ? 0 : (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2336 /* BOUND is the highest core address of this file's procedures */
2337 bound
= (cur_fd
== cur_hdr
->ifdMax
- 1) ?
2338 cur_hdr
->cbDnOffset
:
2341 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2342 if (fh
&& fh
->csym
>= 2
2343 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)
2347 * This symbol table contains stabs-in-ecoff entries.
2353 /* Parse local symbols first */
2355 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2357 current_objfile
= NULL
;
2360 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2361 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2362 char *name
= (char*)sh
->iss
;
2363 CORE_ADDR valu
= sh
->value
;
2364 if (MIPS_IS_STAB(sh
)) {
2365 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2366 process_one_symbol (type_code
, 0, valu
, name
, /*FIXME*/ 0,
2368 if (type_code
== N_FUN
) {
2369 /* Make up special symbol to contain
2370 procedure specific info */
2371 struct mips_extra_func_info
*e
=
2372 (struct mips_extra_func_info
*)
2373 obstack_alloc(¤t_objfile
->symbol_obstack
,
2374 sizeof(struct mips_extra_func_info
));
2375 struct symbol
*s
= new_symbol(".gdbinfo.");
2376 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2377 SYMBOL_CLASS(s
) = LOC_CONST
;
2378 SYMBOL_TYPE(s
) = builtin_type_void
;
2379 SYMBOL_VALUE(s
) = (int)e
;
2380 add_symbol_to_list (s
, &local_symbols
);
2383 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2384 /* Handle encoded stab line number. */
2385 record_line (current_subfile
, sh
->index
, valu
);
2387 else complain (&stab_unknown_complaint
, (char *)sh
->iss
);
2389 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2391 /* Sort the symbol table now, we are done adding symbols to it.
2392 We must do this before parse_procedure calls lookup_symbol. */
2393 sort_symtab_syms(st
);
2395 /* This may not be necessary for stabs symtabs. FIXME. */
2398 /* Fill in procedure info next. We need to look-ahead to
2399 find out where each procedure's code ends. */
2401 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2402 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2403 parse_procedure (pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 1);
2408 * This symbol table contains ordinary ecoff entries.
2415 /* How many symbols will we need */
2416 /* FIXME, this does not count enum values. */
2417 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2420 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2422 f_max
+= fh
->csym
+ fh
->cpd
;
2423 maxlines
= 2 * fh
->cline
;
2424 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2427 lines
= LINETABLE(st
);
2428 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2429 if (pending_list
== 0) {
2430 pending_list
= (struct mips_pending
**)
2431 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2432 cur_hdr
->cbOptOffset
= (int)pending_list
;
2435 /* Get a new lexical context */
2438 top_stack
->cur_st
= st
;
2439 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(st
),
2441 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2442 BLOCK_END(top_stack
->cur_block
) = 0;
2443 top_stack
->blocktype
= stFile
;
2444 top_stack
->maxsyms
= 2*f_max
;
2445 top_stack
->cur_type
= 0;
2446 top_stack
->procadr
= 0;
2447 top_stack
->numargs
= 0;
2453 /* Parse local symbols first */
2455 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2456 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2457 cur_sdx
+= parse_symbol(sh
, (union aux_ent
*)fh
->iauxBase
,
2461 /* Linenumbers. At the end, check if we can save memory */
2463 parse_lines(fh
, lines
);
2464 if (lines
->nitems
< fh
->cline
)
2465 lines
= shrink_linetable(lines
);
2467 /* Fill in procedure info next. We need to look-ahead to
2468 find out where each procedure's code ends. */
2470 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2471 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2472 parse_procedure(pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 0);
2476 LINETABLE(st
) = lines
;
2478 /* .. and our share of externals.
2479 XXX use the global list to speed up things here. how?
2480 FIXME, Maybe quit once we have found the right number of ext's? */
2481 top_stack
->cur_st
= st
;
2482 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
2484 top_stack
->blocktype
= stFile
;
2485 top_stack
->maxsyms
=
2486 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2488 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2489 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2490 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2492 /* If there are undefined, tell the user */
2493 if (n_undef_symbols
) {
2494 printf_filtered("File %s contains %d unresolved references:",
2495 st
->filename
, n_undef_symbols
);
2496 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2497 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2498 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2503 /* Sort the symbol table now, we are done adding symbols to it.*/
2504 sort_symtab_syms(st
);
2509 /* Now link the psymtab and the symtab. */
2512 current_objfile
= NULL
;
2515 /* Ancillary parsing procedures. */
2517 /* Lookup the type at relative index RN. Return it in TPP
2518 if found and in any event come up with its name PNAME.
2519 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2520 Return value says how many aux symbols we ate. */
2523 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2526 enum type_code type_code
; /* Use to alloc new type if none is found. */
2534 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2536 /* Escape index means 'the next one' */
2537 if (rn
->rfd
== 0xfff) {
2539 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2546 *pname
= "<undefined>";
2549 * Find the relative file descriptor and the symbol in it
2551 FDR
*fh
= get_rfd(cur_fd
, rf
);
2556 * If we have processed this symbol then we left a forwarding
2557 * pointer to the corresponding GDB symbol. If not, we`ll put
2558 * it in a list of pending symbols, to be processed later when
2559 * the file f will be. In any event, we collect the name for
2560 * the type here. Which is why we made a first pass at
2563 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2565 /* Careful, we might be looking at .o files */
2566 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2569 /* Have we parsed it ? */
2570 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2571 t
= (struct type
*) sh
->value
;
2574 /* Avoid duplicates */
2575 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2579 *tpp
= init_type(type_code
, 0, 0, (char *) NULL
,
2580 (struct objfile
*) NULL
);
2581 add_pending(fh
, sh
, *tpp
);
2586 /* We used one auxent normally, two if we got a "next one" rf. */
2591 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2592 keeping the symtab sorted */
2594 static struct symbol
*
2595 mylookup_symbol (name
, block
, namespace, class)
2597 register struct block
*block
;
2598 enum namespace namespace;
2599 enum address_class
class;
2601 register int bot
, top
, inc
;
2602 register struct symbol
*sym
;
2605 top
= BLOCK_NSYMS(block
);
2608 sym
= BLOCK_SYM(block
, bot
);
2609 if (SYMBOL_NAME(sym
)[0] == inc
2610 && SYMBOL_NAMESPACE(sym
) == namespace
2611 && SYMBOL_CLASS(sym
) == class
2612 && !strcmp(SYMBOL_NAME(sym
), name
))
2616 block
= BLOCK_SUPERBLOCK (block
);
2618 return mylookup_symbol (name
, block
, namespace, class);
2623 /* Add a new symbol S to a block B.
2624 Infrequently, we will need to reallocate the block to make it bigger.
2625 We only detect this case when adding to top_stack->cur_block, since
2626 that's the only time we know how big the block is. FIXME. */
2633 int nsyms
= BLOCK_NSYMS(b
)++;
2634 struct block
*origb
;
2635 struct parse_stack
*stackp
;
2637 if (b
== top_stack
->cur_block
&&
2638 nsyms
>= top_stack
->maxsyms
) {
2639 complain (&block_overflow_complaint
, s
->name
);
2640 /* In this case shrink_block is actually grow_block, since
2641 BLOCK_NSYMS(b) is larger than its current size. */
2643 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2645 /* Now run through the stack replacing pointers to the
2646 original block. shrink_block has already done this
2647 for the blockvector and BLOCK_FUNCTION. */
2648 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2649 if (stackp
->cur_block
== origb
) {
2650 stackp
->cur_block
= b
;
2651 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2655 BLOCK_SYM(b
,nsyms
) = s
;
2658 /* Add a new block B to a symtab S */
2665 struct blockvector
*bv
= BLOCKVECTOR(s
);
2667 bv
= (struct blockvector
*)xrealloc((PTR
) bv
,
2668 sizeof(struct blockvector
) +
2669 BLOCKVECTOR_NBLOCKS(bv
)
2670 * sizeof(bv
->block
));
2671 if (bv
!= BLOCKVECTOR(s
))
2672 BLOCKVECTOR(s
) = bv
;
2674 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2677 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2678 MIPS' linenumber encoding might need more than one byte
2679 to describe it, LAST is used to detect these continuation lines */
2682 add_line(lt
, lineno
, adr
, last
)
2683 struct linetable
*lt
;
2689 last
= -2; /* make sure we record first line */
2691 if (last
== lineno
) /* skip continuation lines */
2694 lt
->item
[lt
->nitems
].line
= lineno
;
2695 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2699 /* Sorting and reordering procedures */
2701 /* Blocks with a smaller low bound should come first */
2704 compare_blocks(arg1
, arg2
)
2705 const void *arg1
, *arg2
;
2707 register int addr_diff
;
2708 struct block
**b1
= (struct block
**) arg1
;
2709 struct block
**b2
= (struct block
**) arg2
;
2711 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2713 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2717 /* Sort the blocks of a symtab S.
2718 Reorder the blocks in the blockvector by code-address,
2719 as required by some MI search routines */
2725 struct blockvector
*bv
= BLOCKVECTOR(s
);
2727 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2729 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2730 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2731 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2732 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2736 * This is very unfortunate: normally all functions are compiled in
2737 * the order they are found, but if the file is compiled -O3 things
2738 * are very different. It would be nice to find a reliable test
2739 * to detect -O3 images in advance.
2741 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2742 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2743 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2744 sizeof(struct block
*),
2748 register CORE_ADDR high
= 0;
2749 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2751 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2752 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2753 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2754 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2757 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2758 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2760 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2761 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2762 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2763 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2767 /* Constructor/restructor/destructor procedures */
2769 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2770 MAXSYMS and linenumbers MAXLINES we'll put in it */
2772 static struct symtab
*
2773 new_symtab(name
, maxsyms
, maxlines
, objfile
)
2777 struct objfile
*objfile
;
2779 struct symtab
*s
= allocate_symtab (name
, objfile
);
2781 LINETABLE(s
) = new_linetable(maxlines
);
2783 /* All symtabs must have at least two blocks */
2784 BLOCKVECTOR(s
) = new_bvect(2);
2785 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2786 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2787 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2788 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2790 s
->free_code
= free_linetable
;
2795 /* Allocate a new partial_symtab NAME */
2797 static struct partial_symtab
*
2798 new_psymtab(name
, objfile
)
2800 struct objfile
*objfile
;
2802 struct partial_symtab
*psymtab
;
2804 /* FIXME -- why (char *) -1 rather than NULL? */
2805 psymtab
= allocate_psymtab (name
== (char *) -1 ? "<no name>" : name
,
2808 /* Keep a backpointer to the file's symbols */
2810 psymtab
-> read_symtab_private
= (char *)
2811 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2812 CUR_HDR(psymtab
) = cur_hdr
;
2814 /* The way to turn this into a symtab is to call... */
2815 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
2820 /* Allocate a linetable array of the given SIZE. Since the struct
2821 already includes one item, we subtract one when calculating the
2822 proper size to allocate. */
2824 static struct linetable
*
2828 struct linetable
*l
;
2830 size
= (size
-1) * sizeof(l
->item
) + sizeof(struct linetable
);
2831 l
= (struct linetable
*)xmalloc(size
);
2836 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2837 I am not so sure about the 3.4 ones.
2839 Since the struct linetable already includes one item, we subtract one when
2840 calculating the proper size to allocate. */
2842 static struct linetable
*
2843 shrink_linetable(lt
)
2844 struct linetable
* lt
;
2847 return (struct linetable
*) xrealloc ((PTR
)lt
,
2848 sizeof(struct linetable
)
2849 + (lt
->nitems
- 1) * sizeof(lt
->item
));
2852 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2854 static struct blockvector
*
2858 struct blockvector
*bv
;
2861 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2862 bv
= (struct blockvector
*) xzalloc(size
);
2864 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2869 /* Allocate and zero a new block of MAXSYMS symbols */
2871 static struct block
*
2875 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2877 return (struct block
*)xzalloc (size
);
2880 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2881 Shrink_block can also be used by add_symbol to grow a block. */
2883 static struct block
*
2889 struct blockvector
*bv
= BLOCKVECTOR(s
);
2892 /* Just reallocate it and fix references to the old one */
2894 new = (struct block
*) xrealloc ((PTR
)b
, sizeof(struct block
) +
2895 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2897 /* Should chase pointers to old one. Fortunately, that`s just
2898 the block`s function and inferior blocks */
2899 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2900 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2901 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2902 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2903 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2904 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2905 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2909 /* Create a new symbol with printname NAME */
2911 static struct symbol
*
2915 struct symbol
*s
= (struct symbol
*)
2916 obstack_alloc (¤t_objfile
->symbol_obstack
, sizeof (struct symbol
));
2918 memset ((PTR
)s
, 0, sizeof (*s
));
2919 SYMBOL_NAME(s
) = name
;
2923 /* Create a new type with printname NAME */
2925 static struct type
*
2931 t
= alloc_type (current_objfile
);
2932 TYPE_NAME(t
) = name
;
2933 TYPE_CPLUS_SPECIFIC(t
) = (struct cplus_struct_type
*)
2934 &cplus_struct_default
;
2939 /* Things used for calling functions in the inferior.
2940 These functions are exported to our companion
2941 mips-tdep.c file and are here because they play
2942 with the symbol-table explicitly. */
2944 /* Sigtramp: make sure we have all the necessary information
2945 about the signal trampoline code. Since the official code
2946 from MIPS does not do so, we make up that information ourselves.
2947 If they fix the library (unlikely) this code will neutralize itself. */
2954 struct block
*b
, *b0
;
2956 sigtramp_address
= -1;
2958 /* We know it is sold as sigvec */
2959 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2961 /* Most programs do not play with signals */
2963 s
= lookup_symbol("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
2966 b0
= SYMBOL_BLOCK_VALUE(s
);
2968 /* A label of sigvec, to be more precise */
2969 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
2972 /* But maybe this program uses its own version of sigvec */
2976 /* Did we or MIPSco fix the library ? */
2977 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
2979 sigtramp_address
= BLOCK_START(SYMBOL_BLOCK_VALUE(s
));
2980 sigtramp_end
= BLOCK_END(SYMBOL_BLOCK_VALUE(s
));
2984 sigtramp_address
= SYMBOL_VALUE(s
);
2985 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
2987 /* But what symtab does it live in ? */
2988 st
= find_pc_symtab(SYMBOL_VALUE(s
));
2991 * Ok, there goes the fix: turn it into a procedure, with all the
2992 * needed info. Note we make it a nested procedure of sigvec,
2993 * which is the way the (assembly) code is actually written.
2995 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
2996 SYMBOL_CLASS(s
) = LOC_BLOCK
;
2997 SYMBOL_TYPE(s
) = init_type(TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
2998 (struct objfile
*) NULL
);
2999 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
3001 /* Need a block to allocate .gdbinfo. in */
3003 SYMBOL_BLOCK_VALUE(s
) = b
;
3004 BLOCK_START(b
) = sigtramp_address
;
3005 BLOCK_END(b
) = sigtramp_end
;
3006 BLOCK_FUNCTION(b
) = s
;
3007 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
3011 /* Make a .gdbinfo. for it */
3013 struct mips_extra_func_info
*e
=
3014 (struct mips_extra_func_info
*)
3015 xzalloc(sizeof(struct mips_extra_func_info
));
3017 e
->numargs
= 0; /* the kernel thinks otherwise */
3018 /* align_longword(sigcontext + SIGFRAME) */
3019 e
->pdr
.frameoffset
= 0x150;
3020 e
->pdr
.framereg
= SP_REGNUM
;
3022 e
->pdr
.regmask
= -2;
3023 e
->pdr
.regoffset
= -(41 * sizeof(int));
3024 e
->pdr
.fregmask
= -1;
3025 e
->pdr
.fregoffset
= -(37 * sizeof(int));
3026 e
->pdr
.isym
= (long)s
;
3028 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3029 s
= new_symbol(".gdbinfo.");
3030 SYMBOL_VALUE(s
) = (int) e
;
3031 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
3032 SYMBOL_CLASS(s
) = LOC_CONST
;
3033 SYMBOL_TYPE(s
) = builtin_type_void
;
3034 current_objfile
= NULL
;
3037 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
3040 /* Initialization */
3042 static struct sym_fns ecoff_sym_fns
=
3044 "ecoff", /* sym_name: name or name prefix of BFD target type */
3045 5, /* sym_namelen: number of significant sym_name chars */
3046 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3047 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
3048 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
3049 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
3050 NULL
/* next: pointer to next struct sym_fns */
3055 _initialize_mipsread ()
3057 add_symtab_fns (&ecoff_sym_fns
);
3059 /* Missing basic types */
3061 builtin_type_string
=
3062 init_type(TYPE_CODE_PASCAL_ARRAY
,
3063 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3065 (struct objfile
*) NULL
);
3066 builtin_type_complex
=
3067 init_type(TYPE_CODE_FLT
,
3068 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3070 (struct objfile
*) NULL
);
3071 builtin_type_double_complex
=
3072 init_type(TYPE_CODE_FLT
,
3073 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3074 0, "double complex",
3075 (struct objfile
*) NULL
);
3076 builtin_type_fixed_dec
=
3077 init_type(TYPE_CODE_INT
,
3078 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3080 (struct objfile
*) NULL
);
3081 builtin_type_float_dec
=
3082 init_type(TYPE_CODE_FLT
,
3083 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3084 0, "floating decimal",
3085 (struct objfile
*) NULL
);