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/sym.h" /* Symbol structures in ecoff files */
73 #include "coff/symconst.h" /* Manifest constants in ecoff sym structures */
74 #include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
76 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
77 #include "aout/aout64.h"
78 #include "aout/stab_gnu.h" /* STABS information */
81 struct external_filehdr f
;
82 struct external_aouthdr a
;
85 /* These must match the corresponding definition in gcc/config/xm-mips.h.
86 At some point, these should probably go into a shared include file,
87 but currently gcc and gdb do not share any directories. */
89 #define CODE_MASK 0x8F300
90 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
91 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
92 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
93 #define STABS_SYMBOL "@stabs"
95 /* Each partial symbol table entry contains a pointer to private data for the
96 read_symtab() function to use when expanding a partial symbol table entry
97 to a full symbol table entry.
99 For mipsread this structure contains the index of the FDR that this psymtab
100 represents and a pointer to the symbol table header HDRR from the symbol
101 file that the psymtab was created from. */
103 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
104 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
105 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
110 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
111 int extern_count
; /* Size of extern_tab. */
114 /* Things we import explicitly from other modules */
116 extern int info_verbose
;
118 /* Various complaints about symbol reading that don't abort the process */
120 struct complaint bad_file_number_complaint
=
121 {"bad file number %d", 0, 0};
123 struct complaint index_complaint
=
124 {"bad aux index at symbol %s", 0, 0};
126 struct complaint aux_index_complaint
=
127 {"bad proc end in aux found from symbol %s", 0, 0};
129 struct complaint unknown_ext_complaint
=
130 {"unknown external symbol %s", 0, 0};
132 struct complaint unknown_sym_complaint
=
133 {"unknown local symbol %s", 0, 0};
135 struct complaint unknown_st_complaint
=
136 {"with type %d", 0, 0};
138 struct complaint block_overflow_complaint
=
139 {"block containing %s overfilled", 0, 0};
141 struct complaint basic_type_complaint
=
142 {"cannot map MIPS basic type 0x%x", 0, 0};
144 struct complaint unknown_type_qual_complaint
=
145 {"unknown type qualifier 0x%x", 0, 0};
147 struct complaint array_bitsize_complaint
=
148 {"size of array target type not known, assuming %d bits", 0, 0};
150 struct complaint bad_tag_guess_complaint
=
151 {"guessed tag type of %s incorrectly", 0, 0};
153 struct complaint block_member_complaint
=
154 {"declaration block contains unhandled symbol type %d", 0, 0};
156 struct complaint stEnd_complaint
=
157 {"stEnd with storage class %d not handled", 0, 0};
159 struct complaint unknown_mips_symtype_complaint
=
160 {"unknown symbol type 0x%x", 0, 0};
162 struct complaint stab_unknown_complaint
=
163 {"unknown stabs symbol %s", 0, 0};
165 struct complaint pdr_for_nonsymbol_complaint
=
166 {"PDR for %s, but no symbol", 0, 0};
168 struct complaint pdr_static_symbol_complaint
=
169 {"can't handle PDR for static proc at 0x%x", 0, 0};
171 /* Macros and extra defs */
173 /* Already-parsed symbols are marked specially */
175 #define stParsed stType
177 /* Puns: hard to find whether -g was used and how */
179 #define MIN_GLEVEL GLEVEL_0
180 #define compare_glevel(a,b) \
181 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
182 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
184 /* When looking at .o files, avoid tripping over bad addresses */
186 #define SAFE_TEXT_ADDR 0x400000
187 #define SAFE_DATA_ADDR 0x10000000
189 #define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR)
191 /* Things that really are local to this module */
193 /* MIPS symtab header for the current file */
195 static HDRR
*cur_hdr
;
197 /* Pointer to current file decriptor record, and its index */
202 /* Index of current symbol */
206 /* Note how much "debuggable" this image is. We would like
207 to see at least one FDR with full symbols */
212 /* When examining .o files, report on undefined symbols */
214 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
216 /* Pseudo symbol to use when putting stabs into the symbol table. */
218 static char stabs_symbol
[] = STABS_SYMBOL
;
220 /* Extra builtin types */
222 struct type
*builtin_type_complex
;
223 struct type
*builtin_type_double_complex
;
224 struct type
*builtin_type_fixed_dec
;
225 struct type
*builtin_type_float_dec
;
226 struct type
*builtin_type_string
;
228 /* Forward declarations */
231 fixup_symtab
PARAMS ((HDRR
*, char *, int, bfd
*));
234 read_mips_symtab
PARAMS ((struct objfile
*));
237 read_the_mips_symtab
PARAMS ((bfd
*, CORE_ADDR
*));
240 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
243 parse_partial_symbols
PARAMS ((int, struct objfile
*));
246 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
250 fixup_sigtramp
PARAMS ((void));
252 static struct symbol
*
253 new_symbol
PARAMS ((char *));
256 new_type
PARAMS ((char *));
258 static struct block
*
259 new_block
PARAMS ((int));
261 static struct symtab
*
262 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
264 static struct linetable
*
265 new_linetable
PARAMS ((int));
267 static struct blockvector
*
268 new_bvect
PARAMS ((int));
271 parse_type
PARAMS ((union aux_ext
*, int *, int));
273 static struct symbol
*
274 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
275 enum address_class
));
277 static struct block
*
278 shrink_block
PARAMS ((struct block
*, struct symtab
*));
281 xzalloc
PARAMS ((unsigned int));
284 sort_blocks
PARAMS ((struct symtab
*));
287 compare_blocks
PARAMS ((const void *, const void *));
289 static struct partial_symtab
*
290 new_psymtab
PARAMS ((char *, struct objfile
*));
293 static struct partial_symtab
*
294 parse_fdr
PARAMS ((int, int, struct objfile
*));
298 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
301 add_block
PARAMS ((struct block
*, struct symtab
*));
304 add_symbol
PARAMS ((struct symbol
*, struct block
*));
307 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
309 static struct linetable
*
310 shrink_linetable
PARAMS ((struct linetable
*));
313 mips_next_symbol_text
PARAMS ((void));
315 /* Things we export to other modules */
317 /* Address bounds for the signal trampoline in inferior, if any */
318 /* FIXME: Nothing really seems to use this. Why is it here? */
320 CORE_ADDR sigtramp_address
, sigtramp_end
;
323 mipscoff_new_init (ignore
)
324 struct objfile
*ignore
;
329 mipscoff_symfile_init (objfile
)
330 struct objfile
*objfile
;
332 if (objfile
-> sym_private
!= NULL
)
334 mfree (objfile
-> md
, objfile
-> sym_private
);
336 objfile
-> sym_private
= NULL
;
340 mipscoff_symfile_read (objfile
, addr
, mainline
)
341 struct objfile
*objfile
;
345 bfd
*abfd
= objfile
-> obfd
;
347 init_minimal_symbol_collection ();
348 make_cleanup (discard_minimal_symbols
, 0);
350 /* Now that the executable file is positioned at symbol table,
351 process it and define symbols accordingly. */
353 read_mips_symtab(objfile
);
355 /* Install any minimal symbols that have been collected as the current
356 minimal symbols for this objfile. */
358 install_minimal_symbols (objfile
);
361 /* Perform any local cleanups required when we are done with a particular
362 objfile. I.E, we are in the process of discarding all symbol information
363 for an objfile, freeing up all memory held for it, and unlinking the
364 objfile struct from the global list of known objfiles. */
367 mipscoff_symfile_finish (objfile
)
368 struct objfile
*objfile
;
370 if (objfile
-> sym_private
!= NULL
)
372 mfree (objfile
-> md
, objfile
-> sym_private
);
375 /* If we have a file symbol header lying around, blow it away. */
384 /* Allocate zeroed memory */
390 PTR p
= xmalloc(size
);
396 /* Exported procedure: Builds a symtab from the PST partial one.
397 Restores the environment in effect when PST was created, delegates
398 most of the work to an ancillary procedure, and sorts
399 and reorders the symtab list at the end */
402 mipscoff_psymtab_to_symtab(pst
)
403 struct partial_symtab
*pst
;
410 printf_filtered("Reading in symbols for %s...", pst
->filename
);
413 /* Restore the header and list of pending typedefs */
414 cur_hdr
= CUR_HDR(pst
);
416 next_symbol_text_func
= mips_next_symbol_text
;
418 psymtab_to_symtab_1(pst
, pst
->filename
);
420 /* Match with global symbols. This only needs to be done once,
421 after all of the symtabs and dependencies have been read in. */
422 scan_file_globals (pst
->objfile
);
425 printf_filtered("done.\n");
428 /* Exported procedure: Is PC in the signal trampoline code */
431 in_sigtramp(pc
, ignore
)
433 char *ignore
; /* function name */
435 if (sigtramp_address
== 0)
437 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
440 /* File-level interface functions */
442 /* Read the symtab information from file ABFD into memory. Also,
443 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
446 read_the_mips_symtab(abfd
, end_of_text_segp
)
448 CORE_ADDR
*end_of_text_segp
;
450 int stsize
, st_hdrsize
;
452 struct hdr_ext hdr_ext
;
454 /* Header for executable/object file we read symbols from */
455 struct coff_exec filhdr
;
458 /* We need some info from the initial headers */
459 val
= bfd_seek(abfd
, 0L, L_SET
);
460 val
= bfd_read((PTR
)&filhdr
, sizeof filhdr
, 1, abfd
);
462 if (end_of_text_segp
)
464 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
465 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
467 /* Find and read the symbol table header */
468 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
469 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
473 bfd_seek (abfd
, st_filptr
, L_SET
);
474 if (st_hdrsize
!= sizeof (hdr_ext
)) { /* Profanity check */
475 error ("Wrong header size: %d, not %d", st_hdrsize
,
478 if (bfd_read((PTR
)&hdr_ext
, st_hdrsize
, 1, abfd
) != st_hdrsize
)
480 ecoff_swap_hdr_in (abfd
, &hdr_ext
, &st_hdr
);
482 /* Find out how large the symbol table is */
483 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
484 + st_hdr
.iextMax
* cbEXTR
;
486 /* Allocate space for the symbol table. Read it in. */
487 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
489 memcpy((PTR
)cur_hdr
, (PTR
)&hdr_ext
, st_hdrsize
);
490 if (bfd_read((char *)cur_hdr
+ st_hdrsize
, stsize
, 1, abfd
) != stsize
)
493 /* Fixup file_pointers in it */
494 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
495 st_filptr
+ st_hdrsize
, abfd
);
499 error("Short read on %s", bfd_get_filename (abfd
));
503 /* Turn all file-relative pointers in the symtab described by HDR
504 into memory pointers, given that the symtab itself is located
505 at DATA in memory and F_PTR in the file.
507 Byte-swap all the data structures, in place, while we are at it --
508 except AUX entries, which we leave in their original byte order.
509 They will be swapped as they are used instead. (FIXME: we ought to
510 do all the data structures that way.) */
513 fixup_symtab (hdr
, data
, f_ptr
, abfd
)
524 struct rfd_ext
*rbase
;
526 /* This function depends on the external and internal forms
527 of the MIPS symbol table taking identical space. Check this
528 assumption at compile-time. */
529 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
530 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
531 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
532 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
533 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
534 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
535 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
536 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
537 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
538 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
539 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
540 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
542 /* Swap in the header record. */
543 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
546 * These fields are useless (and empty) by now:
547 * hdr->cbDnOffset, hdr->cbOptOffset
548 * We use them for other internal purposes.
551 hdr
->cbOptOffset
= 0;
554 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
568 /* Fix all the RFD's. */
569 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
570 for (i
= 0; i
< hdr
->crfd
; i
++) {
571 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
574 /* Fix all string pointers inside the symtab, and
575 the FDR records. Also fix other miscellany. */
577 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
578 register unsigned code_offset
;
580 /* Header itself, and strings */
581 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
583 /* Swap in the FDR */
584 ecoff_swap_fdr_in (abfd
, fh
, fh
);
586 fh
->issBase
+= hdr
->cbSsOffset
;
588 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
591 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
593 /* FIXME! Probably don't want to do this here! */
594 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
595 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
596 ecoff_swap_sym_in (abfd
, sh
, sh
);
598 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
604 /* cannot fix fh->ipdFirst because it is a short */
605 #define IPDFIRST(h,fh) \
606 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
608 /* Optional symbols (actually used for partial_symtabs) */
614 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
615 /* Relative file descriptor table */
616 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
620 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
622 /* Procedure symbols. (XXX This should be done later) */
623 code_offset
= fh
->adr
;
624 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
625 unsigned name
, only_ext
;
627 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
628 ecoff_swap_pdr_in (abfd
, pr
, pr
);
630 /* Simple rule to find files linked "-x" */
631 only_ext
= fh
->rss
== -1;
633 if (pr
->isym
== -1) {
634 /* static function */
638 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
639 sh
= &((EXTR
*)name
)->asym
;
643 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
644 /* Included code ? */
645 if (s_idx
== 0 && pr
->adr
!= 0)
646 code_offset
-= pr
->adr
;
649 /* Turn index into a pointer */
652 /* Fix line numbers */
653 pr
->cbLineOffset
+= fh
->cbLineOffset
;
655 /* Relocate address */
657 pr
->adr
+= code_offset
;
661 /* External symbols: swap in, and fix string */
662 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
663 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
664 ecoff_swap_ext_in (abfd
, esh
, esh
);
665 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
670 /* Find a file descriptor given its index RF relative to a file CF */
678 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
679 /* Object files do not have the RFD table, all refs are absolute */
681 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
682 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
683 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
686 /* Return a safer print NAME for a file descriptor */
692 if (name
== (char *) -1)
693 return "<stripped file>";
694 if (UNSAFE_DATA_ADDR(name
))
700 /* Read in and parse the symtab of the file DESC. INCREMENTAL says
701 whether we are adding to the general symtab or not.
702 FIXME: INCREMENTAL is currently always zero, though it should not be. */
705 read_mips_symtab (objfile
)
706 struct objfile
*objfile
;
708 CORE_ADDR end_of_text_seg
;
710 read_the_mips_symtab(objfile
->obfd
, &end_of_text_seg
);
712 parse_partial_symbols(end_of_text_seg
, objfile
);
716 * Check to make sure file was compiled with -g.
717 * If not, warn the user of this limitation.
719 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
720 if (max_gdbinfo
== 0)
722 "\n%s not compiled with -g, debugging support is limited.\n",
725 "You should compile with -g2 or -g3 for best debugging support.\n");
731 /* Local utilities */
733 /* Map of FDR indexes to partial symtabs */
736 struct partial_symtab
*pst
; /* the psymtab proper */
737 int n_globals
; /* exported globals (external symbols) */
738 int globals_offset
; /* cumulative */
742 /* Utility stack, used to nest procedures and blocks properly.
743 It is a doubly linked list, to avoid too many alloc/free.
744 Since we might need it quite a few times it is NOT deallocated
747 static struct parse_stack
{
748 struct parse_stack
*next
, *prev
;
749 struct symtab
*cur_st
; /* Current symtab. */
750 struct block
*cur_block
; /* Block in it. */
751 int blocktype
; /* What are we parsing. */
752 int maxsyms
; /* Max symbols in this block. */
753 struct type
*cur_type
; /* Type we parse fields for. */
754 int cur_field
; /* Field number in cur_type. */
755 int procadr
; /* Start addres of this procedure */
756 int numargs
; /* Its argument count */
757 } *top_stack
; /* Top stack ptr */
760 /* Enter a new lexical context */
765 struct parse_stack
*new;
767 /* Reuse frames if possible */
768 if (top_stack
&& top_stack
->prev
)
769 new = top_stack
->prev
;
771 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
772 /* Initialize new frame with previous content */
774 register struct parse_stack
*prev
= new->prev
;
777 top_stack
->prev
= new;
779 new->next
= top_stack
;
784 /* Exit a lexical context */
792 top_stack
= top_stack
->next
;
796 /* Cross-references might be to things we haven't looked at
797 yet, e.g. type references. To avoid too many type
798 duplications we keep a quick fixup table, an array
799 of lists of references indexed by file descriptor */
801 static struct mips_pending
{
802 struct mips_pending
*next
; /* link */
803 SYMR
*s
; /* the symbol */
804 struct type
*t
; /* its partial type descriptor */
808 /* Check whether we already saw symbol SH in file FH as undefined */
810 static struct mips_pending
*
811 is_pending_symbol(fh
, sh
)
815 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
816 register struct mips_pending
*p
;
818 /* Linear search is ok, list is typically no more than 10 deep */
819 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
825 /* Add a new undef symbol SH of type T */
828 add_pending(fh
, sh
, t
)
833 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
834 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
836 /* Make sure we do not make duplicates */
838 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
841 p
->next
= pending_list
[f_idx
];
842 pending_list
[f_idx
] = p
;
844 sh
->reserved
= 1; /* for quick check */
847 /* Throw away undef entries when done with file index F_IDX */
848 /* FIXME -- storage leak. This is never called!!! --gnu */
854 register struct mips_pending
*p
, *q
;
856 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
860 pending_list
[f_idx
] = 0;
864 prepend_tag_kind(tag_name
, type_code
)
866 enum type_code type_code
;
874 case TYPE_CODE_STRUCT
:
877 case TYPE_CODE_UNION
:
884 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
885 strlen(prefix
) + strlen(tag_name
) + 1);
886 sprintf(result
, "%s%s", prefix
, tag_name
);
891 /* Parsing Routines proper. */
893 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
894 For blocks, procedures and types we open a new lexical context.
895 This is basically just a big switch on the symbol's type.
896 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
897 BIGEND says whether aux symbols are big-endian or little-endian.
898 Return count of SYMR's handled (normally one). */
901 parse_symbol(sh
, ax
, bigend
)
912 /* When a symbol is cross-referenced from other files/symbols
913 we mark it explicitly */
914 int pend
= (sh
->reserved
== 1);
915 enum address_class
class;
923 case stGlobal
: /* external symbol, goes into global block */
925 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
927 s
= new_symbol((char *)sh
->iss
);
928 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
931 case stStatic
: /* static data, goes into current block. */
933 b
= top_stack
->cur_block
;
934 s
= new_symbol((char *)sh
->iss
);
935 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
938 case stLocal
: /* local variable, goes into current block */
939 if (sh
->sc
== scRegister
) {
940 class = LOC_REGISTER
;
942 sh
->value
+= FP0_REGNUM
-32;
945 b
= top_stack
->cur_block
;
946 s
= new_symbol((char *)sh
->iss
);
947 SYMBOL_VALUE(s
) = sh
->value
;
949 data
: /* Common code for symbols describing data */
950 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
951 SYMBOL_CLASS(s
) = class;
954 /* Type could be missing in a number of cases */
955 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
956 sh
->index
== 0xfffff)
957 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
959 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
960 /* Value of a data symbol is its memory address */
963 case stParam
: /* arg to procedure, goes into current block */
965 top_stack
->numargs
++;
967 name
= (char*)sh
->iss
;
968 /* Special GNU C++ name. */
969 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
970 name
= "this"; /* FIXME, not alloc'd in obstack */
971 s
= new_symbol(name
);
973 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
974 if (sh
->sc
== scRegister
) {
975 SYMBOL_CLASS(s
) = LOC_REGPARM
;
977 sh
->value
+= FP0_REGNUM
-32;
979 SYMBOL_CLASS(s
) = LOC_ARG
;
980 SYMBOL_VALUE(s
) = sh
->value
;
981 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
982 add_symbol(s
, top_stack
->cur_block
);
984 /* FIXME: This has not been tested. See dbxread.c */
985 /* Add the type of this parameter to the function/procedure
986 type of this block. */
987 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
991 case stLabel
: /* label, goes into current block */
992 s
= new_symbol((char *)sh
->iss
);
993 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
994 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
995 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
996 SYMBOL_TYPE(s
) = builtin_type_int
;
997 add_symbol(s
, top_stack
->cur_block
);
1000 case stProc
: /* Procedure, usually goes into global block */
1001 case stStaticProc
: /* Static procedure, goes into current block */
1002 s
= new_symbol((char *)sh
->iss
);
1003 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1004 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1005 /* Type of the return value */
1006 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1007 t
= builtin_type_int
;
1009 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
1010 b
= top_stack
->cur_block
;
1011 if (sh
->st
== stProc
) {
1012 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1013 /* The next test should normally be true,
1014 but provides a hook for nested functions
1015 (which we don't want to make global). */
1016 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
1017 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
1021 /* Make a type for the procedure itself */
1023 /* FIXME: This has not been tested yet! See dbxread.c */
1024 /* Generate a template for the type of this function. The
1025 types of the arguments will be added as we read the symbol
1027 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1029 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1032 /* Create and enter a new lexical context */
1033 b
= new_block(top_stack
->maxsyms
);
1034 SYMBOL_BLOCK_VALUE(s
) = b
;
1035 BLOCK_FUNCTION(b
) = s
;
1036 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1037 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1038 add_block(b
, top_stack
->cur_st
);
1040 /* Not if we only have partial info */
1041 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1045 top_stack
->cur_block
= b
;
1046 top_stack
->blocktype
= sh
->st
;
1047 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1048 top_stack
->cur_field
= -1;
1049 top_stack
->procadr
= sh
->value
;
1050 top_stack
->numargs
= 0;
1052 sh
->value
= (long) SYMBOL_TYPE(s
);
1055 /* Beginning of code for structure, union, and enum definitions.
1056 They all share a common set of local variables, defined here. */
1058 enum type_code type_code
;
1064 case stStruct
: /* Start a block defining a struct type */
1065 type_code
= TYPE_CODE_STRUCT
;
1066 goto structured_common
;
1068 case stUnion
: /* Start a block defining a union type */
1069 type_code
= TYPE_CODE_UNION
;
1070 goto structured_common
;
1072 case stEnum
: /* Start a block defining an enum type */
1073 type_code
= TYPE_CODE_ENUM
;
1074 goto structured_common
;
1076 case stBlock
: /* Either a lexical block, or some type */
1077 if (sh
->sc
!= scInfo
)
1078 goto case_stBlock_code
; /* Lexical block */
1080 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
1082 /* Common code for handling struct, union, enum, and/or as-yet-
1083 unknown-type blocks of info about structured data. `type_code'
1084 has been set to the proper TYPE_CODE, if we know it. */
1087 top_stack
->blocktype
= stBlock
;
1089 s
= new_symbol((char *)sh
->iss
);
1090 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1091 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1092 SYMBOL_VALUE(s
) = 0;
1093 add_symbol(s
, top_stack
->cur_block
);
1095 /* First count the number of fields and the highest value. */
1098 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1100 if (tsym
->st
== stMember
) {
1101 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1102 /* If the type of the member is Nil (or Void),
1103 assume the tag is an enumeration. */
1104 if (tsym
->index
== indexNil
)
1105 type_code
= TYPE_CODE_ENUM
;
1107 ecoff_swap_tir_in (bigend
,
1108 &ax
[tsym
->index
].a_ti
,
1110 if (tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1111 type_code
= TYPE_CODE_ENUM
;
1114 if (tsym
->value
> max_value
)
1115 max_value
= tsym
->value
;
1117 else if (tsym
->st
== stBlock
1118 || tsym
->st
== stUnion
1119 || tsym
->st
== stEnum
1120 || tsym
->st
== stStruct
1121 || tsym
->st
== stParsed
) {
1122 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1123 if (tsym
->index
!= 0)
1124 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1127 else complain (&block_member_complaint
, (char *)tsym
->st
);
1130 /* In an stBlock, there is no way to distinguish structs,
1131 unions, and enums at this point. This is a bug in the
1132 original design (that has been fixed with the
1133 recent addition of the stStruct, stUnion, and stEnum
1134 symbol types.) The way you can tell is if/when you
1135 see a variable or field of that type. In that case
1136 the variable's type (in the AUX table) says if the
1137 type is struct, union, or enum,
1138 and points back to the stBlock here.
1139 So you can patch the tag kind up later - but only
1140 if there actually is a variable or field of that type.
1142 So until we know for sure, we will guess at this point.
1144 If the first member has index==indexNil or a void type,
1145 assume we have an enumeration.
1146 Otherwise, if there is more than one member, and all
1147 the members have offset 0, assume we have a union.
1148 Otherwise, assume we have a struct.
1150 The heuristic could guess wrong in the case of
1151 of an enumeration with no members or a union
1152 with one (or zero) members, or when all except the
1153 last field of a struct have width zero.
1154 These are uncommon and/or illegal situations, and
1155 in any case guessing wrong probably doesn't matter much.
1157 But if we later do find out we were wrong,
1158 we fixup the tag kind. Members of an enumeration
1159 must be handled differently from struct/union fields,
1160 and that is harder to patch up, but luckily we
1161 shouldn't need to. (If there are any enumeration
1162 members, we can tell for sure it's an enum here.) */
1164 if (type_code
== TYPE_CODE_UNDEF
)
1165 if (nfields
> 1 && max_value
== 0)
1166 type_code
= TYPE_CODE_UNION
;
1168 type_code
= TYPE_CODE_STRUCT
;
1170 /* If this type was expected, use its partial definition */
1172 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1174 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1177 TYPE_CODE(t
) = type_code
;
1178 TYPE_LENGTH(t
) = sh
->value
;
1179 TYPE_NFIELDS(t
) = nfields
;
1180 TYPE_FIELDS(t
) = f
= (struct field
*)
1181 obstack_alloc (¤t_objfile
-> type_obstack
,
1182 nfields
* sizeof (struct field
));
1184 if (type_code
== TYPE_CODE_ENUM
) {
1185 /* This is a non-empty enum. */
1186 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1187 struct symbol
*enum_sym
;
1188 f
->bitpos
= tsym
->value
;
1190 f
->name
= (char*)tsym
->iss
;
1193 enum_sym
= (struct symbol
*)
1194 obstack_alloc (¤t_objfile
->symbol_obstack
,
1195 sizeof (struct symbol
));
1196 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1197 SYMBOL_NAME (enum_sym
) = f
->name
;
1198 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1199 SYMBOL_TYPE (enum_sym
) = t
;
1200 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1201 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1202 add_symbol(enum_sym
, top_stack
->cur_block
);
1204 /* Skip the stMembers that we've handled. */
1210 /* make this the current type */
1211 top_stack
->cur_type
= t
;
1212 top_stack
->cur_field
= 0;
1213 /* Mark that symbol has a type, and say which one */
1214 sh
->value
= (long) t
;
1217 /* End of local variables shared by struct, union, enum, and
1218 block (as yet unknown struct/union/enum) processing. */
1222 /* beginnning of (code) block. Value of symbol
1223 is the displacement from procedure start */
1225 top_stack
->blocktype
= stBlock
;
1226 b
= new_block(top_stack
->maxsyms
);
1227 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1228 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1229 top_stack
->cur_block
= b
;
1230 add_block(b
, top_stack
->cur_st
);
1233 case stEnd
: /* end (of anything) */
1234 if (sh
->sc
== scInfo
) {
1235 /* Finished with type */
1236 top_stack
->cur_type
= 0;
1237 } else if (sh
->sc
== scText
&&
1238 (top_stack
->blocktype
== stProc
||
1239 top_stack
->blocktype
== stStaticProc
)) {
1240 /* Finished with procedure */
1241 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1242 struct mips_extra_func_info
*e
;
1246 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1248 /* Make up special symbol to contain procedure specific
1250 s
= new_symbol(".gdbinfo.");
1251 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1252 SYMBOL_CLASS(s
) = LOC_CONST
;
1253 SYMBOL_TYPE(s
) = builtin_type_void
;
1254 e
= (struct mips_extra_func_info
*)
1255 obstack_alloc (¤t_objfile
->symbol_obstack
,
1256 sizeof (struct mips_extra_func_info
));
1257 SYMBOL_VALUE(s
) = (int)e
;
1258 e
->numargs
= top_stack
->numargs
;
1259 add_symbol(s
, top_stack
->cur_block
);
1261 /* Reallocate symbols, saving memory */
1262 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1264 /* f77 emits proc-level with address bounds==[0,0],
1265 So look for such child blocks, and patch them. */
1266 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1267 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1268 if (BLOCK_SUPERBLOCK(b_bad
) == b
1269 && BLOCK_START(b_bad
) == top_stack
->procadr
1270 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1271 BLOCK_START(b_bad
) = BLOCK_START(b
);
1272 BLOCK_END(b_bad
) = BLOCK_END(b
);
1275 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1276 /* End of (code) block. The value of the symbol
1277 is the displacement from the procedure`s start
1278 address of the end of this block. */
1279 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1280 (void) shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1281 } else complain (&stEnd_complaint
, (char *)sh
->sc
);
1283 pop_parse_stack(); /* restore previous lexical context */
1286 case stMember
: /* member of struct or union */
1287 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1288 f
->name
= (char*)sh
->iss
;
1289 f
->bitpos
= sh
->value
;
1291 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1294 case stTypedef
: /* type definition */
1295 s
= new_symbol((char *)sh
->iss
);
1296 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1297 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1298 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1299 add_symbol(s
, top_stack
->cur_block
);
1300 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1301 sh
->value
= (long) SYMBOL_TYPE(s
);
1304 case stFile
: /* file name */
1306 top_stack
->blocktype
= sh
->st
;
1309 /* I`ve never seen these for C */
1311 break; /* register relocation */
1313 break; /* forwarding address */
1315 break; /* constant */
1317 complain(&unknown_mips_symtype_complaint
, (char *)sh
->st
);
1324 /* Parse the type information provided in the raw AX entries for
1325 the symbol SH. Return the bitfield size in BS, in case.
1326 We must byte-swap the AX entries before we use them; BIGEND says whether
1327 they are big-endian or little-endian (from fh->fBigendian). */
1329 static struct type
*
1330 parse_type(ax
, bs
, bigend
)
1335 /* Null entries in this map are treated specially */
1336 static struct type
**map_bt
[] =
1338 &builtin_type_void
, /* btNil */
1340 &builtin_type_char
, /* btChar */
1341 &builtin_type_unsigned_char
, /* btUChar */
1342 &builtin_type_short
, /* btShort */
1343 &builtin_type_unsigned_short
, /* btUShort */
1344 &builtin_type_int
, /* btInt */
1345 &builtin_type_unsigned_int
, /* btUInt */
1346 &builtin_type_long
, /* btLong */
1347 &builtin_type_unsigned_long
, /* btULong */
1348 &builtin_type_float
, /* btFloat */
1349 &builtin_type_double
, /* btDouble */
1356 &builtin_type_complex
, /* btComplex */
1357 &builtin_type_double_complex
, /* btDComplex */
1359 &builtin_type_fixed_dec
, /* btFixedDec */
1360 &builtin_type_float_dec
, /* btFloatDec */
1361 &builtin_type_string
, /* btString */
1364 &builtin_type_void
, /* btVoid */
1365 &builtin_type_long_long
, /* btLongLong */
1366 &builtin_type_unsigned_long_long
,/* btULongLong */
1370 struct type
*tp
= 0;
1373 enum type_code type_code
;
1375 /* Use aux as a type information record, map its basic type. */
1377 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1378 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1379 complain (&basic_type_complaint
, (char *)t
->bt
);
1380 return builtin_type_int
;
1382 if (map_bt
[t
->bt
]) {
1383 tp
= *map_bt
[t
->bt
];
1387 /* Cannot use builtin types -- build our own */
1390 tp
= lookup_pointer_type (builtin_type_void
);
1394 type_code
= TYPE_CODE_STRUCT
;
1398 type_code
= TYPE_CODE_UNION
;
1402 type_code
= TYPE_CODE_ENUM
;
1406 type_code
= TYPE_CODE_RANGE
;
1410 type_code
= TYPE_CODE_SET
;
1415 complain (&basic_type_complaint
, (char *)t
->bt
);
1416 return builtin_type_int
;
1420 /* Skip over any further type qualifiers (FIXME). */
1422 /* This is the way it would work if the compiler worked */
1426 ecoff_swap_tir_in (bigend
, ax
, t1
);
1427 } while (t1
->continued
);
1430 /* Move on to next aux */
1434 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1438 /* All these types really point to some (common) MIPS type
1439 definition, and only the type-qualifiers fully identify
1440 them. We'll make the same effort at sharing. */
1441 if (t
->bt
== btIndirect
||
1442 t
->bt
== btStruct
||
1445 t
->bt
== btTypedef
||
1448 char name
[256], *pn
;
1450 /* Try to cross reference this type */
1451 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1452 /* reading .o file ? */
1453 if (UNSAFE_DATA_ADDR(tp
))
1454 tp
= init_type(type_code
, 0, 0, 0, (struct objfile
*) NULL
);
1455 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1456 sprintf(name
, fmt
, pn
);
1458 /* Usually, TYPE_CODE(tp) is already type_code. The main
1459 exception is if we guessed wrong re struct/union/enum. */
1460 if (TYPE_CODE(tp
) != type_code
) {
1461 complain (&bad_tag_guess_complaint
, name
);
1462 TYPE_CODE(tp
) = type_code
;
1464 if (TYPE_NAME(tp
) == NULL
|| strcmp(TYPE_NAME(tp
), name
) != 0)
1465 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1466 ¤t_objfile
-> type_obstack
);
1469 /* Deal with range types */
1470 if (t
->bt
== btRange
) {
1471 TYPE_NFIELDS (tp
) = 2;
1473 (struct field
*) obstack_alloc (¤t_objfile
-> type_obstack
,
1474 2 * sizeof (struct field
));
1475 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1476 ¤t_objfile
-> type_obstack
);
1477 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1479 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1480 ¤t_objfile
-> type_obstack
);
1481 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1485 /* Parse all the type qualifiers now. If there are more
1486 than 6 the game will continue in the next aux */
1488 #define PARSE_TQ(tq) \
1489 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1491 again
: PARSE_TQ(tq0
);
1501 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1507 /* Make up a complex type from a basic one. Type is passed by
1508 reference in TPP and side-effected as necessary. The type
1509 qualifier TQ says how to handle the aux symbols at AX for
1510 the symbol SX we are currently analyzing. BIGEND says whether
1511 aux symbols are big-endian or little-endian.
1512 Returns the number of aux symbols we parsed. */
1515 upgrade_type(tpp
, tq
, ax
, bigend
)
1524 /* Used in array processing */
1533 t
= lookup_pointer_type (*tpp
);
1538 t
= lookup_function_type (*tpp
);
1544 t
= init_type(TYPE_CODE_ARRAY
, 0, 0, 0, (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
);
1653 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1654 s
= new_symbol(sh_name
);
1655 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1656 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1657 /* Donno its type, hope int is ok */
1658 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1659 add_symbol(s
, top_stack
->cur_block
);
1660 /* Wont have symbols for this one */
1662 SYMBOL_BLOCK_VALUE(s
) = b
;
1663 BLOCK_FUNCTION(b
) = s
;
1664 BLOCK_START(b
) = pr
->adr
;
1665 BLOCK_END(b
) = bound
;
1666 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1667 add_block(b
, top_stack
->cur_st
);
1671 i
= mylookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, LOC_CONST
);
1675 e
= (struct mips_extra_func_info
*)SYMBOL_VALUE(i
);
1677 e
->pdr
.isym
= (long)s
;
1681 /* Parse the external symbol ES. Just call parse_symbol() after
1682 making sure we know where the aux are for it. For procedures,
1683 parsing of the PDRs has already provided all the needed
1684 information, we only parse them if SKIP_PROCEDURES is false,
1685 and only if this causes no symbol duplication.
1686 BIGEND says whether aux entries are big-endian or little-endian.
1688 This routine clobbers top_stack->cur_block and ->cur_st. */
1691 parse_external(es
, skip_procedures
, bigend
)
1693 int skip_procedures
;
1698 if (es
->ifd
!= ifdNil
) {
1700 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1701 ax
= (union aux_ext
*)cur_fdr
->iauxBase
;
1703 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1707 /* Reading .o files */
1708 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1710 switch (es
->asym
.st
) {
1712 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1713 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1714 case stLabel
: what
= "label"; n_undef_labels
++; break;
1715 default : what
= "symbol"; break;
1718 /* FIXME: Turn this into a complaint? */
1720 printf_filtered("Warning: %s `%s' is undefined (in %s)\n",
1721 what
, es
->asym
.iss
, fdr_name((char *)cur_fdr
->rss
));
1725 switch (es
->asym
.st
) {
1727 /* If we have full symbols we do not need more */
1728 if (skip_procedures
)
1730 if (mylookup_symbol ((char *)es
->asym
.iss
, top_stack
->cur_block
,
1731 VAR_NAMESPACE
, LOC_BLOCK
))
1737 * Note that the case of a symbol with indexNil
1738 * must be handled anyways by parse_symbol().
1740 parse_symbol(&es
->asym
, ax
, bigend
);
1747 /* Parse the line number info for file descriptor FH into
1748 GDB's linetable LT. MIPS' encoding requires a little bit
1749 of magic to get things out. Note also that MIPS' line
1750 numbers can go back and forth, apparently we can live
1751 with that and do not need to reorder our linetables */
1756 struct linetable
*lt
;
1758 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1760 int delta
, count
, lineno
= 0;
1766 /* Scan by procedure descriptors */
1768 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1771 /* No code for this one */
1772 if (pr
->iline
== ilineNil
||
1773 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1776 * Aurgh! To know where to stop expanding we
1779 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1780 if (pr
[l
].iline
!= -1)
1782 if (l
== (fh
->cpd
- j
))
1787 * When procedures are moved around the linenumbers
1788 * are attributed to the next procedure up
1790 if (pr
->iline
>= halt
) continue;
1792 base
= (unsigned char*)pr
->cbLineOffset
;
1793 l
= pr
->adr
>> 2; /* in words */
1794 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1795 for (lineno
= pr
->lnLow
; l
< halt
;) {
1796 count
= *base
& 0x0f;
1797 delta
= *base
++ >> 4;
1801 delta
= (base
[0] << 8) | base
[1];
1802 if (delta
>= 0x8000)
1806 lineno
+= delta
;/* first delta is 0 */
1807 k
= add_line(lt
, lineno
, l
, k
);
1813 /* Master parsing procedure for first-pass reading of file symbols
1814 into a partial_symtab.
1816 Parses the symtab described by the global symbolic header CUR_HDR.
1817 END_OF_TEXT_SEG gives the address just after the text segment for
1818 the symtab we are reading. */
1821 parse_partial_symbols (end_of_text_seg
, objfile
)
1822 int end_of_text_seg
;
1823 struct objfile
*objfile
;
1826 HDRR
*hdr
= cur_hdr
;
1827 /* Running pointers */
1831 struct partial_symtab
*pst
;
1833 int past_first_source_file
= 0;
1835 /* List of current psymtab's include files */
1836 char **psymtab_include_list
;
1837 int includes_allocated
;
1840 struct pst_map
* fdr_to_pst
;
1841 /* Index within current psymtab dependency list */
1842 struct partial_symtab
**dependency_list
;
1843 int dependencies_used
, dependencies_allocated
;
1844 struct cleanup
*old_chain
;
1846 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1847 sizeof(EXTR
*) * hdr
->iextMax
);
1849 includes_allocated
= 30;
1851 psymtab_include_list
= (char **) alloca (includes_allocated
*
1853 next_symbol_text_func
= mips_next_symbol_text
;
1855 dependencies_allocated
= 30;
1856 dependencies_used
= 0;
1858 (struct partial_symtab
**) alloca (dependencies_allocated
*
1859 sizeof (struct partial_symtab
*));
1861 last_source_file
= 0;
1866 * Only parse the Local and External symbols, and the Relative FDR.
1867 * Fixup enough of the loader symtab to be able to use it.
1868 * Allocate space only for the file's portions we need to
1873 max_glevel
= MIN_GLEVEL
;
1875 /* Allocate the map FDR -> PST.
1876 Minor hack: -O3 images might claim some global data belongs
1877 to FDR -1. We`ll go along with that */
1878 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1879 old_chain
= make_cleanup (free
, fdr_to_pst
);
1882 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1883 fdr_to_pst
[-1].pst
= pst
;
1887 /* Pass 1 over external syms: Presize and partition the list */
1888 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1889 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1890 fdr_to_pst
[esh
->ifd
].n_globals
++;
1893 /* Pass 1.5 over files: partition out global symbol space */
1895 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1896 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1897 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1898 fdr_to_pst
[f_idx
].n_globals
= 0;
1901 /* Pass 2 over external syms: fill in external symbols */
1902 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1903 enum minimal_symbol_type ms_type
= mst_text
;
1904 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1906 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1907 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1909 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1912 switch (esh
->asym
.st
) {
1921 ms_type
= mst_unknown
;
1922 complain (&unknown_ext_complaint
, (char *)esh
->asym
.iss
);
1924 prim_record_minimal_symbol ((char *)esh
->asym
.iss
,
1929 /* Pass 3 over files, over local syms: fill in static symbols */
1930 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1931 struct partial_symtab
*save_pst
;
1933 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1935 if (fh
->csym
== 0) {
1936 fdr_to_pst
[f_idx
].pst
= NULL
;
1939 pst
= start_psymtab_common (objfile
, 0, (char*)fh
->rss
,
1940 fh
->cpd
? fh
->adr
: 0,
1941 objfile
->global_psymbols
.next
,
1942 objfile
->static_psymbols
.next
);
1943 pst
->read_symtab_private
= (char *)
1944 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1947 /* Make everything point to everything. */
1948 FDR_IDX(pst
) = f_idx
;
1949 fdr_to_pst
[f_idx
].pst
= pst
;
1950 fh
->ioptBase
= (int)pst
;
1952 CUR_HDR(pst
) = cur_hdr
;
1954 /* The way to turn this into a symtab is to call... */
1955 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1957 pst
->texthigh
= pst
->textlow
;
1959 #if 0 /* This is done in start_psymtab_common */
1960 pst
->globals_offset
= global_psymbols
.next
- global_psymbols
.list
;
1961 pst
->statics_offset
= static_psymbols
.next
- static_psymbols
.list
;
1963 pst
->n_global_syms
= 0;
1964 pst
->n_static_syms
= 0;
1967 /* The second symbol must be @stab.
1968 This symbol is emitted by mips-tfile to signal
1969 that the current object file uses encapsulated stabs
1970 instead of mips ecoff for local symbols.
1971 (It is the second symbol because the first symbol is
1972 the stFile used to signal the start of a file). */
1974 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
),
1975 stabs_symbol
) == 0) {
1976 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1979 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1980 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1981 if (!MIPS_IS_STAB(sh
)) {
1982 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
1983 long procaddr
= sh
->value
;
1984 sh
= AUX_GET_ISYM (fh
->fBigendian
,
1985 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
1986 + (SYMR
*) fh
->isymBase
- 1;
1987 if (sh
->st
== stEnd
) {
1988 long high
= procaddr
+ sh
->value
;
1989 if (high
> pst
->texthigh
)
1990 pst
->texthigh
= high
;
1995 #define SET_NAMESTRING() namestring = (char*)sh->iss
1996 #define CUR_SYMBOL_TYPE type_code
1997 #define CUR_SYMBOL_VALUE sh->value
1998 #define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
2000 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2001 #define addr 0 /* FIXME, should be offset of addresses */
2002 #define HANDLE_RBRAC(val) \
2003 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2004 #include "partial-stab.h"
2009 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2011 enum address_class
class;
2012 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2014 if (MIPS_IS_STAB(sh
)) {
2019 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
2020 sh
->index
== 0xfffff) {
2021 /* FIXME, premature? */
2026 name
= (char *)(sh
->iss
);
2033 case stProc
: /* Asm labels apparently */
2034 case stStaticProc
: /* Function */
2035 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2036 VAR_NAMESPACE
, LOC_BLOCK
,
2037 objfile
->static_psymbols
, sh
->value
);
2038 /* Skip over procedure to next one. */
2039 if (sh
->index
>= hdr
->iauxMax
)
2041 /* Should not happen, but does when cross-compiling
2042 with the MIPS compiler. FIXME -- pull later. */
2043 complain (&index_complaint
, name
);
2044 new_sdx
= cur_sdx
+1; /* Don't skip at all */
2047 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2048 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
2049 procaddr
= sh
->value
;
2051 if (new_sdx
<= cur_sdx
)
2053 /* This should not happen either... FIXME. */
2054 complain (&aux_index_complaint
, name
);
2055 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2059 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
2060 if (sh
->st
!= stEnd
)
2062 high
= procaddr
+ sh
->value
;
2063 if (high
> pst
->texthigh
)
2064 pst
->texthigh
= high
;
2067 case stStatic
: /* Variable */
2071 case stTypedef
: /* Typedef */
2072 class = LOC_TYPEDEF
;
2075 case stConstant
: /* Constant decl */
2082 case stBlock
: /* { }, str, un, enum*/
2083 if (sh
->sc
== scInfo
) {
2084 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2085 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2086 objfile
->static_psymbols
, sh
->value
);
2088 /* Skip over the block */
2089 cur_sdx
= sh
->index
;
2092 case stFile
: /* File headers */
2093 case stLabel
: /* Labels */
2094 case stEnd
: /* Ends of files */
2098 /* Both complaints are valid: one gives symbol name,
2099 the other the offending symbol type. */
2100 complain (&unknown_sym_complaint
, (char *)sh
->iss
);
2101 complain (&unknown_st_complaint
, (char *)sh
->st
);
2105 /* Use this gdb symbol */
2106 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2107 VAR_NAMESPACE
, class,
2108 objfile
->static_psymbols
, sh
->value
);
2110 cur_sdx
++; /* Go to next file symbol */
2113 /* Now do enter the external symbols. */
2114 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2115 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2116 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2117 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2118 for (; --cur_sdx
>= 0; ext_ptr
++) {
2119 register struct partial_symbol
*psym
;
2120 enum address_class
class;
2122 if ((*ext_ptr
)->ifd
!= f_idx
)
2124 sh
= &(*ext_ptr
)->asym
;
2133 complain (&unknown_ext_complaint
, (char *)sh
->iss
);
2134 /* Fall through, pretend it's global. */
2139 if (objfile
->global_psymbols
.next
>=
2140 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2141 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2142 psym
= objfile
->global_psymbols
.next
++;
2143 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2144 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2145 SYMBOL_CLASS (psym
) = class;
2146 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2150 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2151 -1, save_pst
->texthigh
,
2152 dependency_list
, dependencies_used
);
2153 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2154 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2156 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2157 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2161 /* Mark the last code address, and remember it for later */
2162 hdr
->cbDnOffset
= end_of_text_seg
;
2164 /* Now scan the FDRs for dependencies */
2165 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2167 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2168 pst
= fdr_to_pst
[f_idx
].pst
;
2170 /* This should catch stabs-in-ecoff. */
2174 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2175 /* ...then presumably a .h file: drop reverse depends .h->.c */
2176 for (; s_id0
< fh
->crfd
; s_id0
++) {
2177 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2179 s_id0
++; /* Skip self-dependency */
2184 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2185 pst
->dependencies
= (struct partial_symtab
**)
2186 obstack_alloc (&objfile
->psymbol_obstack
,
2187 pst
->number_of_dependencies
*
2188 sizeof (struct partial_symtab
*));
2189 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2190 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2191 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2192 complain(&bad_file_number_complaint
, (char *)*rh
);
2194 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2197 do_cleanups (old_chain
);
2202 /* Do the initial analisys of the F_IDX-th file descriptor.
2203 Allocates a partial symtab for it, and builds the list
2204 of dependent files by recursion. LEV says at which level
2205 of recursion we are called (to pretty up debug traces) */
2207 static struct partial_symtab
*
2208 parse_fdr(f_idx
, lev
, objfile
)
2211 struct objfile
*objfile
;
2214 register struct partial_symtab
*pst
;
2217 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2219 /* Use this to indicate into which symtab this file was parsed */
2221 return (struct partial_symtab
*) fh
->ioptBase
;
2223 /* Debuggability level */
2224 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2225 max_glevel
= fh
->glevel
;
2227 /* Make a new partial_symtab */
2228 pst
= new_psymtab(fh
->rss
, objfile
);
2233 pst
->textlow
= fh
->adr
;
2234 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2237 /* Make everything point to everything. */
2238 FDR_IDX(pst
) = f_idx
;
2239 fdr_to_pst
[f_idx
].pst
= pst
;
2240 fh
->ioptBase
= (int)pst
;
2242 /* Analyze its dependencies */
2247 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2248 /* ...then presumably a .h file: drop reverse depends .h->.c */
2249 for (; s_id0
< fh
->crfd
; s_id0
++) {
2250 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2252 s_id0
++; /* Skip self-dependency */
2257 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2258 pst
->dependencies
= (struct partial_symtab
**)
2259 obstack_alloc (&objfile
->psymbol_obstack
,
2260 pst
->number_of_dependencies
*
2261 sizeof (struct partial_symtab
*));
2262 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2263 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2265 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2273 mips_next_symbol_text ()
2276 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2279 /* Ancillary function to psymtab_to_symtab(). Does all the work
2280 for turning the partial symtab PST into a symtab, recurring
2281 first on all dependent psymtabs. The argument FILENAME is
2282 only passed so we can see in debug stack traces what file
2285 This function has a split personality, based on whether the
2286 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2287 The flow of control and even the memory allocation differs. FIXME. */
2290 psymtab_to_symtab_1(pst
, filename
)
2291 struct partial_symtab
*pst
;
2297 struct linetable
*lines
;
2304 /* Read in all partial symbtabs on which this one is dependent.
2305 NOTE that we do have circular dependencies, sigh. We solved
2306 that by setting pst->readin before this point. */
2308 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2309 if (!pst
->dependencies
[i
]->readin
) {
2310 /* Inform about additional files to be read in. */
2313 fputs_filtered (" ", stdout
);
2315 fputs_filtered ("and ", stdout
);
2317 printf_filtered ("%s...",
2318 pst
->dependencies
[i
]->filename
);
2319 wrap_here (""); /* Flush output */
2322 /* We only pass the filename for debug purposes */
2323 psymtab_to_symtab_1(pst
->dependencies
[i
],
2324 pst
->dependencies
[i
]->filename
);
2327 /* Now read the symbols for this symtab */
2329 current_objfile
= pst
->objfile
;
2330 cur_fd
= FDR_IDX(pst
);
2331 fh
= (cur_fd
== -1) ? 0 : (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2334 /* BOUND is the highest core address of this file's procedures */
2335 bound
= (cur_fd
== cur_hdr
->ifdMax
- 1) ?
2336 cur_hdr
->cbDnOffset
:
2339 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2340 if (fh
&& fh
->csym
>= 2
2341 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)
2345 * This symbol table contains stabs-in-ecoff entries.
2351 /* Parse local symbols first */
2353 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2355 current_objfile
= NULL
;
2358 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2359 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2360 char *name
= (char*)sh
->iss
;
2361 CORE_ADDR valu
= sh
->value
;
2362 if (MIPS_IS_STAB(sh
)) {
2363 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2364 process_one_symbol (type_code
, 0, valu
, name
, /*FIXME*/ 0,
2366 if (type_code
== N_FUN
) {
2367 /* Make up special symbol to contain
2368 procedure specific info */
2369 struct mips_extra_func_info
*e
=
2370 (struct mips_extra_func_info
*)
2371 obstack_alloc(¤t_objfile
->symbol_obstack
,
2372 sizeof(struct mips_extra_func_info
));
2373 struct symbol
*s
= new_symbol(".gdbinfo.");
2374 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2375 SYMBOL_CLASS(s
) = LOC_CONST
;
2376 SYMBOL_TYPE(s
) = builtin_type_void
;
2377 SYMBOL_VALUE(s
) = (int)e
;
2378 add_symbol_to_list (s
, &local_symbols
);
2381 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2382 /* Handle encoded stab line number. */
2383 record_line (current_subfile
, sh
->index
, valu
);
2385 else complain (&stab_unknown_complaint
, (char *)sh
->iss
);
2387 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2389 /* Sort the symbol table now, we are done adding symbols to it.
2390 We must do this before parse_procedure calls lookup_symbol. */
2391 sort_symtab_syms(st
);
2393 /* This may not be necessary for stabs symtabs. FIXME. */
2396 /* Fill in procedure info next. We need to look-ahead to
2397 find out where each procedure's code ends. */
2399 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2400 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2401 parse_procedure (pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 1);
2406 * This symbol table contains ordinary ecoff entries.
2413 /* How many symbols will we need */
2414 /* FIXME, this does not count enum values. */
2415 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2418 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2420 f_max
+= fh
->csym
+ fh
->cpd
;
2421 maxlines
= 2 * fh
->cline
;
2422 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2425 lines
= LINETABLE(st
);
2426 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2427 if (pending_list
== 0) {
2428 pending_list
= (struct mips_pending
**)
2429 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2430 cur_hdr
->cbOptOffset
= (int)pending_list
;
2433 /* Get a new lexical context */
2436 top_stack
->cur_st
= st
;
2437 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(st
),
2439 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2440 BLOCK_END(top_stack
->cur_block
) = 0;
2441 top_stack
->blocktype
= stFile
;
2442 top_stack
->maxsyms
= 2*f_max
;
2443 top_stack
->cur_type
= 0;
2444 top_stack
->procadr
= 0;
2445 top_stack
->numargs
= 0;
2451 /* Parse local symbols first */
2453 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2454 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2455 cur_sdx
+= parse_symbol(sh
, (union aux_ent
*)fh
->iauxBase
,
2459 /* Linenumbers. At the end, check if we can save memory */
2461 parse_lines(fh
, lines
);
2462 if (lines
->nitems
< fh
->cline
)
2463 lines
= shrink_linetable(lines
);
2465 /* Fill in procedure info next. We need to look-ahead to
2466 find out where each procedure's code ends. */
2468 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2469 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2470 parse_procedure(pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 0);
2474 LINETABLE(st
) = lines
;
2476 /* .. and our share of externals.
2477 XXX use the global list to speed up things here. how?
2478 FIXME, Maybe quit once we have found the right number of ext's? */
2479 top_stack
->cur_st
= st
;
2480 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
2482 top_stack
->blocktype
= stFile
;
2483 top_stack
->maxsyms
=
2484 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2486 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2487 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2488 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2490 /* If there are undefined, tell the user */
2491 if (n_undef_symbols
) {
2492 printf_filtered("File %s contains %d unresolved references:",
2493 st
->filename
, n_undef_symbols
);
2494 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2495 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2496 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2501 /* Sort the symbol table now, we are done adding symbols to it.*/
2502 sort_symtab_syms(st
);
2507 /* Now link the psymtab and the symtab. */
2510 current_objfile
= NULL
;
2513 /* Ancillary parsing procedures. */
2515 /* Lookup the type at relative index RN. Return it in TPP
2516 if found and in any event come up with its name PNAME.
2517 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2518 Return value says how many aux symbols we ate. */
2521 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2524 enum type_code type_code
; /* Use to alloc new type if none is found. */
2532 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2534 /* Escape index means 'the next one' */
2535 if (rn
->rfd
== 0xfff) {
2537 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2544 *pname
= "<undefined>";
2547 * Find the relative file descriptor and the symbol in it
2549 FDR
*fh
= get_rfd(cur_fd
, rf
);
2554 * If we have processed this symbol then we left a forwarding
2555 * pointer to the corresponding GDB symbol. If not, we`ll put
2556 * it in a list of pending symbols, to be processed later when
2557 * the file f will be. In any event, we collect the name for
2558 * the type here. Which is why we made a first pass at
2561 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2563 /* Careful, we might be looking at .o files */
2564 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2567 /* Have we parsed it ? */
2568 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2569 t
= (struct type
*) sh
->value
;
2572 /* Avoid duplicates */
2573 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2577 *tpp
= init_type(type_code
, 0, 0, 0, (struct objfile
*) NULL
);
2578 add_pending(fh
, sh
, *tpp
);
2583 /* We used one auxent normally, two if we got a "next one" rf. */
2588 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2589 keeping the symtab sorted */
2591 static struct symbol
*
2592 mylookup_symbol (name
, block
, namespace, class)
2594 register struct block
*block
;
2595 enum namespace namespace;
2596 enum address_class
class;
2598 register int bot
, top
, inc
;
2599 register struct symbol
*sym
;
2602 top
= BLOCK_NSYMS(block
);
2605 sym
= BLOCK_SYM(block
, bot
);
2606 if (SYMBOL_NAME(sym
)[0] == inc
2607 && SYMBOL_NAMESPACE(sym
) == namespace
2608 && SYMBOL_CLASS(sym
) == class
2609 && !strcmp(SYMBOL_NAME(sym
), name
))
2613 block
= BLOCK_SUPERBLOCK (block
);
2615 return mylookup_symbol (name
, block
, namespace, class);
2620 /* Add a new symbol S to a block B.
2621 Infrequently, we will need to reallocate the block to make it bigger.
2622 We only detect this case when adding to top_stack->cur_block, since
2623 that's the only time we know how big the block is. FIXME. */
2630 int nsyms
= BLOCK_NSYMS(b
)++;
2631 struct block
*origb
;
2632 struct parse_stack
*stackp
;
2634 if (b
== top_stack
->cur_block
&&
2635 nsyms
>= top_stack
->maxsyms
) {
2636 complain (&block_overflow_complaint
, s
->name
);
2637 /* In this case shrink_block is actually grow_block, since
2638 BLOCK_NSYMS(b) is larger than its current size. */
2640 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2642 /* Now run through the stack replacing pointers to the
2643 original block. shrink_block has already done this
2644 for the blockvector and BLOCK_FUNCTION. */
2645 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2646 if (stackp
->cur_block
== origb
) {
2647 stackp
->cur_block
= b
;
2648 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2652 BLOCK_SYM(b
,nsyms
) = s
;
2655 /* Add a new block B to a symtab S */
2662 struct blockvector
*bv
= BLOCKVECTOR(s
);
2664 bv
= (struct blockvector
*)xrealloc((PTR
) bv
,
2665 sizeof(struct blockvector
) +
2666 BLOCKVECTOR_NBLOCKS(bv
)
2667 * sizeof(bv
->block
));
2668 if (bv
!= BLOCKVECTOR(s
))
2669 BLOCKVECTOR(s
) = bv
;
2671 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2674 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2675 MIPS' linenumber encoding might need more than one byte
2676 to describe it, LAST is used to detect these continuation lines */
2679 add_line(lt
, lineno
, adr
, last
)
2680 struct linetable
*lt
;
2686 last
= -2; /* make sure we record first line */
2688 if (last
== lineno
) /* skip continuation lines */
2691 lt
->item
[lt
->nitems
].line
= lineno
;
2692 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2696 /* Sorting and reordering procedures */
2698 /* Blocks with a smaller low bound should come first */
2701 compare_blocks(arg1
, arg2
)
2702 const void *arg1
, *arg2
;
2704 register int addr_diff
;
2705 struct block
**b1
= (struct block
**) arg1
;
2706 struct block
**b2
= (struct block
**) arg2
;
2708 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2710 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2714 /* Sort the blocks of a symtab S.
2715 Reorder the blocks in the blockvector by code-address,
2716 as required by some MI search routines */
2722 struct blockvector
*bv
= BLOCKVECTOR(s
);
2724 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2726 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2727 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2728 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2729 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2733 * This is very unfortunate: normally all functions are compiled in
2734 * the order they are found, but if the file is compiled -O3 things
2735 * are very different. It would be nice to find a reliable test
2736 * to detect -O3 images in advance.
2738 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2739 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2740 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2741 sizeof(struct block
*),
2745 register CORE_ADDR high
= 0;
2746 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2748 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2749 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2750 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2751 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2754 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2755 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2757 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2758 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2759 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2760 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2764 /* Constructor/restructor/destructor procedures */
2766 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2767 MAXSYMS and linenumbers MAXLINES we'll put in it */
2769 static struct symtab
*
2770 new_symtab(name
, maxsyms
, maxlines
, objfile
)
2774 struct objfile
*objfile
;
2776 struct symtab
*s
= allocate_symtab (name
, objfile
);
2778 LINETABLE(s
) = new_linetable(maxlines
);
2780 /* All symtabs must have at least two blocks */
2781 BLOCKVECTOR(s
) = new_bvect(2);
2782 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2783 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2784 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2785 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2787 s
->free_code
= free_linetable
;
2792 /* Allocate a new partial_symtab NAME */
2794 static struct partial_symtab
*
2795 new_psymtab(name
, objfile
)
2797 struct objfile
*objfile
;
2799 struct partial_symtab
*psymtab
;
2801 /* FIXME -- why (char *) -1 rather than NULL? */
2802 psymtab
= allocate_psymtab (name
== (char *) -1 ? "<no name>" : name
,
2805 /* Keep a backpointer to the file's symbols */
2807 psymtab
-> read_symtab_private
= (char *)
2808 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2809 CUR_HDR(psymtab
) = cur_hdr
;
2811 /* The way to turn this into a symtab is to call... */
2812 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
2817 /* Allocate a linetable array of the given SIZE. Since the struct
2818 already includes one item, we subtract one when calculating the
2819 proper size to allocate. */
2821 static struct linetable
*
2825 struct linetable
*l
;
2827 size
= (size
-1) * sizeof(l
->item
) + sizeof(struct linetable
);
2828 l
= (struct linetable
*)xmalloc(size
);
2833 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2834 I am not so sure about the 3.4 ones.
2836 Since the struct linetable already includes one item, we subtract one when
2837 calculating the proper size to allocate. */
2839 static struct linetable
*
2840 shrink_linetable(lt
)
2841 struct linetable
* lt
;
2844 return (struct linetable
*) xrealloc ((PTR
)lt
,
2845 sizeof(struct linetable
)
2846 + (lt
->nitems
- 1) * sizeof(lt
->item
));
2849 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2851 static struct blockvector
*
2855 struct blockvector
*bv
;
2858 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2859 bv
= (struct blockvector
*) xzalloc(size
);
2861 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2866 /* Allocate and zero a new block of MAXSYMS symbols */
2868 static struct block
*
2872 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2874 return (struct block
*)xzalloc (size
);
2877 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2878 Shrink_block can also be used by add_symbol to grow a block. */
2880 static struct block
*
2886 struct blockvector
*bv
= BLOCKVECTOR(s
);
2889 /* Just reallocate it and fix references to the old one */
2891 new = (struct block
*) xrealloc ((PTR
)b
, sizeof(struct block
) +
2892 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2894 /* Should chase pointers to old one. Fortunately, that`s just
2895 the block`s function and inferior blocks */
2896 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2897 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2898 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2899 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2900 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2901 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2902 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2906 /* Create a new symbol with printname NAME */
2908 static struct symbol
*
2912 struct symbol
*s
= (struct symbol
*)
2913 obstack_alloc (¤t_objfile
->symbol_obstack
, sizeof (struct symbol
));
2915 memset ((PTR
)s
, 0, sizeof (*s
));
2916 SYMBOL_NAME(s
) = name
;
2920 /* Create a new type with printname NAME */
2922 static struct type
*
2928 t
= alloc_type (current_objfile
);
2929 TYPE_NAME(t
) = name
;
2930 TYPE_CPLUS_SPECIFIC(t
) = (struct cplus_struct_type
*)
2931 &cplus_struct_default
;
2936 /* Things used for calling functions in the inferior.
2937 These functions are exported to our companion
2938 mips-tdep.c file and are here because they play
2939 with the symbol-table explicitly. */
2941 /* Sigtramp: make sure we have all the necessary information
2942 about the signal trampoline code. Since the official code
2943 from MIPS does not do so, we make up that information ourselves.
2944 If they fix the library (unlikely) this code will neutralize itself. */
2951 struct block
*b
, *b0
;
2953 sigtramp_address
= -1;
2955 /* We know it is sold as sigvec */
2956 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2958 /* Most programs do not play with signals */
2960 s
= lookup_symbol("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
2963 b0
= SYMBOL_BLOCK_VALUE(s
);
2965 /* A label of sigvec, to be more precise */
2966 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
2969 /* But maybe this program uses its own version of sigvec */
2973 /* Did we or MIPSco fix the library ? */
2974 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
2976 sigtramp_address
= BLOCK_START(SYMBOL_BLOCK_VALUE(s
));
2977 sigtramp_end
= BLOCK_END(SYMBOL_BLOCK_VALUE(s
));
2981 sigtramp_address
= SYMBOL_VALUE(s
);
2982 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
2984 /* But what symtab does it live in ? */
2985 st
= find_pc_symtab(SYMBOL_VALUE(s
));
2988 * Ok, there goes the fix: turn it into a procedure, with all the
2989 * needed info. Note we make it a nested procedure of sigvec,
2990 * which is the way the (assembly) code is actually written.
2992 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
2993 SYMBOL_CLASS(s
) = LOC_BLOCK
;
2994 SYMBOL_TYPE(s
) = init_type(TYPE_CODE_FUNC
, 4, 0, 0, (struct objfile
*) NULL
);
2995 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
2997 /* Need a block to allocate .gdbinfo. in */
2999 SYMBOL_BLOCK_VALUE(s
) = b
;
3000 BLOCK_START(b
) = sigtramp_address
;
3001 BLOCK_END(b
) = sigtramp_end
;
3002 BLOCK_FUNCTION(b
) = s
;
3003 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
3007 /* Make a .gdbinfo. for it */
3009 struct mips_extra_func_info
*e
=
3010 (struct mips_extra_func_info
*)
3011 xzalloc(sizeof(struct mips_extra_func_info
));
3013 e
->numargs
= 0; /* the kernel thinks otherwise */
3014 /* align_longword(sigcontext + SIGFRAME) */
3015 e
->pdr
.frameoffset
= 0x150;
3016 e
->pdr
.framereg
= SP_REGNUM
;
3018 e
->pdr
.regmask
= -2;
3019 e
->pdr
.regoffset
= -(41 * sizeof(int));
3020 e
->pdr
.fregmask
= -1;
3021 e
->pdr
.fregoffset
= -(37 * sizeof(int));
3022 e
->pdr
.isym
= (long)s
;
3024 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3025 s
= new_symbol(".gdbinfo.");
3026 SYMBOL_VALUE(s
) = (int) e
;
3027 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
3028 SYMBOL_CLASS(s
) = LOC_CONST
;
3029 SYMBOL_TYPE(s
) = builtin_type_void
;
3030 current_objfile
= NULL
;
3033 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
3036 /* Initialization */
3038 static struct sym_fns ecoff_sym_fns
=
3040 "ecoff", /* sym_name: name or name prefix of BFD target type */
3041 5, /* sym_namelen: number of significant sym_name chars */
3042 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3043 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
3044 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
3045 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
3046 NULL
/* next: pointer to next struct sym_fns */
3051 _initialize_mipsread ()
3053 add_symtab_fns (&ecoff_sym_fns
);
3055 /* Missing basic types */
3056 builtin_type_string
=
3057 init_type (TYPE_CODE_PASCAL_ARRAY
,
3059 (struct objfile
*) NULL
);
3060 builtin_type_complex
=
3061 init_type(TYPE_CODE_FLT
,
3062 2 * sizeof(float), 0, "complex",
3063 (struct objfile
*) NULL
);
3064 builtin_type_double_complex
=
3065 init_type(TYPE_CODE_FLT
,
3066 2 * sizeof(double), 0, "double_complex",
3067 (struct objfile
*) NULL
);
3068 builtin_type_fixed_dec
=
3069 init_type(TYPE_CODE_INT
, sizeof(int),
3071 (struct objfile
*) NULL
);
3072 builtin_type_float_dec
=
3073 init_type(TYPE_CODE_FLT
, sizeof(double),
3074 0, "floating_decimal",
3075 (struct objfile
*) NULL
);