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>
72 #include "coff/mips.h" /* COFF-like aspects of ecoff files */
73 #include "coff/sym.h" /* Symbol structures in ecoff files */
74 #include "coff/symconst.h" /* Manifest constants in ecoff sym structures */
75 #include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
77 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
78 #include "aout/aout64.h"
79 #include "aout/stab_gnu.h" /* STABS information */
82 struct external_filehdr f
;
83 struct external_aouthdr a
;
86 /* These must match the corresponding definition in gcc/config/xm-mips.h.
87 At some point, these should probably go into a shared include file,
88 but currently gcc and gdb do not share any directories. */
90 #define CODE_MASK 0x8F300
91 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
92 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
93 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
94 #define STABS_SYMBOL "@stabs"
96 /* Each partial symbol table entry contains a pointer to private data for the
97 read_symtab() function to use when expanding a partial symbol table entry
98 to a full symbol table entry.
100 For mipsread this structure contains the index of the FDR that this psymtab
101 represents and a pointer to the symbol table header HDRR from the symbol
102 file that the psymtab was created from. */
104 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
105 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
106 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
111 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
112 int extern_count
; /* Size of extern_tab. */
115 /* Things we import explicitly from other modules */
117 extern int info_verbose
;
119 /* Various complaints about symbol reading that don't abort the process */
121 struct complaint bad_file_number_complaint
=
122 {"bad file number %d", 0, 0};
124 struct complaint index_complaint
=
125 {"bad aux index at symbol %s", 0, 0};
127 struct complaint aux_index_complaint
=
128 {"bad proc end in aux found from symbol %s", 0, 0};
130 struct complaint unknown_ext_complaint
=
131 {"unknown external symbol %s", 0, 0};
133 struct complaint unknown_sym_complaint
=
134 {"unknown local symbol %s", 0, 0};
136 struct complaint unknown_st_complaint
=
137 {"with type %d", 0, 0};
139 struct complaint block_overflow_complaint
=
140 {"block containing %s overfilled", 0, 0};
142 struct complaint basic_type_complaint
=
143 {"cannot map MIPS basic type 0x%x", 0, 0};
145 struct complaint unknown_type_qual_complaint
=
146 {"unknown type qualifier 0x%x", 0, 0};
148 struct complaint array_bitsize_complaint
=
149 {"size of array target type not known, assuming %d bits", 0, 0};
151 struct complaint bad_tag_guess_complaint
=
152 {"guessed tag type of %s incorrectly", 0, 0};
154 struct complaint block_member_complaint
=
155 {"declaration block contains unhandled symbol type %d", 0, 0};
157 struct complaint stEnd_complaint
=
158 {"stEnd with storage class %d not handled", 0, 0};
160 struct complaint unknown_mips_symtype_complaint
=
161 {"unknown symbol type 0x%x", 0, 0};
163 struct complaint stab_unknown_complaint
=
164 {"unknown stabs symbol %s", 0, 0};
166 struct complaint pdr_for_nonsymbol_complaint
=
167 {"PDR for %s, but no symbol", 0, 0};
169 struct complaint pdr_static_symbol_complaint
=
170 {"can't handle PDR for static proc at 0x%x", 0, 0};
172 /* Macros and extra defs */
174 /* Already-parsed symbols are marked specially */
176 #define stParsed stType
178 /* Puns: hard to find whether -g was used and how */
180 #define MIN_GLEVEL GLEVEL_0
181 #define compare_glevel(a,b) \
182 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
183 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
185 /* When looking at .o files, avoid tripping over bad addresses */
187 #define SAFE_TEXT_ADDR 0x400000
188 #define SAFE_DATA_ADDR 0x10000000
190 #define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR)
192 /* Things that really are local to this module */
194 /* MIPS symtab header for the current file */
196 static HDRR
*cur_hdr
;
198 /* Pointer to current file decriptor record, and its index */
203 /* Index of current symbol */
207 /* Note how much "debuggable" this image is. We would like
208 to see at least one FDR with full symbols */
213 /* When examining .o files, report on undefined symbols */
215 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
217 /* Pseudo symbol to use when putting stabs into the symbol table. */
219 static char stabs_symbol
[] = STABS_SYMBOL
;
221 /* Extra builtin types */
223 struct type
*builtin_type_complex
;
224 struct type
*builtin_type_double_complex
;
225 struct type
*builtin_type_fixed_dec
;
226 struct type
*builtin_type_float_dec
;
227 struct type
*builtin_type_string
;
229 /* Forward declarations */
232 fixup_symtab
PARAMS ((HDRR
*, char *, int, bfd
*));
235 read_mips_symtab
PARAMS ((struct objfile
*));
238 read_the_mips_symtab
PARAMS ((bfd
*, CORE_ADDR
*));
241 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
244 parse_partial_symbols
PARAMS ((int, struct objfile
*));
247 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
251 fixup_sigtramp
PARAMS ((void));
253 static struct symbol
*
254 new_symbol
PARAMS ((char *));
257 new_type
PARAMS ((char *));
259 static struct block
*
260 new_block
PARAMS ((int));
262 static struct symtab
*
263 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
265 static struct linetable
*
266 new_linetable
PARAMS ((int));
268 static struct blockvector
*
269 new_bvect
PARAMS ((int));
272 parse_type
PARAMS ((union aux_ext
*, int *, int));
274 static struct symbol
*
275 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
276 enum address_class
));
278 static struct block
*
279 shrink_block
PARAMS ((struct block
*, struct symtab
*));
282 xzalloc
PARAMS ((unsigned int));
285 sort_blocks
PARAMS ((struct symtab
*));
288 compare_blocks
PARAMS ((const void *, const void *));
290 static struct partial_symtab
*
291 new_psymtab
PARAMS ((char *, struct objfile
*));
294 static struct partial_symtab
*
295 parse_fdr
PARAMS ((int, int, struct objfile
*));
299 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
302 add_block
PARAMS ((struct block
*, struct symtab
*));
305 add_symbol
PARAMS ((struct symbol
*, struct block
*));
308 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
310 static struct linetable
*
311 shrink_linetable
PARAMS ((struct linetable
*));
314 mips_next_symbol_text
PARAMS ((void));
316 /* Things we export to other modules */
318 /* Address bounds for the signal trampoline in inferior, if any */
319 /* FIXME: Nothing really seems to use this. Why is it here? */
321 CORE_ADDR sigtramp_address
, sigtramp_end
;
324 mipscoff_new_init (ignore
)
325 struct objfile
*ignore
;
330 mipscoff_symfile_init (objfile
)
331 struct objfile
*objfile
;
333 if (objfile
-> sym_private
!= NULL
)
335 mfree (objfile
-> md
, objfile
-> sym_private
);
337 objfile
-> sym_private
= NULL
;
341 mipscoff_symfile_read (objfile
, addr
, mainline
)
342 struct objfile
*objfile
;
346 bfd
*abfd
= objfile
-> obfd
;
348 init_minimal_symbol_collection ();
349 make_cleanup (discard_minimal_symbols
, 0);
351 /* Now that the executable file is positioned at symbol table,
352 process it and define symbols accordingly. */
354 read_mips_symtab(objfile
);
356 /* Install any minimal symbols that have been collected as the current
357 minimal symbols for this objfile. */
359 install_minimal_symbols (objfile
);
362 /* Perform any local cleanups required when we are done with a particular
363 objfile. I.E, we are in the process of discarding all symbol information
364 for an objfile, freeing up all memory held for it, and unlinking the
365 objfile struct from the global list of known objfiles. */
368 mipscoff_symfile_finish (objfile
)
369 struct objfile
*objfile
;
371 if (objfile
-> sym_private
!= NULL
)
373 mfree (objfile
-> md
, objfile
-> sym_private
);
376 /* If we have a file symbol header lying around, blow it away. */
385 /* Allocate zeroed memory */
391 PTR p
= xmalloc(size
);
397 /* Exported procedure: Builds a symtab from the PST partial one.
398 Restores the environment in effect when PST was created, delegates
399 most of the work to an ancillary procedure, and sorts
400 and reorders the symtab list at the end */
403 mipscoff_psymtab_to_symtab(pst
)
404 struct partial_symtab
*pst
;
411 printf_filtered("Reading in symbols for %s...", pst
->filename
);
414 /* Restore the header and list of pending typedefs */
415 cur_hdr
= CUR_HDR(pst
);
417 next_symbol_text_func
= mips_next_symbol_text
;
419 psymtab_to_symtab_1(pst
, pst
->filename
);
421 /* Match with global symbols. This only needs to be done once,
422 after all of the symtabs and dependencies have been read in. */
423 scan_file_globals (pst
->objfile
);
426 printf_filtered("done.\n");
429 /* Exported procedure: Is PC in the signal trampoline code */
432 in_sigtramp(pc
, ignore
)
434 char *ignore
; /* function name */
436 if (sigtramp_address
== 0)
438 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
441 /* File-level interface functions */
443 /* Read the symtab information from file ABFD into memory. Also,
444 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
447 read_the_mips_symtab(abfd
, end_of_text_segp
)
449 CORE_ADDR
*end_of_text_segp
;
451 int stsize
, st_hdrsize
;
453 struct hdr_ext hdr_ext
;
455 /* Header for executable/object file we read symbols from */
456 struct coff_exec filhdr
;
459 /* We need some info from the initial headers */
460 val
= bfd_seek(abfd
, 0L, L_SET
);
461 val
= bfd_read((PTR
)&filhdr
, sizeof filhdr
, 1, abfd
);
463 if (end_of_text_segp
)
465 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
466 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
468 /* Find and read the symbol table header */
469 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
470 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
474 bfd_seek (abfd
, st_filptr
, L_SET
);
475 if (st_hdrsize
!= sizeof (hdr_ext
)) { /* Profanity check */
476 error ("Wrong header size: %d, not %d", st_hdrsize
,
479 if (bfd_read((PTR
)&hdr_ext
, st_hdrsize
, 1, abfd
) != st_hdrsize
)
481 ecoff_swap_hdr_in (abfd
, &hdr_ext
, &st_hdr
);
483 /* Find out how large the symbol table is */
484 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
485 + st_hdr
.iextMax
* cbEXTR
;
487 /* Allocate space for the symbol table. Read it in. */
488 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
490 memcpy((PTR
)cur_hdr
, (PTR
)&hdr_ext
, st_hdrsize
);
491 if (bfd_read((char *)cur_hdr
+ st_hdrsize
, stsize
, 1, abfd
) != stsize
)
494 /* Fixup file_pointers in it */
495 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
496 st_filptr
+ st_hdrsize
, abfd
);
500 error("Short read on %s", bfd_get_filename (abfd
));
504 /* Turn all file-relative pointers in the symtab described by HDR
505 into memory pointers, given that the symtab itself is located
506 at DATA in memory and F_PTR in the file.
508 Byte-swap all the data structures, in place, while we are at it --
509 except AUX entries, which we leave in their original byte order.
510 They will be swapped as they are used instead. (FIXME: we ought to
511 do all the data structures that way.) */
514 fixup_symtab (hdr
, data
, f_ptr
, abfd
)
525 struct rfd_ext
*rbase
;
527 /* This function depends on the external and internal forms
528 of the MIPS symbol table taking identical space. Check this
529 assumption at compile-time. */
530 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
531 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
532 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
533 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
534 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
535 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
536 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
537 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
538 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
539 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
540 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
541 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
543 /* Swap in the header record. */
544 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
547 * These fields are useless (and empty) by now:
548 * hdr->cbDnOffset, hdr->cbOptOffset
549 * We use them for other internal purposes.
552 hdr
->cbOptOffset
= 0;
555 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
569 /* Fix all the RFD's. */
570 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
571 for (i
= 0; i
< hdr
->crfd
; i
++) {
572 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
575 /* Fix all string pointers inside the symtab, and
576 the FDR records. Also fix other miscellany. */
578 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
579 register unsigned code_offset
;
581 /* Header itself, and strings */
582 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
584 /* Swap in the FDR */
585 ecoff_swap_fdr_in (abfd
, fh
, fh
);
587 fh
->issBase
+= hdr
->cbSsOffset
;
589 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
592 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
594 /* FIXME! Probably don't want to do this here! */
595 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
596 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
597 ecoff_swap_sym_in (abfd
, sh
, sh
);
599 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
605 /* cannot fix fh->ipdFirst because it is a short */
606 #define IPDFIRST(h,fh) \
607 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
609 /* Optional symbols (actually used for partial_symtabs) */
615 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
616 /* Relative file descriptor table */
617 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
621 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
623 /* Procedure symbols. (XXX This should be done later) */
624 code_offset
= fh
->adr
;
625 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
626 unsigned name
, only_ext
;
628 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
629 ecoff_swap_pdr_in (abfd
, pr
, pr
);
631 /* Simple rule to find files linked "-x" */
632 only_ext
= fh
->rss
== -1;
634 if (pr
->isym
== -1) {
635 /* static function */
639 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
640 sh
= &((EXTR
*)name
)->asym
;
644 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
645 /* Included code ? */
646 if (s_idx
== 0 && pr
->adr
!= 0)
647 code_offset
-= pr
->adr
;
650 /* Turn index into a pointer */
653 /* Fix line numbers */
654 pr
->cbLineOffset
+= fh
->cbLineOffset
;
656 /* Relocate address */
658 pr
->adr
+= code_offset
;
662 /* External symbols: swap in, and fix string */
663 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
664 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
665 ecoff_swap_ext_in (abfd
, esh
, esh
);
666 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
671 /* Find a file descriptor given its index RF relative to a file CF */
679 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
680 /* Object files do not have the RFD table, all refs are absolute */
682 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
683 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
684 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
687 /* Return a safer print NAME for a file descriptor */
693 if (name
== (char *) -1)
694 return "<stripped file>";
695 if (UNSAFE_DATA_ADDR(name
))
701 /* Read in and parse the symtab of the file DESC. INCREMENTAL says
702 whether we are adding to the general symtab or not.
703 FIXME: INCREMENTAL is currently always zero, though it should not be. */
706 read_mips_symtab (objfile
)
707 struct objfile
*objfile
;
709 CORE_ADDR end_of_text_seg
;
711 read_the_mips_symtab(objfile
->obfd
, &end_of_text_seg
);
713 parse_partial_symbols(end_of_text_seg
, objfile
);
717 * Check to make sure file was compiled with -g.
718 * If not, warn the user of this limitation.
720 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
721 if (max_gdbinfo
== 0)
723 "\n%s not compiled with -g, debugging support is limited.\n",
726 "You should compile with -g2 or -g3 for best debugging support.\n");
732 /* Local utilities */
734 /* Map of FDR indexes to partial symtabs */
737 struct partial_symtab
*pst
; /* the psymtab proper */
738 int n_globals
; /* exported globals (external symbols) */
739 int globals_offset
; /* cumulative */
743 /* Utility stack, used to nest procedures and blocks properly.
744 It is a doubly linked list, to avoid too many alloc/free.
745 Since we might need it quite a few times it is NOT deallocated
748 static struct parse_stack
{
749 struct parse_stack
*next
, *prev
;
750 struct symtab
*cur_st
; /* Current symtab. */
751 struct block
*cur_block
; /* Block in it. */
752 int blocktype
; /* What are we parsing. */
753 int maxsyms
; /* Max symbols in this block. */
754 struct type
*cur_type
; /* Type we parse fields for. */
755 int cur_field
; /* Field number in cur_type. */
756 int procadr
; /* Start addres of this procedure */
757 int numargs
; /* Its argument count */
758 } *top_stack
; /* Top stack ptr */
761 /* Enter a new lexical context */
766 struct parse_stack
*new;
768 /* Reuse frames if possible */
769 if (top_stack
&& top_stack
->prev
)
770 new = top_stack
->prev
;
772 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
773 /* Initialize new frame with previous content */
775 register struct parse_stack
*prev
= new->prev
;
778 top_stack
->prev
= new;
780 new->next
= top_stack
;
785 /* Exit a lexical context */
793 top_stack
= top_stack
->next
;
797 /* Cross-references might be to things we haven't looked at
798 yet, e.g. type references. To avoid too many type
799 duplications we keep a quick fixup table, an array
800 of lists of references indexed by file descriptor */
802 static struct mips_pending
{
803 struct mips_pending
*next
; /* link */
804 SYMR
*s
; /* the symbol */
805 struct type
*t
; /* its partial type descriptor */
809 /* Check whether we already saw symbol SH in file FH as undefined */
811 static struct mips_pending
*
812 is_pending_symbol(fh
, sh
)
816 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
817 register struct mips_pending
*p
;
819 /* Linear search is ok, list is typically no more than 10 deep */
820 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
826 /* Add a new undef symbol SH of type T */
829 add_pending(fh
, sh
, t
)
834 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
835 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
837 /* Make sure we do not make duplicates */
839 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
842 p
->next
= pending_list
[f_idx
];
843 pending_list
[f_idx
] = p
;
845 sh
->reserved
= 1; /* for quick check */
848 /* Throw away undef entries when done with file index F_IDX */
849 /* FIXME -- storage leak. This is never called!!! --gnu */
855 register struct mips_pending
*p
, *q
;
857 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
861 pending_list
[f_idx
] = 0;
865 prepend_tag_kind(tag_name
, type_code
)
867 enum type_code type_code
;
875 case TYPE_CODE_STRUCT
:
878 case TYPE_CODE_UNION
:
885 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
886 strlen(prefix
) + strlen(tag_name
) + 1);
887 sprintf(result
, "%s%s", prefix
, tag_name
);
892 /* Parsing Routines proper. */
894 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
895 For blocks, procedures and types we open a new lexical context.
896 This is basically just a big switch on the symbol's type.
897 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
898 BIGEND says whether aux symbols are big-endian or little-endian.
899 Return count of SYMR's handled (normally one). */
902 parse_symbol(sh
, ax
, bigend
)
913 /* When a symbol is cross-referenced from other files/symbols
914 we mark it explicitly */
915 int pend
= (sh
->reserved
== 1);
916 enum address_class
class;
924 case stGlobal
: /* external symbol, goes into global block */
926 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
928 s
= new_symbol((char *)sh
->iss
);
929 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
932 case stStatic
: /* static data, goes into current block. */
934 b
= top_stack
->cur_block
;
935 s
= new_symbol((char *)sh
->iss
);
936 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
939 case stLocal
: /* local variable, goes into current block */
940 if (sh
->sc
== scRegister
) {
941 class = LOC_REGISTER
;
943 sh
->value
+= FP0_REGNUM
-32;
946 b
= top_stack
->cur_block
;
947 s
= new_symbol((char *)sh
->iss
);
948 SYMBOL_VALUE(s
) = sh
->value
;
950 data
: /* Common code for symbols describing data */
951 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
952 SYMBOL_CLASS(s
) = class;
955 /* Type could be missing in a number of cases */
956 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
957 sh
->index
== 0xfffff)
958 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
960 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
961 /* Value of a data symbol is its memory address */
964 case stParam
: /* arg to procedure, goes into current block */
966 top_stack
->numargs
++;
968 name
= (char*)sh
->iss
;
969 /* Special GNU C++ name. */
970 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
971 name
= "this"; /* FIXME, not alloc'd in obstack */
972 s
= new_symbol(name
);
974 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
975 if (sh
->sc
== scRegister
) {
976 SYMBOL_CLASS(s
) = LOC_REGPARM
;
978 sh
->value
+= FP0_REGNUM
-32;
980 SYMBOL_CLASS(s
) = LOC_ARG
;
981 SYMBOL_VALUE(s
) = sh
->value
;
982 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
983 add_symbol(s
, top_stack
->cur_block
);
985 /* FIXME: This has not been tested. See dbxread.c */
986 /* Add the type of this parameter to the function/procedure
987 type of this block. */
988 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
992 case stLabel
: /* label, goes into current block */
993 s
= new_symbol((char *)sh
->iss
);
994 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
995 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
996 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
997 SYMBOL_TYPE(s
) = builtin_type_int
;
998 add_symbol(s
, top_stack
->cur_block
);
1001 case stProc
: /* Procedure, usually goes into global block */
1002 case stStaticProc
: /* Static procedure, goes into current block */
1003 s
= new_symbol((char *)sh
->iss
);
1004 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1005 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1006 /* Type of the return value */
1007 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1008 t
= builtin_type_int
;
1010 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
1011 b
= top_stack
->cur_block
;
1012 if (sh
->st
== stProc
) {
1013 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1014 /* The next test should normally be true,
1015 but provides a hook for nested functions
1016 (which we don't want to make global). */
1017 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
1018 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
1022 /* Make a type for the procedure itself */
1024 /* FIXME: This has not been tested yet! See dbxread.c */
1025 /* Generate a template for the type of this function. The
1026 types of the arguments will be added as we read the symbol
1028 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1030 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1033 /* Create and enter a new lexical context */
1034 b
= new_block(top_stack
->maxsyms
);
1035 SYMBOL_BLOCK_VALUE(s
) = b
;
1036 BLOCK_FUNCTION(b
) = s
;
1037 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1038 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1039 add_block(b
, top_stack
->cur_st
);
1041 /* Not if we only have partial info */
1042 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1046 top_stack
->cur_block
= b
;
1047 top_stack
->blocktype
= sh
->st
;
1048 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1049 top_stack
->cur_field
= -1;
1050 top_stack
->procadr
= sh
->value
;
1051 top_stack
->numargs
= 0;
1053 sh
->value
= (long) SYMBOL_TYPE(s
);
1056 /* Beginning of code for structure, union, and enum definitions.
1057 They all share a common set of local variables, defined here. */
1059 enum type_code type_code
;
1065 case stStruct
: /* Start a block defining a struct type */
1066 type_code
= TYPE_CODE_STRUCT
;
1067 goto structured_common
;
1069 case stUnion
: /* Start a block defining a union type */
1070 type_code
= TYPE_CODE_UNION
;
1071 goto structured_common
;
1073 case stEnum
: /* Start a block defining an enum type */
1074 type_code
= TYPE_CODE_ENUM
;
1075 goto structured_common
;
1077 case stBlock
: /* Either a lexical block, or some type */
1078 if (sh
->sc
!= scInfo
)
1079 goto case_stBlock_code
; /* Lexical block */
1081 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
1083 /* Common code for handling struct, union, enum, and/or as-yet-
1084 unknown-type blocks of info about structured data. `type_code'
1085 has been set to the proper TYPE_CODE, if we know it. */
1088 top_stack
->blocktype
= stBlock
;
1090 s
= new_symbol((char *)sh
->iss
);
1091 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1092 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1093 SYMBOL_VALUE(s
) = 0;
1094 add_symbol(s
, top_stack
->cur_block
);
1096 /* First count the number of fields and the highest value. */
1099 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1101 if (tsym
->st
== stMember
) {
1102 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1103 /* If the type of the member is Nil (or Void),
1104 assume the tag is an enumeration. */
1105 if (tsym
->index
== indexNil
)
1106 type_code
= TYPE_CODE_ENUM
;
1108 ecoff_swap_tir_in (bigend
,
1109 &ax
[tsym
->index
].a_ti
,
1111 if (tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1112 type_code
= TYPE_CODE_ENUM
;
1115 if (tsym
->value
> max_value
)
1116 max_value
= tsym
->value
;
1118 else if (tsym
->st
== stBlock
1119 || tsym
->st
== stUnion
1120 || tsym
->st
== stEnum
1121 || tsym
->st
== stStruct
1122 || tsym
->st
== stParsed
) {
1123 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1124 if (tsym
->index
!= 0)
1125 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1128 else complain (&block_member_complaint
, (char *)tsym
->st
);
1131 /* In an stBlock, there is no way to distinguish structs,
1132 unions, and enums at this point. This is a bug in the
1133 original design (that has been fixed with the
1134 recent addition of the stStruct, stUnion, and stEnum
1135 symbol types.) The way you can tell is if/when you
1136 see a variable or field of that type. In that case
1137 the variable's type (in the AUX table) says if the
1138 type is struct, union, or enum,
1139 and points back to the stBlock here.
1140 So you can patch the tag kind up later - but only
1141 if there actually is a variable or field of that type.
1143 So until we know for sure, we will guess at this point.
1145 If the first member has index==indexNil or a void type,
1146 assume we have an enumeration.
1147 Otherwise, if there is more than one member, and all
1148 the members have offset 0, assume we have a union.
1149 Otherwise, assume we have a struct.
1151 The heuristic could guess wrong in the case of
1152 of an enumeration with no members or a union
1153 with one (or zero) members, or when all except the
1154 last field of a struct have width zero.
1155 These are uncommon and/or illegal situations, and
1156 in any case guessing wrong probably doesn't matter much.
1158 But if we later do find out we were wrong,
1159 we fixup the tag kind. Members of an enumeration
1160 must be handled differently from struct/union fields,
1161 and that is harder to patch up, but luckily we
1162 shouldn't need to. (If there are any enumeration
1163 members, we can tell for sure it's an enum here.) */
1165 if (type_code
== TYPE_CODE_UNDEF
)
1166 if (nfields
> 1 && max_value
== 0)
1167 type_code
= TYPE_CODE_UNION
;
1169 type_code
= TYPE_CODE_STRUCT
;
1171 /* If this type was expected, use its partial definition */
1173 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1175 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1178 TYPE_CODE(t
) = type_code
;
1179 TYPE_LENGTH(t
) = sh
->value
;
1180 TYPE_NFIELDS(t
) = nfields
;
1181 TYPE_FIELDS(t
) = f
= (struct field
*)
1182 obstack_alloc (¤t_objfile
-> type_obstack
,
1183 nfields
* sizeof (struct field
));
1185 if (type_code
== TYPE_CODE_ENUM
) {
1186 /* This is a non-empty enum. */
1187 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1188 struct symbol
*enum_sym
;
1189 f
->bitpos
= tsym
->value
;
1191 f
->name
= (char*)tsym
->iss
;
1194 enum_sym
= (struct symbol
*)
1195 obstack_alloc (¤t_objfile
->symbol_obstack
,
1196 sizeof (struct symbol
));
1197 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1198 SYMBOL_NAME (enum_sym
) = f
->name
;
1199 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1200 SYMBOL_TYPE (enum_sym
) = t
;
1201 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1202 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1203 add_symbol(enum_sym
, top_stack
->cur_block
);
1205 /* Skip the stMembers that we've handled. */
1211 /* make this the current type */
1212 top_stack
->cur_type
= t
;
1213 top_stack
->cur_field
= 0;
1214 /* Mark that symbol has a type, and say which one */
1215 sh
->value
= (long) t
;
1218 /* End of local variables shared by struct, union, enum, and
1219 block (as yet unknown struct/union/enum) processing. */
1223 /* beginnning of (code) block. Value of symbol
1224 is the displacement from procedure start */
1226 top_stack
->blocktype
= stBlock
;
1227 b
= new_block(top_stack
->maxsyms
);
1228 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1229 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1230 top_stack
->cur_block
= b
;
1231 add_block(b
, top_stack
->cur_st
);
1234 case stEnd
: /* end (of anything) */
1235 if (sh
->sc
== scInfo
) {
1236 /* Finished with type */
1237 top_stack
->cur_type
= 0;
1238 } else if (sh
->sc
== scText
&&
1239 (top_stack
->blocktype
== stProc
||
1240 top_stack
->blocktype
== stStaticProc
)) {
1241 /* Finished with procedure */
1242 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1243 struct mips_extra_func_info
*e
;
1247 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1249 /* Make up special symbol to contain procedure specific
1251 s
= new_symbol(".gdbinfo.");
1252 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1253 SYMBOL_CLASS(s
) = LOC_CONST
;
1254 SYMBOL_TYPE(s
) = builtin_type_void
;
1255 e
= (struct mips_extra_func_info
*)
1256 obstack_alloc (¤t_objfile
->symbol_obstack
,
1257 sizeof (struct mips_extra_func_info
));
1258 SYMBOL_VALUE(s
) = (int)e
;
1259 e
->numargs
= top_stack
->numargs
;
1260 add_symbol(s
, top_stack
->cur_block
);
1262 /* Reallocate symbols, saving memory */
1263 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1265 /* f77 emits proc-level with address bounds==[0,0],
1266 So look for such child blocks, and patch them. */
1267 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1268 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1269 if (BLOCK_SUPERBLOCK(b_bad
) == b
1270 && BLOCK_START(b_bad
) == top_stack
->procadr
1271 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1272 BLOCK_START(b_bad
) = BLOCK_START(b
);
1273 BLOCK_END(b_bad
) = BLOCK_END(b
);
1276 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1277 /* End of (code) block. The value of the symbol
1278 is the displacement from the procedure`s start
1279 address of the end of this block. */
1280 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1281 (void) shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1282 } else complain (&stEnd_complaint
, (char *)sh
->sc
);
1284 pop_parse_stack(); /* restore previous lexical context */
1287 case stMember
: /* member of struct or union */
1288 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1289 f
->name
= (char*)sh
->iss
;
1290 f
->bitpos
= sh
->value
;
1292 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1295 case stTypedef
: /* type definition */
1296 s
= new_symbol((char *)sh
->iss
);
1297 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1298 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1299 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1300 add_symbol(s
, top_stack
->cur_block
);
1301 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1302 sh
->value
= (long) SYMBOL_TYPE(s
);
1305 case stFile
: /* file name */
1307 top_stack
->blocktype
= sh
->st
;
1310 /* I`ve never seen these for C */
1312 break; /* register relocation */
1314 break; /* forwarding address */
1316 break; /* constant */
1318 complain(&unknown_mips_symtype_complaint
, (char *)sh
->st
);
1325 /* Parse the type information provided in the raw AX entries for
1326 the symbol SH. Return the bitfield size in BS, in case.
1327 We must byte-swap the AX entries before we use them; BIGEND says whether
1328 they are big-endian or little-endian (from fh->fBigendian). */
1330 static struct type
*
1331 parse_type(ax
, bs
, bigend
)
1336 /* Null entries in this map are treated specially */
1337 static struct type
**map_bt
[] =
1339 &builtin_type_void
, /* btNil */
1341 &builtin_type_char
, /* btChar */
1342 &builtin_type_unsigned_char
, /* btUChar */
1343 &builtin_type_short
, /* btShort */
1344 &builtin_type_unsigned_short
, /* btUShort */
1345 &builtin_type_int
, /* btInt */
1346 &builtin_type_unsigned_int
, /* btUInt */
1347 &builtin_type_long
, /* btLong */
1348 &builtin_type_unsigned_long
, /* btULong */
1349 &builtin_type_float
, /* btFloat */
1350 &builtin_type_double
, /* btDouble */
1357 &builtin_type_complex
, /* btComplex */
1358 &builtin_type_double_complex
, /* btDComplex */
1360 &builtin_type_fixed_dec
, /* btFixedDec */
1361 &builtin_type_float_dec
, /* btFloatDec */
1362 &builtin_type_string
, /* btString */
1365 &builtin_type_void
, /* btVoid */
1366 &builtin_type_long_long
, /* btLongLong */
1367 &builtin_type_unsigned_long_long
,/* btULongLong */
1371 struct type
*tp
= 0;
1374 enum type_code type_code
;
1376 /* Use aux as a type information record, map its basic type. */
1378 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1379 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1380 complain (&basic_type_complaint
, (char *)t
->bt
);
1381 return builtin_type_int
;
1383 if (map_bt
[t
->bt
]) {
1384 tp
= *map_bt
[t
->bt
];
1388 /* Cannot use builtin types -- build our own */
1391 tp
= lookup_pointer_type (builtin_type_void
);
1395 type_code
= TYPE_CODE_STRUCT
;
1399 type_code
= TYPE_CODE_UNION
;
1403 type_code
= TYPE_CODE_ENUM
;
1407 type_code
= TYPE_CODE_RANGE
;
1411 type_code
= TYPE_CODE_SET
;
1416 complain (&basic_type_complaint
, (char *)t
->bt
);
1417 return builtin_type_int
;
1421 /* Skip over any further type qualifiers (FIXME). */
1423 /* This is the way it would work if the compiler worked */
1427 ecoff_swap_tir_in (bigend
, ax
, t1
);
1428 } while (t1
->continued
);
1431 /* Move on to next aux */
1435 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1439 /* All these types really point to some (common) MIPS type
1440 definition, and only the type-qualifiers fully identify
1441 them. We'll make the same effort at sharing. */
1442 if (t
->bt
== btIndirect
||
1443 t
->bt
== btStruct
||
1446 t
->bt
== btTypedef
||
1449 char name
[256], *pn
;
1451 /* Try to cross reference this type */
1452 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1453 /* reading .o file ? */
1454 if (UNSAFE_DATA_ADDR(tp
))
1455 tp
= init_type(type_code
, 0, 0, 0, (struct objfile
*) NULL
);
1456 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1457 sprintf(name
, fmt
, pn
);
1459 /* Usually, TYPE_CODE(tp) is already type_code. The main
1460 exception is if we guessed wrong re struct/union/enum. */
1461 if (TYPE_CODE(tp
) != type_code
) {
1462 complain (&bad_tag_guess_complaint
, name
);
1463 TYPE_CODE(tp
) = type_code
;
1465 if (TYPE_NAME(tp
) == NULL
|| strcmp(TYPE_NAME(tp
), name
) != 0)
1466 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1467 ¤t_objfile
-> type_obstack
);
1470 /* Deal with range types */
1471 if (t
->bt
== btRange
) {
1472 TYPE_NFIELDS (tp
) = 2;
1474 (struct field
*) obstack_alloc (¤t_objfile
-> type_obstack
,
1475 2 * sizeof (struct field
));
1476 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1477 ¤t_objfile
-> type_obstack
);
1478 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1480 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1481 ¤t_objfile
-> type_obstack
);
1482 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1486 /* Parse all the type qualifiers now. If there are more
1487 than 6 the game will continue in the next aux */
1489 #define PARSE_TQ(tq) \
1490 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1492 again
: PARSE_TQ(tq0
);
1502 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1508 /* Make up a complex type from a basic one. Type is passed by
1509 reference in TPP and side-effected as necessary. The type
1510 qualifier TQ says how to handle the aux symbols at AX for
1511 the symbol SX we are currently analyzing. BIGEND says whether
1512 aux symbols are big-endian or little-endian.
1513 Returns the number of aux symbols we parsed. */
1516 upgrade_type(tpp
, tq
, ax
, bigend
)
1525 /* Used in array processing */
1534 t
= lookup_pointer_type (*tpp
);
1539 t
= lookup_function_type (*tpp
);
1545 t
= init_type(TYPE_CODE_ARRAY
, 0, 0, 0, (struct objfile
*) NULL
);
1546 TYPE_TARGET_TYPE(t
) = *tpp
;
1548 /* Determine and record the domain type (type of index) */
1549 ecoff_swap_rndx_in (bigend
, ax
, &rndx
);
1554 rf
= AUX_GET_ISYM (bigend
, ax
);
1557 fh
= get_rfd(cur_fd
, rf
);
1559 /* Fields are kept in an array */
1560 /* FIXME - Memory leak! */
1561 if (TYPE_NFIELDS(t
))
1562 TYPE_FIELDS(t
) = (struct field
*)
1563 xrealloc((PTR
) TYPE_FIELDS(t
),
1564 (TYPE_NFIELDS(t
)+1) * sizeof(struct field
));
1566 TYPE_FIELDS(t
) = (struct field
*)
1567 xzalloc(sizeof(struct field
));
1568 f
= &(TYPE_FIELD(t
,TYPE_NFIELDS(t
)));
1570 memset((PTR
)f
, 0, sizeof(struct field
));
1572 /* XXX */ f
->type
= parse_type(id
+ (union aux_ext
*)fh
->iauxBase
,
1573 &f
->bitsize
, bigend
);
1576 lower
= AUX_GET_DNLOW (bigend
, ax
);
1578 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1580 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1582 /* Check whether supplied array element bit size matches
1583 the known size of the element type. If this complaint
1584 ends up not happening, we can remove this code. It's
1585 here because we aren't sure we understand this *&%&$
1587 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1589 /* Most likely an undefined type */
1591 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1594 complain (&array_bitsize_complaint
, (char *)rf
);
1596 TYPE_LENGTH(t
) = (upper
< 0) ? 0 :
1597 (upper
- lower
+ 1) * (rf
>> 3);
1602 /* Volatile -- currently ignored */
1606 /* Const -- currently ignored */
1610 complain (&unknown_type_qual_complaint
, (char *)tq
);
1616 /* Parse a procedure descriptor record PR. Note that the procedure
1617 is parsed _after_ the local symbols, now we just insert the extra
1618 information we need into a special ".gdbinfo." symbol that has already
1619 been placed in the procedure's main block. Note also that images that
1620 have been partially stripped (ld -x) have been deprived
1621 of local symbols, and we have to cope with them here.
1622 The procedure's code ends at BOUND */
1625 parse_procedure (pr
, bound
, have_stabs
)
1630 struct symbol
*s
, *i
;
1631 SYMR
*sh
= (SYMR
*)pr
->isym
;
1633 struct mips_extra_func_info
*e
;
1637 /* Static procedure at address pr->adr. Sigh. */
1638 if (sh
== (SYMR
*)-1) {
1639 complain (&pdr_static_symbol_complaint
, (char *)pr
->adr
);
1642 sh_name
= (char*)sh
->iss
;
1644 s
= lookup_symbol(sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1646 s
= mylookup_symbol(sh_name
, top_stack
->cur_block
,
1647 VAR_NAMESPACE
, LOC_BLOCK
);
1650 b
= SYMBOL_BLOCK_VALUE(s
);
1652 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1656 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1657 s
= new_symbol(sh_name
);
1658 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1659 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1660 /* Donno its type, hope int is ok */
1661 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1662 add_symbol(s
, top_stack
->cur_block
);
1663 /* Wont have symbols for this one */
1665 SYMBOL_BLOCK_VALUE(s
) = b
;
1666 BLOCK_FUNCTION(b
) = s
;
1667 BLOCK_START(b
) = pr
->adr
;
1668 BLOCK_END(b
) = bound
;
1669 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1670 add_block(b
, top_stack
->cur_st
);
1674 i
= mylookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, LOC_CONST
);
1678 e
= (struct mips_extra_func_info
*)SYMBOL_VALUE(i
);
1680 e
->pdr
.isym
= (long)s
;
1684 /* Parse the external symbol ES. Just call parse_symbol() after
1685 making sure we know where the aux are for it. For procedures,
1686 parsing of the PDRs has already provided all the needed
1687 information, we only parse them if SKIP_PROCEDURES is false,
1688 and only if this causes no symbol duplication.
1689 BIGEND says whether aux entries are big-endian or little-endian.
1691 This routine clobbers top_stack->cur_block and ->cur_st. */
1694 parse_external(es
, skip_procedures
, bigend
)
1696 int skip_procedures
;
1701 if (es
->ifd
!= ifdNil
) {
1703 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1704 ax
= (union aux_ext
*)cur_fdr
->iauxBase
;
1706 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1710 /* Reading .o files */
1711 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1713 switch (es
->asym
.st
) {
1715 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1716 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1717 case stLabel
: what
= "label"; n_undef_labels
++; break;
1718 default : what
= "symbol"; break;
1721 /* FIXME: Turn this into a complaint? */
1723 printf_filtered("Warning: %s `%s' is undefined (in %s)\n",
1724 what
, es
->asym
.iss
, fdr_name((char *)cur_fdr
->rss
));
1728 switch (es
->asym
.st
) {
1730 /* If we have full symbols we do not need more */
1731 if (skip_procedures
)
1733 if (mylookup_symbol ((char *)es
->asym
.iss
, top_stack
->cur_block
,
1734 VAR_NAMESPACE
, LOC_BLOCK
))
1740 * Note that the case of a symbol with indexNil
1741 * must be handled anyways by parse_symbol().
1743 parse_symbol(&es
->asym
, ax
, bigend
);
1750 /* Parse the line number info for file descriptor FH into
1751 GDB's linetable LT. MIPS' encoding requires a little bit
1752 of magic to get things out. Note also that MIPS' line
1753 numbers can go back and forth, apparently we can live
1754 with that and do not need to reorder our linetables */
1759 struct linetable
*lt
;
1761 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1763 int delta
, count
, lineno
= 0;
1769 /* Scan by procedure descriptors */
1771 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1774 /* No code for this one */
1775 if (pr
->iline
== ilineNil
||
1776 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1779 * Aurgh! To know where to stop expanding we
1782 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1783 if (pr
[l
].iline
!= -1)
1785 if (l
== (fh
->cpd
- j
))
1790 * When procedures are moved around the linenumbers
1791 * are attributed to the next procedure up
1793 if (pr
->iline
>= halt
) continue;
1795 base
= (unsigned char*)pr
->cbLineOffset
;
1796 l
= pr
->adr
>> 2; /* in words */
1797 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1798 for (lineno
= pr
->lnLow
; l
< halt
;) {
1799 count
= *base
& 0x0f;
1800 delta
= *base
++ >> 4;
1804 delta
= (base
[0] << 8) | base
[1];
1805 if (delta
>= 0x8000)
1809 lineno
+= delta
;/* first delta is 0 */
1810 k
= add_line(lt
, lineno
, l
, k
);
1816 /* Master parsing procedure for first-pass reading of file symbols
1817 into a partial_symtab.
1819 Parses the symtab described by the global symbolic header CUR_HDR.
1820 END_OF_TEXT_SEG gives the address just after the text segment for
1821 the symtab we are reading. */
1824 parse_partial_symbols (end_of_text_seg
, objfile
)
1825 int end_of_text_seg
;
1826 struct objfile
*objfile
;
1829 HDRR
*hdr
= cur_hdr
;
1830 /* Running pointers */
1834 struct partial_symtab
*pst
;
1836 int past_first_source_file
= 0;
1838 /* List of current psymtab's include files */
1839 char **psymtab_include_list
;
1840 int includes_allocated
;
1843 struct pst_map
* fdr_to_pst
;
1844 /* Index within current psymtab dependency list */
1845 struct partial_symtab
**dependency_list
;
1846 int dependencies_used
, dependencies_allocated
;
1847 struct cleanup
*old_chain
;
1849 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1850 sizeof(EXTR
*) * hdr
->iextMax
);
1852 includes_allocated
= 30;
1854 psymtab_include_list
= (char **) alloca (includes_allocated
*
1856 next_symbol_text_func
= mips_next_symbol_text
;
1858 dependencies_allocated
= 30;
1859 dependencies_used
= 0;
1861 (struct partial_symtab
**) alloca (dependencies_allocated
*
1862 sizeof (struct partial_symtab
*));
1864 last_source_file
= 0;
1869 * Only parse the Local and External symbols, and the Relative FDR.
1870 * Fixup enough of the loader symtab to be able to use it.
1871 * Allocate space only for the file's portions we need to
1876 max_glevel
= MIN_GLEVEL
;
1878 /* Allocate the map FDR -> PST.
1879 Minor hack: -O3 images might claim some global data belongs
1880 to FDR -1. We`ll go along with that */
1881 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1882 old_chain
= make_cleanup (free
, fdr_to_pst
);
1885 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1886 fdr_to_pst
[-1].pst
= pst
;
1890 /* Pass 1 over external syms: Presize and partition the list */
1891 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1892 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1893 fdr_to_pst
[esh
->ifd
].n_globals
++;
1896 /* Pass 1.5 over files: partition out global symbol space */
1898 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1899 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1900 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1901 fdr_to_pst
[f_idx
].n_globals
= 0;
1904 /* Pass 2 over external syms: fill in external symbols */
1905 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1906 enum minimal_symbol_type ms_type
= mst_text
;
1907 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1909 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1910 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1912 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1915 switch (esh
->asym
.st
) {
1924 ms_type
= mst_unknown
;
1925 complain (&unknown_ext_complaint
, (char *)esh
->asym
.iss
);
1927 prim_record_minimal_symbol ((char *)esh
->asym
.iss
,
1932 /* Pass 3 over files, over local syms: fill in static symbols */
1933 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1934 struct partial_symtab
*save_pst
;
1936 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1938 if (fh
->csym
== 0) {
1939 fdr_to_pst
[f_idx
].pst
= NULL
;
1942 pst
= start_psymtab_common (objfile
, 0, (char*)fh
->rss
,
1943 fh
->cpd
? fh
->adr
: 0,
1944 objfile
->global_psymbols
.next
,
1945 objfile
->static_psymbols
.next
);
1946 pst
->read_symtab_private
= (char *)
1947 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1950 /* Make everything point to everything. */
1951 FDR_IDX(pst
) = f_idx
;
1952 fdr_to_pst
[f_idx
].pst
= pst
;
1953 fh
->ioptBase
= (int)pst
;
1955 CUR_HDR(pst
) = cur_hdr
;
1957 /* The way to turn this into a symtab is to call... */
1958 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1960 pst
->texthigh
= pst
->textlow
;
1962 #if 0 /* This is done in start_psymtab_common */
1963 pst
->globals_offset
= global_psymbols
.next
- global_psymbols
.list
;
1964 pst
->statics_offset
= static_psymbols
.next
- static_psymbols
.list
;
1966 pst
->n_global_syms
= 0;
1967 pst
->n_static_syms
= 0;
1970 /* The second symbol must be @stab.
1971 This symbol is emitted by mips-tfile to signal
1972 that the current object file uses encapsulated stabs
1973 instead of mips ecoff for local symbols.
1974 (It is the second symbol because the first symbol is
1975 the stFile used to signal the start of a file). */
1977 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
),
1978 stabs_symbol
) == 0) {
1979 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1982 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1983 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1984 if (!MIPS_IS_STAB(sh
)) {
1985 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
1986 long procaddr
= sh
->value
;
1987 sh
= AUX_GET_ISYM (fh
->fBigendian
,
1988 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
1989 + (SYMR
*) fh
->isymBase
- 1;
1990 if (sh
->st
== stEnd
) {
1991 long high
= procaddr
+ sh
->value
;
1992 if (high
> pst
->texthigh
)
1993 pst
->texthigh
= high
;
1998 #define SET_NAMESTRING() namestring = (char*)sh->iss
1999 #define CUR_SYMBOL_TYPE type_code
2000 #define CUR_SYMBOL_VALUE sh->value
2001 #define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
2003 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2004 #define addr 0 /* FIXME, should be offset of addresses */
2005 #define HANDLE_RBRAC(val) \
2006 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2007 #include "partial-stab.h"
2012 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2014 enum address_class
class;
2015 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2017 if (MIPS_IS_STAB(sh
)) {
2022 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
2023 sh
->index
== 0xfffff) {
2024 /* FIXME, premature? */
2029 name
= (char *)(sh
->iss
);
2036 case stProc
: /* Asm labels apparently */
2037 case stStaticProc
: /* Function */
2038 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2039 VAR_NAMESPACE
, LOC_BLOCK
,
2040 objfile
->static_psymbols
, sh
->value
);
2041 /* Skip over procedure to next one. */
2042 if (sh
->index
>= hdr
->iauxMax
)
2044 /* Should not happen, but does when cross-compiling
2045 with the MIPS compiler. FIXME -- pull later. */
2046 complain (&index_complaint
, name
);
2047 new_sdx
= cur_sdx
+1; /* Don't skip at all */
2050 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2051 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
2052 procaddr
= sh
->value
;
2054 if (new_sdx
<= cur_sdx
)
2056 /* This should not happen either... FIXME. */
2057 complain (&aux_index_complaint
, name
);
2058 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2062 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
2063 if (sh
->st
!= stEnd
)
2065 high
= procaddr
+ sh
->value
;
2066 if (high
> pst
->texthigh
)
2067 pst
->texthigh
= high
;
2070 case stStatic
: /* Variable */
2074 case stTypedef
: /* Typedef */
2075 class = LOC_TYPEDEF
;
2078 case stConstant
: /* Constant decl */
2085 case stBlock
: /* { }, str, un, enum*/
2086 if (sh
->sc
== scInfo
) {
2087 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2088 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2089 objfile
->static_psymbols
, sh
->value
);
2091 /* Skip over the block */
2092 cur_sdx
= sh
->index
;
2095 case stFile
: /* File headers */
2096 case stLabel
: /* Labels */
2097 case stEnd
: /* Ends of files */
2101 /* Both complaints are valid: one gives symbol name,
2102 the other the offending symbol type. */
2103 complain (&unknown_sym_complaint
, (char *)sh
->iss
);
2104 complain (&unknown_st_complaint
, (char *)sh
->st
);
2108 /* Use this gdb symbol */
2109 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2110 VAR_NAMESPACE
, class,
2111 objfile
->static_psymbols
, sh
->value
);
2113 cur_sdx
++; /* Go to next file symbol */
2116 /* Now do enter the external symbols. */
2117 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2118 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2119 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2120 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2121 for (; --cur_sdx
>= 0; ext_ptr
++) {
2122 register struct partial_symbol
*psym
;
2123 enum address_class
class;
2125 if ((*ext_ptr
)->ifd
!= f_idx
)
2127 sh
= &(*ext_ptr
)->asym
;
2136 complain (&unknown_ext_complaint
, (char *)sh
->iss
);
2137 /* Fall through, pretend it's global. */
2142 if (objfile
->global_psymbols
.next
>=
2143 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2144 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2145 psym
= objfile
->global_psymbols
.next
++;
2146 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2147 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2148 SYMBOL_CLASS (psym
) = class;
2149 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2153 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2154 -1, save_pst
->texthigh
,
2155 dependency_list
, dependencies_used
);
2156 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2157 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2159 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2160 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2164 /* Mark the last code address, and remember it for later */
2165 hdr
->cbDnOffset
= end_of_text_seg
;
2167 /* Now scan the FDRs for dependencies */
2168 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2170 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2171 pst
= fdr_to_pst
[f_idx
].pst
;
2173 /* This should catch stabs-in-ecoff. */
2177 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2178 /* ...then presumably a .h file: drop reverse depends .h->.c */
2179 for (; s_id0
< fh
->crfd
; s_id0
++) {
2180 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2182 s_id0
++; /* Skip self-dependency */
2187 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2188 pst
->dependencies
= (struct partial_symtab
**)
2189 obstack_alloc (&objfile
->psymbol_obstack
,
2190 pst
->number_of_dependencies
*
2191 sizeof (struct partial_symtab
*));
2192 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2193 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2194 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2195 complain(&bad_file_number_complaint
, (char *)*rh
);
2197 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2200 do_cleanups (old_chain
);
2205 /* Do the initial analisys of the F_IDX-th file descriptor.
2206 Allocates a partial symtab for it, and builds the list
2207 of dependent files by recursion. LEV says at which level
2208 of recursion we are called (to pretty up debug traces) */
2210 static struct partial_symtab
*
2211 parse_fdr(f_idx
, lev
, objfile
)
2214 struct objfile
*objfile
;
2217 register struct partial_symtab
*pst
;
2220 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2222 /* Use this to indicate into which symtab this file was parsed */
2224 return (struct partial_symtab
*) fh
->ioptBase
;
2226 /* Debuggability level */
2227 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2228 max_glevel
= fh
->glevel
;
2230 /* Make a new partial_symtab */
2231 pst
= new_psymtab(fh
->rss
, objfile
);
2236 pst
->textlow
= fh
->adr
;
2237 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2240 /* Make everything point to everything. */
2241 FDR_IDX(pst
) = f_idx
;
2242 fdr_to_pst
[f_idx
].pst
= pst
;
2243 fh
->ioptBase
= (int)pst
;
2245 /* Analyze its dependencies */
2250 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2251 /* ...then presumably a .h file: drop reverse depends .h->.c */
2252 for (; s_id0
< fh
->crfd
; s_id0
++) {
2253 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2255 s_id0
++; /* Skip self-dependency */
2260 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2261 pst
->dependencies
= (struct partial_symtab
**)
2262 obstack_alloc (&objfile
->psymbol_obstack
,
2263 pst
->number_of_dependencies
*
2264 sizeof (struct partial_symtab
*));
2265 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2266 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2268 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2276 mips_next_symbol_text ()
2279 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2282 /* Ancillary function to psymtab_to_symtab(). Does all the work
2283 for turning the partial symtab PST into a symtab, recurring
2284 first on all dependent psymtabs. The argument FILENAME is
2285 only passed so we can see in debug stack traces what file
2288 This function has a split personality, based on whether the
2289 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2290 The flow of control and even the memory allocation differs. FIXME. */
2293 psymtab_to_symtab_1(pst
, filename
)
2294 struct partial_symtab
*pst
;
2300 struct linetable
*lines
;
2307 /* Read in all partial symbtabs on which this one is dependent.
2308 NOTE that we do have circular dependencies, sigh. We solved
2309 that by setting pst->readin before this point. */
2311 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2312 if (!pst
->dependencies
[i
]->readin
) {
2313 /* Inform about additional files to be read in. */
2316 fputs_filtered (" ", stdout
);
2318 fputs_filtered ("and ", stdout
);
2320 printf_filtered ("%s...",
2321 pst
->dependencies
[i
]->filename
);
2322 wrap_here (""); /* Flush output */
2325 /* We only pass the filename for debug purposes */
2326 psymtab_to_symtab_1(pst
->dependencies
[i
],
2327 pst
->dependencies
[i
]->filename
);
2330 /* Now read the symbols for this symtab */
2332 current_objfile
= pst
->objfile
;
2333 cur_fd
= FDR_IDX(pst
);
2334 fh
= (cur_fd
== -1) ? 0 : (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2337 /* BOUND is the highest core address of this file's procedures */
2338 bound
= (cur_fd
== cur_hdr
->ifdMax
- 1) ?
2339 cur_hdr
->cbDnOffset
:
2342 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2343 if (fh
&& fh
->csym
>= 2
2344 && strcmp((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)
2348 * This symbol table contains stabs-in-ecoff entries.
2354 /* Parse local symbols first */
2356 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2358 current_objfile
= NULL
;
2361 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2362 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2363 char *name
= (char*)sh
->iss
;
2364 CORE_ADDR valu
= sh
->value
;
2365 if (MIPS_IS_STAB(sh
)) {
2366 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2367 process_one_symbol (type_code
, 0, valu
, name
, /*FIXME*/ 0,
2369 if (type_code
== N_FUN
) {
2370 /* Make up special symbol to contain
2371 procedure specific info */
2372 struct mips_extra_func_info
*e
=
2373 (struct mips_extra_func_info
*)
2374 obstack_alloc(¤t_objfile
->symbol_obstack
,
2375 sizeof(struct mips_extra_func_info
));
2376 struct symbol
*s
= new_symbol(".gdbinfo.");
2377 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2378 SYMBOL_CLASS(s
) = LOC_CONST
;
2379 SYMBOL_TYPE(s
) = builtin_type_void
;
2380 SYMBOL_VALUE(s
) = (int)e
;
2381 add_symbol_to_list (s
, &local_symbols
);
2384 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2385 /* Handle encoded stab line number. */
2386 record_line (current_subfile
, sh
->index
, valu
);
2388 else complain (&stab_unknown_complaint
, (char *)sh
->iss
);
2390 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2392 /* Sort the symbol table now, we are done adding symbols to it.
2393 We must do this before parse_procedure calls lookup_symbol. */
2394 sort_symtab_syms(st
);
2396 /* This may not be necessary for stabs symtabs. FIXME. */
2399 /* Fill in procedure info next. We need to look-ahead to
2400 find out where each procedure's code ends. */
2402 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2403 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2404 parse_procedure (pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 1);
2409 * This symbol table contains ordinary ecoff entries.
2416 /* How many symbols will we need */
2417 /* FIXME, this does not count enum values. */
2418 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2421 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2423 f_max
+= fh
->csym
+ fh
->cpd
;
2424 maxlines
= 2 * fh
->cline
;
2425 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2428 lines
= LINETABLE(st
);
2429 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2430 if (pending_list
== 0) {
2431 pending_list
= (struct mips_pending
**)
2432 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2433 cur_hdr
->cbOptOffset
= (int)pending_list
;
2436 /* Get a new lexical context */
2439 top_stack
->cur_st
= st
;
2440 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(st
),
2442 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2443 BLOCK_END(top_stack
->cur_block
) = 0;
2444 top_stack
->blocktype
= stFile
;
2445 top_stack
->maxsyms
= 2*f_max
;
2446 top_stack
->cur_type
= 0;
2447 top_stack
->procadr
= 0;
2448 top_stack
->numargs
= 0;
2454 /* Parse local symbols first */
2456 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2457 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2458 cur_sdx
+= parse_symbol(sh
, (union aux_ent
*)fh
->iauxBase
,
2462 /* Linenumbers. At the end, check if we can save memory */
2464 parse_lines(fh
, lines
);
2465 if (lines
->nitems
< fh
->cline
)
2466 lines
= shrink_linetable(lines
);
2468 /* Fill in procedure info next. We need to look-ahead to
2469 find out where each procedure's code ends. */
2471 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2472 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2473 parse_procedure(pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 0);
2477 LINETABLE(st
) = lines
;
2479 /* .. and our share of externals.
2480 XXX use the global list to speed up things here. how?
2481 FIXME, Maybe quit once we have found the right number of ext's? */
2482 top_stack
->cur_st
= st
;
2483 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
2485 top_stack
->blocktype
= stFile
;
2486 top_stack
->maxsyms
=
2487 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2489 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2490 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2491 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2493 /* If there are undefined, tell the user */
2494 if (n_undef_symbols
) {
2495 printf_filtered("File %s contains %d unresolved references:",
2496 st
->filename
, n_undef_symbols
);
2497 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2498 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2499 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2504 /* Sort the symbol table now, we are done adding symbols to it.*/
2505 sort_symtab_syms(st
);
2510 /* Now link the psymtab and the symtab. */
2513 current_objfile
= NULL
;
2516 /* Ancillary parsing procedures. */
2518 /* Lookup the type at relative index RN. Return it in TPP
2519 if found and in any event come up with its name PNAME.
2520 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2521 Return value says how many aux symbols we ate. */
2524 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2527 enum type_code type_code
; /* Use to alloc new type if none is found. */
2535 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2537 /* Escape index means 'the next one' */
2538 if (rn
->rfd
== 0xfff) {
2540 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2547 *pname
= "<undefined>";
2550 * Find the relative file descriptor and the symbol in it
2552 FDR
*fh
= get_rfd(cur_fd
, rf
);
2557 * If we have processed this symbol then we left a forwarding
2558 * pointer to the corresponding GDB symbol. If not, we`ll put
2559 * it in a list of pending symbols, to be processed later when
2560 * the file f will be. In any event, we collect the name for
2561 * the type here. Which is why we made a first pass at
2564 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2566 /* Careful, we might be looking at .o files */
2567 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2570 /* Have we parsed it ? */
2571 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2572 t
= (struct type
*) sh
->value
;
2575 /* Avoid duplicates */
2576 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2580 *tpp
= init_type(type_code
, 0, 0, 0, (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, 0, (struct objfile
*) NULL
);
2998 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
3000 /* Need a block to allocate .gdbinfo. in */
3002 SYMBOL_BLOCK_VALUE(s
) = b
;
3003 BLOCK_START(b
) = sigtramp_address
;
3004 BLOCK_END(b
) = sigtramp_end
;
3005 BLOCK_FUNCTION(b
) = s
;
3006 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
3010 /* Make a .gdbinfo. for it */
3012 struct mips_extra_func_info
*e
=
3013 (struct mips_extra_func_info
*)
3014 xzalloc(sizeof(struct mips_extra_func_info
));
3016 e
->numargs
= 0; /* the kernel thinks otherwise */
3017 /* align_longword(sigcontext + SIGFRAME) */
3018 e
->pdr
.frameoffset
= 0x150;
3019 e
->pdr
.framereg
= SP_REGNUM
;
3021 e
->pdr
.regmask
= -2;
3022 e
->pdr
.regoffset
= -(41 * sizeof(int));
3023 e
->pdr
.fregmask
= -1;
3024 e
->pdr
.fregoffset
= -(37 * sizeof(int));
3025 e
->pdr
.isym
= (long)s
;
3027 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3028 s
= new_symbol(".gdbinfo.");
3029 SYMBOL_VALUE(s
) = (int) e
;
3030 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
3031 SYMBOL_CLASS(s
) = LOC_CONST
;
3032 SYMBOL_TYPE(s
) = builtin_type_void
;
3033 current_objfile
= NULL
;
3036 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
3039 /* Initialization */
3041 static struct sym_fns ecoff_sym_fns
=
3043 "ecoff", /* sym_name: name or name prefix of BFD target type */
3044 5, /* sym_namelen: number of significant sym_name chars */
3045 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3046 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
3047 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
3048 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
3049 NULL
/* next: pointer to next struct sym_fns */
3054 _initialize_mipsread ()
3056 add_symtab_fns (&ecoff_sym_fns
);
3058 /* Missing basic types */
3060 builtin_type_string
=
3061 init_type(TYPE_CODE_PASCAL_ARRAY
,
3062 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3064 (struct objfile
*) NULL
);
3065 builtin_type_complex
=
3066 init_type(TYPE_CODE_FLT
,
3067 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3069 (struct objfile
*) NULL
);
3070 builtin_type_double_complex
=
3071 init_type(TYPE_CODE_FLT
,
3072 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3073 0, "double complex",
3074 (struct objfile
*) NULL
);
3075 builtin_type_fixed_dec
=
3076 init_type(TYPE_CODE_INT
,
3077 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3079 (struct objfile
*) NULL
);
3080 builtin_type_float_dec
=
3081 init_type(TYPE_CODE_FLT
,
3082 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3083 0, "floating decimal",
3084 (struct objfile
*) NULL
);