1 /* Read a symbol table in MIPS' format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major
4 work by Per Bothner and John Gilmore at Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This module provides three functions: mipscoff_symfile_init,
23 which initializes to read a symbol file; mipscoff_new_init, which
24 discards existing cached information when all symbols are being
25 discarded; and mipscoff_symfile_read, which reads a symbol table
28 mipscoff_symfile_read only does the minimum work necessary for letting the
29 user "name" things symbolically; it does not read the entire symtab.
30 Instead, it reads the external and static symbols and puts them in partial
31 symbol tables. When more extensive information is requested of a
32 file, the corresponding partial symbol table is mutated into a full
33 fledged symbol table by going back and reading the symbols
34 for real. mipscoff_psymtab_to_symtab() is called indirectly through
35 a pointer in the psymtab to do this.
37 ECOFF symbol tables are mostly written in the byte order of the
38 target machine. However, one section of the table (the auxiliary
39 symbol information) is written in the host byte order. There is a
40 bit in the other symbol info which describes which host byte order
41 was used. ECOFF thereby takes the trophy from Intel `b.out' for
42 the most brain-dead adaptation of a file format to byte order.
44 This module can read all four of the known byte-order combinations,
45 on any type of host. However, it does make (and check) the assumption
46 that the external form of a symbol table structure (on disk)
47 occupies the same number of bytes as the internal form (in a struct).
48 Fixing this is possible but requires larger structural changes. */
50 #define TM_FILE_OVERRIDE
60 #include "stabsread.h"
61 #include "complaints.h"
64 #include <sys/types.h>
69 #include <sys/param.h>
74 #include "gdb-stabs.h"
76 #include "coff/mips.h" /* COFF-like aspects of ecoff files */
77 #include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
79 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
80 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
81 #include "aout/aout64.h"
82 #include "aout/stab_gnu.h" /* STABS information */
83 #include "expression.h"
84 #include "language.h" /* Needed inside partial-stab.h */
87 struct external_filehdr f
;
88 struct external_aouthdr a
;
91 /* Each partial symbol table entry contains a pointer to private data for the
92 read_symtab() function to use when expanding a partial symbol table entry
93 to a full symbol table entry.
95 For mipsread this structure contains the index of the FDR that this psymtab
96 represents and a pointer to the symbol table header HDRR from the symbol
97 file that the psymtab was created from. */
99 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
100 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
101 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
106 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
107 int extern_count
; /* Size of extern_tab. */
110 /* Things we import explicitly from other modules */
112 extern int info_verbose
;
114 /* Various complaints about symbol reading that don't abort the process */
116 struct complaint bad_file_number_complaint
=
117 {"bad file number %d", 0, 0};
119 struct complaint index_complaint
=
120 {"bad aux index at symbol %s", 0, 0};
122 struct complaint aux_index_complaint
=
123 {"bad proc end in aux found from symbol %s", 0, 0};
125 struct complaint block_index_complaint
=
126 {"bad aux index at block symbol %s", 0, 0};
128 struct complaint unknown_ext_complaint
=
129 {"unknown external symbol %s", 0, 0};
131 struct complaint unknown_sym_complaint
=
132 {"unknown local symbol %s", 0, 0};
134 struct complaint unknown_st_complaint
=
135 {"with type %d", 0, 0};
137 struct complaint block_overflow_complaint
=
138 {"block containing %s overfilled", 0, 0};
140 struct complaint basic_type_complaint
=
141 {"cannot map MIPS basic type 0x%x", 0, 0};
143 struct complaint unknown_type_qual_complaint
=
144 {"unknown type qualifier 0x%x", 0, 0};
146 struct complaint array_bitsize_complaint
=
147 {"size of array target type not known, assuming %d bits", 0, 0};
149 struct complaint bad_tag_guess_complaint
=
150 {"guessed tag type of %s incorrectly", 0, 0};
152 struct complaint block_member_complaint
=
153 {"declaration block contains unhandled symbol type %d", 0, 0};
155 struct complaint stEnd_complaint
=
156 {"stEnd with storage class %d not handled", 0, 0};
158 struct complaint unknown_mips_symtype_complaint
=
159 {"unknown symbol type 0x%x", 0, 0};
161 struct complaint stab_unknown_complaint
=
162 {"unknown stabs symbol %s", 0, 0};
164 struct complaint pdr_for_nonsymbol_complaint
=
165 {"PDR for %s, but no symbol", 0, 0};
167 struct complaint pdr_static_symbol_complaint
=
168 {"can't handle PDR for static proc at 0x%x", 0, 0};
170 /* Macros and extra defs */
172 /* Already-parsed symbols are marked specially */
174 #define stParsed stType
176 /* Puns: hard to find whether -g was used and how */
178 #define MIN_GLEVEL GLEVEL_0
179 #define compare_glevel(a,b) \
180 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
181 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
183 /* When looking at .o files, avoid tripping over zero pointers.
184 FIXME; places that use this should be fixed to convert from
185 external to internal format, rather than examining in-place. */
187 #define UNSAFE_DATA_ADDR(p) ((p) == 0)
189 /* Things that really are local to this module */
191 /* Remember what we deduced to be the source language of this psymtab. */
193 static enum language psymtab_language
= language_unknown
;
195 /* MIPS symtab header for the current file */
197 static HDRR
*cur_hdr
;
199 /* Pointer to current file decriptor record, and its index */
204 /* Index of current symbol */
208 /* Note how much "debuggable" this image is. We would like
209 to see at least one FDR with full symbols */
214 /* When examining .o files, report on undefined symbols */
216 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
218 /* Pseudo symbol to use when putting stabs into the symbol table. */
220 static char stabs_symbol
[] = STABS_SYMBOL
;
222 /* Extra builtin types */
224 struct type
*builtin_type_complex
;
225 struct type
*builtin_type_double_complex
;
226 struct type
*builtin_type_fixed_dec
;
227 struct type
*builtin_type_float_dec
;
228 struct type
*builtin_type_string
;
230 /* Forward declarations */
233 fixup_symtab
PARAMS ((HDRR
*, char *, file_ptr
, bfd
*));
236 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
239 read_the_mips_symtab
PARAMS ((bfd
*, CORE_ADDR
*));
242 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
245 parse_partial_symbols
PARAMS ((int, struct objfile
*,
246 struct section_offsets
*));
249 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
253 fixup_sigtramp
PARAMS ((void));
255 static struct symbol
*
256 new_symbol
PARAMS ((char *));
259 new_type
PARAMS ((char *));
261 static struct block
*
262 new_block
PARAMS ((int));
264 static struct symtab
*
265 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
267 static struct linetable
*
268 new_linetable
PARAMS ((int));
270 static struct blockvector
*
271 new_bvect
PARAMS ((int));
274 parse_type
PARAMS ((union aux_ext
*, int *, int));
276 static struct symbol
*
277 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
278 enum address_class
));
280 static struct block
*
281 shrink_block
PARAMS ((struct block
*, struct symtab
*));
284 xzalloc
PARAMS ((unsigned int));
287 sort_blocks
PARAMS ((struct symtab
*));
290 compare_blocks
PARAMS ((const void *, const void *));
292 static struct partial_symtab
*
293 new_psymtab
PARAMS ((char *, struct objfile
*));
296 static struct partial_symtab
*
297 parse_fdr
PARAMS ((int, int, struct objfile
*));
301 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
304 add_block
PARAMS ((struct block
*, struct symtab
*));
307 add_symbol
PARAMS ((struct symbol
*, struct block
*));
310 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
312 static struct linetable
*
313 shrink_linetable
PARAMS ((struct linetable
*));
316 mips_next_symbol_text
PARAMS ((void));
318 /* Things we export to other modules */
320 /* Address bounds for the signal trampoline in inferior, if any */
321 /* FIXME: Nothing really seems to use this. Why is it here? */
323 CORE_ADDR sigtramp_address
, sigtramp_end
;
326 mipscoff_new_init (ignore
)
327 struct objfile
*ignore
;
332 mipscoff_symfile_init (objfile
)
333 struct objfile
*objfile
;
335 if (objfile
-> sym_private
!= NULL
)
337 mfree (objfile
-> md
, objfile
-> sym_private
);
339 objfile
-> sym_private
= NULL
;
343 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
344 struct objfile
*objfile
;
345 struct section_offsets
*section_offsets
;
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
, section_offsets
);
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
, (file_ptr
) 0, 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 DO NOT DELETE THESE ENTRIES, OR COMMENT THEM OUT, JUST BECAUSE SOME
531 "LINT" OR COMPILER THINKS THEY ARE UNUSED! Thank you. */
532 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
533 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
534 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
535 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
536 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
537 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
538 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
539 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
540 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
541 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
542 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
543 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
545 /* Swap in the header record. */
546 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
549 * These fields are useless (and empty) by now:
550 * hdr->cbDnOffset, hdr->cbOptOffset
551 * We use them for other internal purposes.
554 hdr
->cbOptOffset
= 0;
557 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
571 /* Fix all the RFD's. */
572 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
573 for (i
= 0; i
< hdr
->crfd
; i
++) {
574 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
577 /* Fix all string pointers inside the symtab, and
578 the FDR records. Also fix other miscellany. */
580 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
581 register unsigned code_offset
;
583 /* Header itself, and strings */
584 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
586 /* Swap in the FDR */
587 ecoff_swap_fdr_in (abfd
, fh
, fh
);
589 fh
->issBase
+= hdr
->cbSsOffset
;
591 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
594 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
596 /* FIXME! Probably don't want to do this here! */
597 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
598 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
599 ecoff_swap_sym_in (abfd
, sh
, sh
);
601 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
607 /* cannot fix fh->ipdFirst because it is a short */
608 #define IPDFIRST(h,fh) \
609 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
611 /* Optional symbols (actually used for partial_symtabs) */
617 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
618 /* Relative file descriptor table */
619 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
623 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
625 /* Procedure symbols. (XXX This should be done later) */
626 code_offset
= fh
->adr
;
627 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
628 unsigned name
, only_ext
;
630 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
631 ecoff_swap_pdr_in (abfd
, pr
, pr
);
633 /* Simple rule to find files linked "-x" */
634 only_ext
= fh
->rss
== -1;
636 if (pr
->isym
== -1) {
637 /* static function */
641 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
642 sh
= &((EXTR
*)name
)->asym
;
646 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
647 /* Included code ? */
648 if (s_idx
== 0 && pr
->adr
!= 0)
649 code_offset
-= pr
->adr
;
652 /* Turn index into a pointer */
655 /* Fix line numbers */
656 pr
->cbLineOffset
+= fh
->cbLineOffset
;
658 /* Relocate address */
660 pr
->adr
+= code_offset
;
664 /* External symbols: swap in, and fix string */
665 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
666 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
667 ecoff_swap_ext_in (abfd
, esh
, esh
);
668 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
673 /* Find a file descriptor given its index RF relative to a file CF */
681 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
682 /* Object files do not have the RFD table, all refs are absolute */
684 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
685 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
686 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
689 /* Return a safer print NAME for a file descriptor */
695 if (name
== (char *) -1)
696 return "<stripped file>";
697 if (UNSAFE_DATA_ADDR(name
))
703 /* Read in and parse the symtab of the file OBJFILE. Symbols from
704 different sections are relocated via the SECTION_OFFSETS. */
707 read_mips_symtab (objfile
, section_offsets
)
708 struct objfile
*objfile
;
709 struct section_offsets
*section_offsets
;
711 CORE_ADDR end_of_text_seg
;
713 read_the_mips_symtab(objfile
->obfd
, &end_of_text_seg
);
715 parse_partial_symbols(end_of_text_seg
, objfile
, section_offsets
);
719 * Check to make sure file was compiled with -g.
720 * If not, warn the user of this limitation.
722 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
723 if (max_gdbinfo
== 0)
725 "\n%s not compiled with -g, debugging support is limited.\n",
728 "You should compile with -g2 or -g3 for best debugging support.\n");
734 /* Local utilities */
736 /* Map of FDR indexes to partial symtabs */
739 struct partial_symtab
*pst
; /* the psymtab proper */
740 int n_globals
; /* exported globals (external symbols) */
741 int globals_offset
; /* cumulative */
745 /* Utility stack, used to nest procedures and blocks properly.
746 It is a doubly linked list, to avoid too many alloc/free.
747 Since we might need it quite a few times it is NOT deallocated
750 static struct parse_stack
{
751 struct parse_stack
*next
, *prev
;
752 struct symtab
*cur_st
; /* Current symtab. */
753 struct block
*cur_block
; /* Block in it. */
754 int blocktype
; /* What are we parsing. */
755 int maxsyms
; /* Max symbols in this block. */
756 struct type
*cur_type
; /* Type we parse fields for. */
757 int cur_field
; /* Field number in cur_type. */
758 int procadr
; /* Start addres of this procedure */
759 int numargs
; /* Its argument count */
760 } *top_stack
; /* Top stack ptr */
763 /* Enter a new lexical context */
768 struct parse_stack
*new;
770 /* Reuse frames if possible */
771 if (top_stack
&& top_stack
->prev
)
772 new = top_stack
->prev
;
774 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
775 /* Initialize new frame with previous content */
777 register struct parse_stack
*prev
= new->prev
;
780 top_stack
->prev
= new;
782 new->next
= top_stack
;
787 /* Exit a lexical context */
795 top_stack
= top_stack
->next
;
799 /* Cross-references might be to things we haven't looked at
800 yet, e.g. type references. To avoid too many type
801 duplications we keep a quick fixup table, an array
802 of lists of references indexed by file descriptor */
804 static struct mips_pending
{
805 struct mips_pending
*next
; /* link */
806 SYMR
*s
; /* the symbol */
807 struct type
*t
; /* its partial type descriptor */
811 /* Check whether we already saw symbol SH in file FH as undefined */
813 static struct mips_pending
*
814 is_pending_symbol(fh
, sh
)
818 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
819 register struct mips_pending
*p
;
821 /* Linear search is ok, list is typically no more than 10 deep */
822 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
828 /* Add a new undef symbol SH of type T */
831 add_pending(fh
, sh
, t
)
836 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
837 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
839 /* Make sure we do not make duplicates */
841 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
844 p
->next
= pending_list
[f_idx
];
845 pending_list
[f_idx
] = p
;
847 sh
->reserved
= 1; /* for quick check */
850 /* Throw away undef entries when done with file index F_IDX */
851 /* FIXME -- storage leak. This is never called!!! --gnu */
859 register struct mips_pending
*p
, *q
;
861 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
865 pending_list
[f_idx
] = 0;
871 prepend_tag_kind(tag_name
, type_code
)
873 enum type_code type_code
;
881 case TYPE_CODE_STRUCT
:
884 case TYPE_CODE_UNION
:
891 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
892 strlen(prefix
) + strlen(tag_name
) + 1);
893 sprintf(result
, "%s%s", prefix
, tag_name
);
898 /* Parsing Routines proper. */
900 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
901 For blocks, procedures and types we open a new lexical context.
902 This is basically just a big switch on the symbol's type.
903 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
904 BIGEND says whether aux symbols are big-endian or little-endian.
905 Return count of SYMR's handled (normally one). */
908 parse_symbol(sh
, ax
, bigend
)
919 /* When a symbol is cross-referenced from other files/symbols
920 we mark it explicitly */
921 int pend
= (sh
->reserved
== 1);
922 enum address_class
class;
930 case stGlobal
: /* external symbol, goes into global block */
932 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
934 s
= new_symbol((char *)sh
->iss
);
935 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
938 case stStatic
: /* static data, goes into current block. */
940 b
= top_stack
->cur_block
;
941 s
= new_symbol((char *)sh
->iss
);
942 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
945 case stLocal
: /* local variable, goes into current block */
946 if (sh
->sc
== scRegister
) {
947 class = LOC_REGISTER
;
949 sh
->value
+= FP0_REGNUM
-32;
952 b
= top_stack
->cur_block
;
953 s
= new_symbol((char *)sh
->iss
);
954 SYMBOL_VALUE(s
) = sh
->value
;
956 data
: /* Common code for symbols describing data */
957 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
958 SYMBOL_CLASS(s
) = class;
961 /* Type could be missing in a number of cases */
962 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
963 sh
->index
== 0xfffff)
964 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
966 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
967 /* Value of a data symbol is its memory address */
970 case stParam
: /* arg to procedure, goes into current block */
972 top_stack
->numargs
++;
974 name
= (char*)sh
->iss
;
975 /* Special GNU C++ name. */
976 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
977 name
= "this"; /* FIXME, not alloc'd in obstack */
978 s
= new_symbol(name
);
980 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
981 if (sh
->sc
== scRegister
) {
982 SYMBOL_CLASS(s
) = LOC_REGPARM
;
984 sh
->value
+= FP0_REGNUM
-32;
986 SYMBOL_CLASS(s
) = LOC_ARG
;
987 SYMBOL_VALUE(s
) = sh
->value
;
988 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
989 add_symbol(s
, top_stack
->cur_block
);
991 /* FIXME: This has not been tested. See dbxread.c */
992 /* Add the type of this parameter to the function/procedure
993 type of this block. */
994 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
998 case stLabel
: /* label, goes into current block */
999 s
= new_symbol((char *)sh
->iss
);
1000 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
1001 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
1002 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
1003 SYMBOL_TYPE(s
) = builtin_type_int
;
1004 add_symbol(s
, top_stack
->cur_block
);
1007 case stProc
: /* Procedure, usually goes into global block */
1008 case stStaticProc
: /* Static procedure, goes into current block */
1009 s
= new_symbol((char *)sh
->iss
);
1010 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1011 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1012 /* Type of the return value */
1013 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1014 t
= builtin_type_int
;
1016 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
1017 b
= top_stack
->cur_block
;
1018 if (sh
->st
== stProc
) {
1019 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1020 /* The next test should normally be true,
1021 but provides a hook for nested functions
1022 (which we don't want to make global). */
1023 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
1024 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
1028 /* Make a type for the procedure itself */
1030 /* FIXME: This has not been tested yet! See dbxread.c */
1031 /* Generate a template for the type of this function. The
1032 types of the arguments will be added as we read the symbol
1034 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1036 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1039 /* Create and enter a new lexical context */
1040 b
= new_block(top_stack
->maxsyms
);
1041 SYMBOL_BLOCK_VALUE(s
) = b
;
1042 BLOCK_FUNCTION(b
) = s
;
1043 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1044 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1045 add_block(b
, top_stack
->cur_st
);
1047 /* Not if we only have partial info */
1048 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1052 top_stack
->cur_block
= b
;
1053 top_stack
->blocktype
= sh
->st
;
1054 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1055 top_stack
->cur_field
= -1;
1056 top_stack
->procadr
= sh
->value
;
1057 top_stack
->numargs
= 0;
1059 sh
->value
= (long) SYMBOL_TYPE(s
);
1062 /* Beginning of code for structure, union, and enum definitions.
1063 They all share a common set of local variables, defined here. */
1065 enum type_code type_code
;
1071 case stStruct
: /* Start a block defining a struct type */
1072 type_code
= TYPE_CODE_STRUCT
;
1073 goto structured_common
;
1075 case stUnion
: /* Start a block defining a union type */
1076 type_code
= TYPE_CODE_UNION
;
1077 goto structured_common
;
1079 case stEnum
: /* Start a block defining an enum type */
1080 type_code
= TYPE_CODE_ENUM
;
1081 goto structured_common
;
1083 case stBlock
: /* Either a lexical block, or some type */
1084 if (sh
->sc
!= scInfo
)
1085 goto case_stBlock_code
; /* Lexical block */
1087 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
1089 /* Common code for handling struct, union, enum, and/or as-yet-
1090 unknown-type blocks of info about structured data. `type_code'
1091 has been set to the proper TYPE_CODE, if we know it. */
1094 top_stack
->blocktype
= stBlock
;
1096 s
= new_symbol((char *)sh
->iss
);
1097 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1098 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1099 SYMBOL_VALUE(s
) = 0;
1100 add_symbol(s
, top_stack
->cur_block
);
1102 /* First count the number of fields and the highest value. */
1105 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1107 if (tsym
->st
== stMember
) {
1108 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1109 /* If the type of the member is Nil (or Void),
1110 without qualifiers, assume the tag is an
1112 if (tsym
->index
== indexNil
)
1113 type_code
= TYPE_CODE_ENUM
;
1115 ecoff_swap_tir_in (bigend
,
1116 &ax
[tsym
->index
].a_ti
,
1118 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1119 && tir
.tq0
== tqNil
)
1120 type_code
= TYPE_CODE_ENUM
;
1123 if (tsym
->value
> max_value
)
1124 max_value
= tsym
->value
;
1126 else if (tsym
->st
== stBlock
1127 || tsym
->st
== stUnion
1128 || tsym
->st
== stEnum
1129 || tsym
->st
== stStruct
1130 || tsym
->st
== stParsed
) {
1131 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1132 if (tsym
->index
!= 0)
1133 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1136 else complain (&block_member_complaint
, tsym
->st
);
1139 /* In an stBlock, there is no way to distinguish structs,
1140 unions, and enums at this point. This is a bug in the
1141 original design (that has been fixed with the
1142 recent addition of the stStruct, stUnion, and stEnum
1143 symbol types.) The way you can tell is if/when you
1144 see a variable or field of that type. In that case
1145 the variable's type (in the AUX table) says if the
1146 type is struct, union, or enum,
1147 and points back to the stBlock here.
1148 So you can patch the tag kind up later - but only
1149 if there actually is a variable or field of that type.
1151 So until we know for sure, we will guess at this point.
1153 If the first member has index==indexNil or a void type,
1154 assume we have an enumeration.
1155 Otherwise, if there is more than one member, and all
1156 the members have offset 0, assume we have a union.
1157 Otherwise, assume we have a struct.
1159 The heuristic could guess wrong in the case of
1160 of an enumeration with no members or a union
1161 with one (or zero) members, or when all except the
1162 last field of a struct have width zero.
1163 These are uncommon and/or illegal situations, and
1164 in any case guessing wrong probably doesn't matter much.
1166 But if we later do find out we were wrong,
1167 we fixup the tag kind. Members of an enumeration
1168 must be handled differently from struct/union fields,
1169 and that is harder to patch up, but luckily we
1170 shouldn't need to. (If there are any enumeration
1171 members, we can tell for sure it's an enum here.) */
1173 if (type_code
== TYPE_CODE_UNDEF
)
1174 if (nfields
> 1 && max_value
== 0)
1175 type_code
= TYPE_CODE_UNION
;
1177 type_code
= TYPE_CODE_STRUCT
;
1179 /* If this type was expected, use its partial definition */
1181 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1183 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1186 TYPE_CODE(t
) = type_code
;
1187 TYPE_LENGTH(t
) = sh
->value
;
1188 TYPE_NFIELDS(t
) = nfields
;
1189 TYPE_FIELDS(t
) = f
= (struct field
*)
1190 TYPE_ALLOC (t
, nfields
* sizeof (struct field
));
1192 if (type_code
== TYPE_CODE_ENUM
) {
1193 /* This is a non-empty enum. */
1194 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1195 struct symbol
*enum_sym
;
1196 f
->bitpos
= tsym
->value
;
1198 f
->name
= (char*)tsym
->iss
;
1201 enum_sym
= (struct symbol
*)
1202 obstack_alloc (¤t_objfile
->symbol_obstack
,
1203 sizeof (struct symbol
));
1204 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1205 SYMBOL_NAME (enum_sym
) = f
->name
;
1206 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1207 SYMBOL_TYPE (enum_sym
) = t
;
1208 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1209 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1210 add_symbol(enum_sym
, top_stack
->cur_block
);
1212 /* Skip the stMembers that we've handled. */
1218 /* make this the current type */
1219 top_stack
->cur_type
= t
;
1220 top_stack
->cur_field
= 0;
1221 /* Mark that symbol has a type, and say which one */
1222 sh
->value
= (long) t
;
1225 /* End of local variables shared by struct, union, enum, and
1226 block (as yet unknown struct/union/enum) processing. */
1230 /* beginnning of (code) block. Value of symbol
1231 is the displacement from procedure start */
1233 top_stack
->blocktype
= stBlock
;
1234 b
= new_block(top_stack
->maxsyms
);
1235 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1236 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1237 top_stack
->cur_block
= b
;
1238 add_block(b
, top_stack
->cur_st
);
1241 case stEnd
: /* end (of anything) */
1242 if (sh
->sc
== scInfo
) {
1243 /* Finished with type */
1244 top_stack
->cur_type
= 0;
1245 } else if (sh
->sc
== scText
&&
1246 (top_stack
->blocktype
== stProc
||
1247 top_stack
->blocktype
== stStaticProc
)) {
1248 /* Finished with procedure */
1249 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1250 struct mips_extra_func_info
*e
;
1254 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1256 /* Make up special symbol to contain procedure specific
1258 s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
1259 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1260 SYMBOL_CLASS(s
) = LOC_CONST
;
1261 SYMBOL_TYPE(s
) = builtin_type_void
;
1262 e
= (struct mips_extra_func_info
*)
1263 obstack_alloc (¤t_objfile
->symbol_obstack
,
1264 sizeof (struct mips_extra_func_info
));
1265 SYMBOL_VALUE(s
) = (int)e
;
1266 e
->numargs
= top_stack
->numargs
;
1267 add_symbol(s
, top_stack
->cur_block
);
1269 /* Reallocate symbols, saving memory */
1270 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1272 /* f77 emits proc-level with address bounds==[0,0],
1273 So look for such child blocks, and patch them. */
1274 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1275 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1276 if (BLOCK_SUPERBLOCK(b_bad
) == b
1277 && BLOCK_START(b_bad
) == top_stack
->procadr
1278 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1279 BLOCK_START(b_bad
) = BLOCK_START(b
);
1280 BLOCK_END(b_bad
) = BLOCK_END(b
);
1283 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1284 /* End of (code) block. The value of the symbol
1285 is the displacement from the procedure`s start
1286 address of the end of this block. */
1287 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1288 shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1289 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
) {
1290 /* End of file. Pop parse stack and ignore. Higher
1291 level code deals with this. */
1293 } else complain (&stEnd_complaint
, sh
->sc
);
1295 pop_parse_stack(); /* restore previous lexical context */
1298 case stMember
: /* member of struct or union */
1299 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1300 f
->name
= (char*)sh
->iss
;
1301 f
->bitpos
= sh
->value
;
1303 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1306 case stTypedef
: /* type definition */
1307 s
= new_symbol((char *)sh
->iss
);
1308 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1309 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1310 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1311 add_symbol(s
, top_stack
->cur_block
);
1312 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1313 sh
->value
= (long) SYMBOL_TYPE(s
);
1316 case stFile
: /* file name */
1318 top_stack
->blocktype
= sh
->st
;
1321 /* I`ve never seen these for C */
1323 break; /* register relocation */
1325 break; /* forwarding address */
1327 break; /* constant */
1329 complain(&unknown_mips_symtype_complaint
, sh
->st
);
1336 /* Parse the type information provided in the raw AX entries for
1337 the symbol SH. Return the bitfield size in BS, in case.
1338 We must byte-swap the AX entries before we use them; BIGEND says whether
1339 they are big-endian or little-endian (from fh->fBigendian). */
1341 static struct type
*
1342 parse_type(ax
, bs
, bigend
)
1347 /* Null entries in this map are treated specially */
1348 static struct type
**map_bt
[] =
1350 &builtin_type_void
, /* btNil */
1352 &builtin_type_char
, /* btChar */
1353 &builtin_type_unsigned_char
, /* btUChar */
1354 &builtin_type_short
, /* btShort */
1355 &builtin_type_unsigned_short
, /* btUShort */
1356 &builtin_type_int
, /* btInt */
1357 &builtin_type_unsigned_int
, /* btUInt */
1358 &builtin_type_long
, /* btLong */
1359 &builtin_type_unsigned_long
, /* btULong */
1360 &builtin_type_float
, /* btFloat */
1361 &builtin_type_double
, /* btDouble */
1368 &builtin_type_complex
, /* btComplex */
1369 &builtin_type_double_complex
, /* btDComplex */
1371 &builtin_type_fixed_dec
, /* btFixedDec */
1372 &builtin_type_float_dec
, /* btFloatDec */
1373 &builtin_type_string
, /* btString */
1376 &builtin_type_void
, /* btVoid */
1377 &builtin_type_long_long
, /* btLongLong */
1378 &builtin_type_unsigned_long_long
,/* btULongLong */
1382 struct type
*tp
= 0;
1385 enum type_code type_code
;
1387 /* Use aux as a type information record, map its basic type. */
1389 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1390 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1391 complain (&basic_type_complaint
, t
->bt
);
1392 return builtin_type_int
;
1394 if (map_bt
[t
->bt
]) {
1395 tp
= *map_bt
[t
->bt
];
1399 /* Cannot use builtin types -- build our own */
1402 tp
= lookup_pointer_type (builtin_type_void
);
1406 type_code
= TYPE_CODE_STRUCT
;
1410 type_code
= TYPE_CODE_UNION
;
1414 type_code
= TYPE_CODE_ENUM
;
1418 type_code
= TYPE_CODE_RANGE
;
1422 type_code
= TYPE_CODE_SET
;
1427 complain (&basic_type_complaint
, t
->bt
);
1428 return builtin_type_int
;
1432 /* Skip over any further type qualifiers (FIXME). */
1434 /* This is the way it would work if the compiler worked */
1438 ecoff_swap_tir_in (bigend
, ax
, t1
);
1439 } while (t1
->continued
);
1442 /* Move on to next aux */
1446 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1450 /* All these types really point to some (common) MIPS type
1451 definition, and only the type-qualifiers fully identify
1452 them. We'll make the same effort at sharing. */
1453 if (t
->bt
== btIndirect
||
1454 t
->bt
== btStruct
||
1457 t
->bt
== btTypedef
||
1460 char name
[256], *pn
;
1462 /* Try to cross reference this type */
1463 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1464 /* reading .o file ? */
1465 if (UNSAFE_DATA_ADDR(tp
))
1466 tp
= init_type(type_code
, 0, 0, (char *) NULL
,
1467 (struct objfile
*) NULL
);
1468 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1469 sprintf(name
, fmt
, pn
);
1471 /* Usually, TYPE_CODE(tp) is already type_code. The main
1472 exception is if we guessed wrong re struct/union/enum. */
1473 if (TYPE_CODE(tp
) != type_code
) {
1474 complain (&bad_tag_guess_complaint
, name
);
1475 TYPE_CODE(tp
) = type_code
;
1477 if (TYPE_NAME(tp
) == NULL
|| !STREQ (TYPE_NAME(tp
), name
))
1478 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1479 ¤t_objfile
-> type_obstack
);
1482 /* Deal with range types */
1483 if (t
->bt
== btRange
) {
1484 TYPE_NFIELDS (tp
) = 2;
1485 TYPE_FIELDS (tp
) = (struct field
*)
1486 TYPE_ALLOC (tp
, 2 * sizeof (struct field
));
1487 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1488 ¤t_objfile
-> type_obstack
);
1489 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1491 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1492 ¤t_objfile
-> type_obstack
);
1493 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1497 /* Parse all the type qualifiers now. If there are more
1498 than 6 the game will continue in the next aux */
1500 #define PARSE_TQ(tq) \
1501 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1503 again
: PARSE_TQ(tq0
);
1513 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1519 /* Make up a complex type from a basic one. Type is passed by
1520 reference in TPP and side-effected as necessary. The type
1521 qualifier TQ says how to handle the aux symbols at AX for
1522 the symbol SX we are currently analyzing. BIGEND says whether
1523 aux symbols are big-endian or little-endian.
1524 Returns the number of aux symbols we parsed. */
1527 upgrade_type(tpp
, tq
, ax
, bigend
)
1536 /* Used in array processing */
1546 t
= lookup_pointer_type (*tpp
);
1551 t
= lookup_function_type (*tpp
);
1558 /* Determine and record the domain type (type of index) */
1559 ecoff_swap_rndx_in (bigend
, ax
, &rndx
);
1564 rf
= AUX_GET_ISYM (bigend
, ax
);
1567 fh
= get_rfd(cur_fd
, rf
);
1569 indx
= parse_type (id
+ (union aux_ext
*) fh
->iauxBase
,
1570 (int *) NULL
, bigend
);
1572 /* Get the bounds, and create the array type. */
1574 lower
= AUX_GET_DNLOW (bigend
, ax
);
1576 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1578 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1580 range
= create_range_type ((struct type
*) NULL
, indx
,
1583 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1585 /* Check whether supplied array element bit size matches
1586 the known size of the element type. If this complaint
1587 ends up not happening, we can remove this code. It's
1588 here because we aren't sure we understand this *&%&$
1590 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1592 /* Most likely an undefined type */
1594 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1597 complain (&array_bitsize_complaint
, rf
);
1603 /* Volatile -- currently ignored */
1607 /* Const -- currently ignored */
1611 complain (&unknown_type_qual_complaint
, tq
);
1617 /* Parse a procedure descriptor record PR. Note that the procedure
1618 is parsed _after_ the local symbols, now we just insert the extra
1619 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has already
1620 been placed in the procedure's main block. Note also that images that
1621 have been partially stripped (ld -x) have been deprived
1622 of local symbols, and we have to cope with them here.
1623 The procedure's code ends at BOUND */
1626 parse_procedure (pr
, bound
, have_stabs
)
1631 struct symbol
*s
, *i
;
1632 SYMR
*sh
= (SYMR
*)pr
->isym
;
1634 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
, 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(MIPS_EFI_SYMBOL_NAME
, 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
, section_offsets
)
1825 int end_of_text_seg
;
1826 struct objfile
*objfile
;
1827 struct section_offsets
*section_offsets
;
1830 HDRR
*hdr
= cur_hdr
;
1831 /* Running pointers */
1835 struct partial_symtab
*pst
;
1837 int past_first_source_file
= 0;
1839 /* List of current psymtab's include files */
1840 char **psymtab_include_list
;
1841 int includes_allocated
;
1844 struct pst_map
* fdr_to_pst
;
1845 /* Index within current psymtab dependency list */
1846 struct partial_symtab
**dependency_list
;
1847 int dependencies_used
, dependencies_allocated
;
1848 struct cleanup
*old_chain
;
1851 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1852 sizeof(EXTR
*) * hdr
->iextMax
);
1854 includes_allocated
= 30;
1856 psymtab_include_list
= (char **) alloca (includes_allocated
*
1858 next_symbol_text_func
= mips_next_symbol_text
;
1860 dependencies_allocated
= 30;
1861 dependencies_used
= 0;
1863 (struct partial_symtab
**) alloca (dependencies_allocated
*
1864 sizeof (struct partial_symtab
*));
1866 last_source_file
= NULL
;
1871 * Only parse the Local and External symbols, and the Relative FDR.
1872 * Fixup enough of the loader symtab to be able to use it.
1873 * Allocate space only for the file's portions we need to
1878 max_glevel
= MIN_GLEVEL
;
1880 /* Allocate the map FDR -> PST.
1881 Minor hack: -O3 images might claim some global data belongs
1882 to FDR -1. We`ll go along with that */
1883 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1884 old_chain
= make_cleanup (free
, fdr_to_pst
);
1887 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1888 fdr_to_pst
[-1].pst
= pst
;
1892 /* Pass 1 over external syms: Presize and partition the list */
1893 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1894 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1895 fdr_to_pst
[esh
->ifd
].n_globals
++;
1898 /* Pass 1.5 over files: partition out global symbol space */
1900 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1901 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1902 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1903 fdr_to_pst
[f_idx
].n_globals
= 0;
1906 /* Pass 2 over external syms: fill in external symbols */
1907 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1908 enum minimal_symbol_type ms_type
= mst_text
;
1909 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1911 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1912 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1914 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1917 switch (esh
->asym
.st
) {
1926 ms_type
= mst_unknown
;
1927 complain (&unknown_ext_complaint
, esh
->asym
.iss
);
1929 name
= (char *)esh
->asym
.iss
;
1930 prim_record_minimal_symbol (name
, esh
->asym
.value
, ms_type
);
1933 /* Pass 3 over files, over local syms: fill in static symbols */
1934 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1935 struct partial_symtab
*save_pst
;
1938 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1940 if (fh
->csym
== 0) {
1941 fdr_to_pst
[f_idx
].pst
= NULL
;
1944 pst
= start_psymtab_common (objfile
, section_offsets
, (char*)fh
->rss
,
1945 fh
->cpd
? fh
->adr
: 0,
1946 objfile
->global_psymbols
.next
,
1947 objfile
->static_psymbols
.next
);
1948 pst
->read_symtab_private
= (char *)
1949 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1952 /* Make everything point to everything. */
1953 FDR_IDX(pst
) = f_idx
;
1954 fdr_to_pst
[f_idx
].pst
= pst
;
1955 fh
->ioptBase
= (int)pst
;
1957 CUR_HDR(pst
) = cur_hdr
;
1959 /* The way to turn this into a symtab is to call... */
1960 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1962 pst
->texthigh
= pst
->textlow
;
1964 /* For stabs-in-ecoff files, the second symbol must be @stab.
1965 This symbol is emitted by mips-tfile to signal
1966 that the current object file uses encapsulated stabs
1967 instead of mips ecoff for local symbols.
1968 (It is the second symbol because the first symbol is
1969 the stFile used to signal the start of a file). */
1971 && STREQ((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)) {
1972 processing_gcc_compilation
= 2;
1973 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1976 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1977 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1978 if (!MIPS_IS_STAB(sh
)) {
1979 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
1980 long procaddr
= sh
->value
;
1981 sh
= AUX_GET_ISYM (fh
->fBigendian
,
1982 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
1983 + (SYMR
*) fh
->isymBase
- 1;
1984 if (sh
->st
== stEnd
) {
1985 long high
= procaddr
+ sh
->value
;
1986 if (high
> pst
->texthigh
)
1987 pst
->texthigh
= high
;
1992 #define SET_NAMESTRING() namestring = (char*)sh->iss
1993 #define CUR_SYMBOL_TYPE type_code
1994 #define CUR_SYMBOL_VALUE sh->value
1995 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1997 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
1998 #define HANDLE_RBRAC(val) \
1999 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2000 #include "partial-stab.h"
2004 processing_gcc_compilation
= 0;
2005 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2007 enum address_class
class;
2008 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2010 if (MIPS_IS_STAB(sh
)) {
2015 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
2016 sh
->index
== 0xfffff) {
2017 /* FIXME, premature? */
2022 name
= (char *)(sh
->iss
);
2029 case stProc
: /* Asm labels apparently */
2030 case stStaticProc
: /* Function */
2031 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2032 VAR_NAMESPACE
, LOC_BLOCK
,
2033 objfile
->static_psymbols
, sh
->value
,
2034 psymtab_language
, objfile
);
2035 /* Skip over procedure to next one. */
2036 if (sh
->index
>= hdr
->iauxMax
)
2038 /* Should not happen, but does when cross-compiling
2039 with the MIPS compiler. FIXME -- pull later. */
2040 complain (&index_complaint
, name
);
2041 new_sdx
= cur_sdx
+1; /* Don't skip at all */
2044 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2045 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
2046 procaddr
= sh
->value
;
2048 if (new_sdx
<= cur_sdx
)
2050 /* This should not happen either... FIXME. */
2051 complain (&aux_index_complaint
, name
);
2052 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2056 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
2057 if (sh
->st
!= stEnd
)
2059 high
= procaddr
+ sh
->value
;
2060 if (high
> pst
->texthigh
)
2061 pst
->texthigh
= high
;
2064 case stStatic
: /* Variable */
2068 case stTypedef
: /* Typedef */
2069 class = LOC_TYPEDEF
;
2072 case stConstant
: /* Constant decl */
2079 case stBlock
: /* { }, str, un, enum*/
2080 if (sh
->sc
== scInfo
) {
2081 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2082 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2083 objfile
->static_psymbols
,
2085 psymtab_language
, objfile
);
2087 /* Skip over the block */
2088 new_sdx
= sh
->index
;
2089 if (new_sdx
<= cur_sdx
)
2091 /* This happens with the Ultrix kernel. */
2092 complain (&block_index_complaint
, name
);
2093 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2098 case stFile
: /* File headers */
2099 case stLabel
: /* Labels */
2100 case stEnd
: /* Ends of files */
2103 case stLocal
: /* Local variables */
2104 /* Normally these are skipped because we skip over
2105 all blocks we see. However, these can occur
2106 as visible symbols in a .h file that contains code. */
2110 /* Both complaints are valid: one gives symbol name,
2111 the other the offending symbol type. */
2112 complain (&unknown_sym_complaint
, sh
->iss
);
2113 complain (&unknown_st_complaint
, sh
->st
);
2117 /* Use this gdb symbol */
2118 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2119 VAR_NAMESPACE
, class,
2120 objfile
->static_psymbols
, sh
->value
,
2121 psymtab_language
, objfile
);
2123 cur_sdx
++; /* Go to next file symbol */
2126 /* Now do enter the external symbols. */
2127 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2128 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2129 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2130 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2131 for (; --cur_sdx
>= 0; ext_ptr
++) {
2132 register struct partial_symbol
*psym
;
2133 enum address_class
class;
2135 if ((*ext_ptr
)->ifd
!= f_idx
)
2137 sh
= &(*ext_ptr
)->asym
;
2146 complain (&unknown_ext_complaint
, sh
->iss
);
2147 /* Fall through, pretend it's global. */
2152 if (objfile
->global_psymbols
.next
>=
2153 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2154 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2155 psym
= objfile
->global_psymbols
.next
++;
2156 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2157 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2158 SYMBOL_CLASS (psym
) = class;
2159 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2163 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2164 -1, save_pst
->texthigh
,
2165 dependency_list
, dependencies_used
);
2166 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2167 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2169 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2170 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2174 /* Mark the last code address, and remember it for later */
2175 hdr
->cbDnOffset
= end_of_text_seg
;
2177 /* Now scan the FDRs for dependencies */
2178 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2180 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2181 pst
= fdr_to_pst
[f_idx
].pst
;
2183 /* This should catch stabs-in-ecoff. */
2187 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2188 /* ...then presumably a .h file: drop reverse depends .h->.c */
2189 for (; s_id0
< fh
->crfd
; s_id0
++) {
2190 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2192 s_id0
++; /* Skip self-dependency */
2197 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2198 pst
->dependencies
= (struct partial_symtab
**)
2199 obstack_alloc (&objfile
->psymbol_obstack
,
2200 pst
->number_of_dependencies
*
2201 sizeof (struct partial_symtab
*));
2202 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2203 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2204 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2205 complain(&bad_file_number_complaint
, *rh
);
2207 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2210 do_cleanups (old_chain
);
2215 /* Do the initial analisys of the F_IDX-th file descriptor.
2216 Allocates a partial symtab for it, and builds the list
2217 of dependent files by recursion. LEV says at which level
2218 of recursion we are called (to pretty up debug traces) */
2220 static struct partial_symtab
*
2221 parse_fdr(f_idx
, lev
, objfile
)
2224 struct objfile
*objfile
;
2227 register struct partial_symtab
*pst
;
2230 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2232 /* Use this to indicate into which symtab this file was parsed */
2234 return (struct partial_symtab
*) fh
->ioptBase
;
2236 /* Debuggability level */
2237 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2238 max_glevel
= fh
->glevel
;
2240 /* Make a new partial_symtab */
2241 pst
= new_psymtab(fh
->rss
, objfile
);
2246 pst
->textlow
= fh
->adr
;
2247 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2250 /* Make everything point to everything. */
2251 FDR_IDX(pst
) = f_idx
;
2252 fdr_to_pst
[f_idx
].pst
= pst
;
2253 fh
->ioptBase
= (int)pst
;
2255 /* Analyze its dependencies */
2260 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2261 /* ...then presumably a .h file: drop reverse depends .h->.c */
2262 for (; s_id0
< fh
->crfd
; s_id0
++) {
2263 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2265 s_id0
++; /* Skip self-dependency */
2270 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2271 pst
->dependencies
= (struct partial_symtab
**)
2272 obstack_alloc (&objfile
->psymbol_obstack
,
2273 pst
->number_of_dependencies
*
2274 sizeof (struct partial_symtab
*));
2275 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2276 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2278 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2286 mips_next_symbol_text ()
2289 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2292 /* Ancillary function to psymtab_to_symtab(). Does all the work
2293 for turning the partial symtab PST into a symtab, recurring
2294 first on all dependent psymtabs. The argument FILENAME is
2295 only passed so we can see in debug stack traces what file
2298 This function has a split personality, based on whether the
2299 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2300 The flow of control and even the memory allocation differs. FIXME. */
2303 psymtab_to_symtab_1(pst
, filename
)
2304 struct partial_symtab
*pst
;
2310 struct linetable
*lines
;
2317 /* Read in all partial symbtabs on which this one is dependent.
2318 NOTE that we do have circular dependencies, sigh. We solved
2319 that by setting pst->readin before this point. */
2321 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2322 if (!pst
->dependencies
[i
]->readin
) {
2323 /* Inform about additional files to be read in. */
2326 fputs_filtered (" ", stdout
);
2328 fputs_filtered ("and ", stdout
);
2330 printf_filtered ("%s...",
2331 pst
->dependencies
[i
]->filename
);
2332 wrap_here (""); /* Flush output */
2335 /* We only pass the filename for debug purposes */
2336 psymtab_to_symtab_1(pst
->dependencies
[i
],
2337 pst
->dependencies
[i
]->filename
);
2340 /* Now read the symbols for this symtab */
2342 current_objfile
= pst
->objfile
;
2343 cur_fd
= FDR_IDX(pst
);
2344 fh
= (cur_fd
== -1) ? 0 : (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2347 /* BOUND is the highest core address of this file's procedures */
2348 bound
= (cur_fd
== cur_hdr
->ifdMax
- 1) ?
2349 cur_hdr
->cbDnOffset
:
2352 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2353 if (fh
&& fh
->csym
>= 2
2354 && STREQ((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)) {
2357 * This symbol table contains stabs-in-ecoff entries.
2362 /* We indicate that this is a GCC compilation so that certain features
2363 will be enabled in stabsread/dbxread. */
2364 processing_gcc_compilation
= 2;
2365 /* Parse local symbols first */
2367 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2369 current_objfile
= NULL
;
2372 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2373 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2374 char *name
= (char*)sh
->iss
;
2375 CORE_ADDR valu
= sh
->value
;
2376 if (MIPS_IS_STAB(sh
)) {
2377 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2378 process_one_symbol (type_code
, 0, valu
, name
,
2379 pst
->section_offsets
, pst
->objfile
);
2380 if (type_code
== N_FUN
) {
2381 /* Make up special symbol to contain
2382 procedure specific info */
2383 struct mips_extra_func_info
*e
=
2384 (struct mips_extra_func_info
*)
2385 obstack_alloc(¤t_objfile
->symbol_obstack
,
2386 sizeof(struct mips_extra_func_info
));
2387 struct symbol
*s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
2388 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2389 SYMBOL_CLASS(s
) = LOC_CONST
;
2390 SYMBOL_TYPE(s
) = builtin_type_void
;
2391 SYMBOL_VALUE(s
) = (int)e
;
2392 add_symbol_to_list (s
, &local_symbols
);
2395 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2396 /* Handle encoded stab line number. */
2397 record_line (current_subfile
, sh
->index
, valu
);
2399 else complain (&stab_unknown_complaint
, sh
->iss
);
2401 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2404 /* Sort the symbol table now, we are done adding symbols to it.
2405 We must do this before parse_procedure calls lookup_symbol. */
2406 sort_symtab_syms(st
);
2408 /* This may not be necessary for stabs symtabs. FIXME. */
2411 /* Fill in procedure info next. We need to look-ahead to
2412 find out where each procedure's code ends. */
2414 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2415 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2416 parse_procedure (pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 1);
2421 * This symbol table contains ordinary ecoff entries.
2424 /* FIXME: doesn't use pst->section_offsets. */
2430 processing_gcc_compilation
= 0;
2432 /* How many symbols will we need */
2433 /* FIXME, this does not count enum values. */
2434 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2437 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2439 f_max
+= fh
->csym
+ fh
->cpd
;
2440 maxlines
= 2 * fh
->cline
;
2441 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2444 lines
= LINETABLE(st
);
2445 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2446 if (pending_list
== 0) {
2447 pending_list
= (struct mips_pending
**)
2448 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2449 cur_hdr
->cbOptOffset
= (int)pending_list
;
2452 /* Get a new lexical context */
2455 top_stack
->cur_st
= st
;
2456 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(st
),
2458 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2459 BLOCK_END(top_stack
->cur_block
) = 0;
2460 top_stack
->blocktype
= stFile
;
2461 top_stack
->maxsyms
= 2*f_max
;
2462 top_stack
->cur_type
= 0;
2463 top_stack
->procadr
= 0;
2464 top_stack
->numargs
= 0;
2470 /* Parse local symbols first */
2472 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2473 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2474 cur_sdx
+= parse_symbol(sh
, (union aux_ext
*)fh
->iauxBase
,
2478 /* Linenumbers. At the end, check if we can save memory */
2480 parse_lines(fh
, lines
);
2481 if (lines
->nitems
< fh
->cline
)
2482 lines
= shrink_linetable(lines
);
2484 /* Fill in procedure info next. We need to look-ahead to
2485 find out where each procedure's code ends. */
2487 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2488 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2489 parse_procedure(pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 0);
2493 LINETABLE(st
) = lines
;
2495 /* .. and our share of externals.
2496 XXX use the global list to speed up things here. how?
2497 FIXME, Maybe quit once we have found the right number of ext's? */
2498 top_stack
->cur_st
= st
;
2499 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
2501 top_stack
->blocktype
= stFile
;
2502 top_stack
->maxsyms
=
2503 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2505 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2506 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2507 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2509 /* If there are undefined, tell the user */
2510 if (n_undef_symbols
) {
2511 printf_filtered("File %s contains %d unresolved references:",
2512 st
->filename
, n_undef_symbols
);
2513 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2514 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2515 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2520 /* Sort the symbol table now, we are done adding symbols to it.*/
2521 sort_symtab_syms(st
);
2526 /* Now link the psymtab and the symtab. */
2529 current_objfile
= NULL
;
2532 /* Ancillary parsing procedures. */
2534 /* Lookup the type at relative index RN. Return it in TPP
2535 if found and in any event come up with its name PNAME.
2536 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2537 Return value says how many aux symbols we ate. */
2540 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2543 enum type_code type_code
; /* Use to alloc new type if none is found. */
2551 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2553 /* Escape index means 'the next one' */
2554 if (rn
->rfd
== 0xfff) {
2556 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2563 *pname
= "<undefined>";
2566 * Find the relative file descriptor and the symbol in it
2568 FDR
*fh
= get_rfd(cur_fd
, rf
);
2573 * If we have processed this symbol then we left a forwarding
2574 * pointer to the corresponding GDB symbol. If not, we`ll put
2575 * it in a list of pending symbols, to be processed later when
2576 * the file f will be. In any event, we collect the name for
2577 * the type here. Which is why we made a first pass at
2580 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2582 /* Careful, we might be looking at .o files */
2583 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2586 /* Have we parsed it ? */
2587 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2588 t
= (struct type
*) sh
->value
;
2591 /* Avoid duplicates */
2592 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2596 *tpp
= init_type(type_code
, 0, 0, (char *) NULL
,
2597 (struct objfile
*) NULL
);
2598 add_pending(fh
, sh
, *tpp
);
2603 /* We used one auxent normally, two if we got a "next one" rf. */
2608 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2609 keeping the symtab sorted */
2611 static struct symbol
*
2612 mylookup_symbol (name
, block
, namespace, class)
2614 register struct block
*block
;
2615 enum namespace namespace;
2616 enum address_class
class;
2618 register int bot
, top
, inc
;
2619 register struct symbol
*sym
;
2622 top
= BLOCK_NSYMS(block
);
2625 sym
= BLOCK_SYM(block
, bot
);
2626 if (SYMBOL_NAME(sym
)[0] == inc
2627 && SYMBOL_NAMESPACE(sym
) == namespace
2628 && SYMBOL_CLASS(sym
) == class
2629 && STREQ(SYMBOL_NAME(sym
), name
))
2633 block
= BLOCK_SUPERBLOCK (block
);
2635 return mylookup_symbol (name
, block
, namespace, class);
2640 /* Add a new symbol S to a block B.
2641 Infrequently, we will need to reallocate the block to make it bigger.
2642 We only detect this case when adding to top_stack->cur_block, since
2643 that's the only time we know how big the block is. FIXME. */
2650 int nsyms
= BLOCK_NSYMS(b
)++;
2651 struct block
*origb
;
2652 struct parse_stack
*stackp
;
2654 if (b
== top_stack
->cur_block
&&
2655 nsyms
>= top_stack
->maxsyms
) {
2656 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
2657 /* In this case shrink_block is actually grow_block, since
2658 BLOCK_NSYMS(b) is larger than its current size. */
2660 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2662 /* Now run through the stack replacing pointers to the
2663 original block. shrink_block has already done this
2664 for the blockvector and BLOCK_FUNCTION. */
2665 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2666 if (stackp
->cur_block
== origb
) {
2667 stackp
->cur_block
= b
;
2668 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2672 BLOCK_SYM(b
,nsyms
) = s
;
2675 /* Add a new block B to a symtab S */
2682 struct blockvector
*bv
= BLOCKVECTOR(s
);
2684 bv
= (struct blockvector
*)xrealloc((PTR
) bv
,
2685 sizeof(struct blockvector
) +
2686 BLOCKVECTOR_NBLOCKS(bv
)
2687 * sizeof(bv
->block
));
2688 if (bv
!= BLOCKVECTOR(s
))
2689 BLOCKVECTOR(s
) = bv
;
2691 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2694 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2695 MIPS' linenumber encoding might need more than one byte
2696 to describe it, LAST is used to detect these continuation lines */
2699 add_line(lt
, lineno
, adr
, last
)
2700 struct linetable
*lt
;
2706 last
= -2; /* make sure we record first line */
2708 if (last
== lineno
) /* skip continuation lines */
2711 lt
->item
[lt
->nitems
].line
= lineno
;
2712 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2716 /* Sorting and reordering procedures */
2718 /* Blocks with a smaller low bound should come first */
2721 compare_blocks(arg1
, arg2
)
2722 const void *arg1
, *arg2
;
2724 register int addr_diff
;
2725 struct block
**b1
= (struct block
**) arg1
;
2726 struct block
**b2
= (struct block
**) arg2
;
2728 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2730 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2734 /* Sort the blocks of a symtab S.
2735 Reorder the blocks in the blockvector by code-address,
2736 as required by some MI search routines */
2742 struct blockvector
*bv
= BLOCKVECTOR(s
);
2744 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2746 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2747 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2748 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2749 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2753 * This is very unfortunate: normally all functions are compiled in
2754 * the order they are found, but if the file is compiled -O3 things
2755 * are very different. It would be nice to find a reliable test
2756 * to detect -O3 images in advance.
2758 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2759 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2760 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2761 sizeof(struct block
*),
2765 register CORE_ADDR high
= 0;
2766 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2768 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2769 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2770 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2771 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2774 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2775 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2777 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2778 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2779 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2780 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2784 /* Constructor/restructor/destructor procedures */
2786 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2787 MAXSYMS and linenumbers MAXLINES we'll put in it */
2789 static struct symtab
*
2790 new_symtab(name
, maxsyms
, maxlines
, objfile
)
2794 struct objfile
*objfile
;
2796 struct symtab
*s
= allocate_symtab (name
, objfile
);
2798 LINETABLE(s
) = new_linetable(maxlines
);
2800 /* All symtabs must have at least two blocks */
2801 BLOCKVECTOR(s
) = new_bvect(2);
2802 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2803 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2804 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2805 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2807 s
->free_code
= free_linetable
;
2812 /* Allocate a new partial_symtab NAME */
2814 static struct partial_symtab
*
2815 new_psymtab(name
, objfile
)
2817 struct objfile
*objfile
;
2819 struct partial_symtab
*psymtab
;
2821 /* FIXME -- why (char *) -1 rather than NULL? */
2822 psymtab
= allocate_psymtab (name
== (char *) -1 ? "<no name>" : name
,
2825 /* Keep a backpointer to the file's symbols */
2827 psymtab
-> read_symtab_private
= (char *)
2828 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2829 CUR_HDR(psymtab
) = cur_hdr
;
2831 /* The way to turn this into a symtab is to call... */
2832 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
2837 /* Allocate a linetable array of the given SIZE. Since the struct
2838 already includes one item, we subtract one when calculating the
2839 proper size to allocate. */
2841 static struct linetable
*
2845 struct linetable
*l
;
2847 size
= (size
-1) * sizeof(l
->item
) + sizeof(struct linetable
);
2848 l
= (struct linetable
*)xmalloc(size
);
2853 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2854 I am not so sure about the 3.4 ones.
2856 Since the struct linetable already includes one item, we subtract one when
2857 calculating the proper size to allocate. */
2859 static struct linetable
*
2860 shrink_linetable(lt
)
2861 struct linetable
* lt
;
2864 return (struct linetable
*) xrealloc ((PTR
)lt
,
2865 sizeof(struct linetable
)
2866 + (lt
->nitems
- 1) * sizeof(lt
->item
));
2869 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2871 static struct blockvector
*
2875 struct blockvector
*bv
;
2878 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2879 bv
= (struct blockvector
*) xzalloc(size
);
2881 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2886 /* Allocate and zero a new block of MAXSYMS symbols */
2888 static struct block
*
2892 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2894 return (struct block
*)xzalloc (size
);
2897 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2898 Shrink_block can also be used by add_symbol to grow a block. */
2900 static struct block
*
2906 struct blockvector
*bv
= BLOCKVECTOR(s
);
2909 /* Just reallocate it and fix references to the old one */
2911 new = (struct block
*) xrealloc ((PTR
)b
, sizeof(struct block
) +
2912 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2914 /* Should chase pointers to old one. Fortunately, that`s just
2915 the block`s function and inferior blocks */
2916 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2917 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2918 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2919 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2920 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2921 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2922 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2926 /* Create a new symbol with printname NAME */
2928 static struct symbol
*
2932 struct symbol
*s
= (struct symbol
*)
2933 obstack_alloc (¤t_objfile
->symbol_obstack
, sizeof (struct symbol
));
2935 memset ((PTR
)s
, 0, sizeof (*s
));
2936 SYMBOL_NAME(s
) = name
;
2940 /* Create a new type with printname NAME */
2942 static struct type
*
2948 t
= alloc_type (current_objfile
);
2949 TYPE_NAME(t
) = name
;
2950 TYPE_CPLUS_SPECIFIC(t
) = (struct cplus_struct_type
*)
2951 &cplus_struct_default
;
2956 /* Things used for calling functions in the inferior.
2957 These functions are exported to our companion
2958 mips-tdep.c file and are here because they play
2959 with the symbol-table explicitly. */
2961 /* Sigtramp: make sure we have all the necessary information
2962 about the signal trampoline code. Since the official code
2963 from MIPS does not do so, we make up that information ourselves.
2964 If they fix the library (unlikely) this code will neutralize itself. */
2971 struct block
*b
, *b0
;
2973 sigtramp_address
= -1;
2975 /* We know it is sold as sigvec */
2976 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2978 /* Most programs do not play with signals */
2980 s
= lookup_symbol("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
2983 b0
= SYMBOL_BLOCK_VALUE(s
);
2985 /* A label of sigvec, to be more precise */
2986 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
2989 /* But maybe this program uses its own version of sigvec */
2993 /* Did we or MIPSco fix the library ? */
2994 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
2996 sigtramp_address
= BLOCK_START(SYMBOL_BLOCK_VALUE(s
));
2997 sigtramp_end
= BLOCK_END(SYMBOL_BLOCK_VALUE(s
));
3001 sigtramp_address
= SYMBOL_VALUE(s
);
3002 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3004 /* But what symtab does it live in ? */
3005 st
= find_pc_symtab(SYMBOL_VALUE(s
));
3008 * Ok, there goes the fix: turn it into a procedure, with all the
3009 * needed info. Note we make it a nested procedure of sigvec,
3010 * which is the way the (assembly) code is actually written.
3012 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
3013 SYMBOL_CLASS(s
) = LOC_BLOCK
;
3014 SYMBOL_TYPE(s
) = init_type(TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3015 (struct objfile
*) NULL
);
3016 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
3018 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3020 SYMBOL_BLOCK_VALUE(s
) = b
;
3021 BLOCK_START(b
) = sigtramp_address
;
3022 BLOCK_END(b
) = sigtramp_end
;
3023 BLOCK_FUNCTION(b
) = s
;
3024 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
3028 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3030 struct mips_extra_func_info
*e
=
3031 (struct mips_extra_func_info
*)
3032 xzalloc(sizeof(struct mips_extra_func_info
));
3034 e
->numargs
= 0; /* the kernel thinks otherwise */
3035 /* align_longword(sigcontext + SIGFRAME) */
3036 e
->pdr
.frameoffset
= 0x150;
3037 e
->pdr
.framereg
= SP_REGNUM
;
3039 e
->pdr
.regmask
= -2;
3040 e
->pdr
.regoffset
= -(41 * sizeof(int));
3041 e
->pdr
.fregmask
= -1;
3042 e
->pdr
.fregoffset
= -(37 * sizeof(int));
3043 e
->pdr
.isym
= (long)s
;
3045 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3046 s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
3047 SYMBOL_VALUE(s
) = (int) e
;
3048 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
3049 SYMBOL_CLASS(s
) = LOC_CONST
;
3050 SYMBOL_TYPE(s
) = builtin_type_void
;
3051 current_objfile
= NULL
;
3054 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
3058 /* Fake up identical offsets for all sections. */
3060 struct section_offsets
*
3061 mipscoff_symfile_offsets (objfile
, addr
)
3062 struct objfile
*objfile
;
3065 struct section_offsets
*section_offsets
;
3068 section_offsets
= (struct section_offsets
*)
3069 obstack_alloc (&objfile
-> psymbol_obstack
,
3070 sizeof (struct section_offsets
) +
3071 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
3073 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3074 ANOFFSET (section_offsets
, i
) = addr
;
3076 return section_offsets
;
3079 /* Initialization */
3081 static struct sym_fns ecoff_sym_fns
=
3083 "ecoff", /* sym_name: name or name prefix of BFD target type */
3084 5, /* sym_namelen: number of significant sym_name chars */
3085 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3086 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
3087 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
3088 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
3089 mipscoff_symfile_offsets
,/* sym_offsets: dummy FIXME til implem sym reloc */
3090 NULL
/* next: pointer to next struct sym_fns */
3095 _initialize_mipsread ()
3097 add_symtab_fns (&ecoff_sym_fns
);
3099 /* Missing basic types */
3101 builtin_type_string
=
3102 init_type(TYPE_CODE_STRING
,
3103 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3105 (struct objfile
*) NULL
);
3106 builtin_type_complex
=
3107 init_type(TYPE_CODE_FLT
,
3108 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3110 (struct objfile
*) NULL
);
3111 builtin_type_double_complex
=
3112 init_type(TYPE_CODE_FLT
,
3113 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3114 0, "double complex",
3115 (struct objfile
*) NULL
);
3116 builtin_type_fixed_dec
=
3117 init_type(TYPE_CODE_INT
,
3118 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3120 (struct objfile
*) NULL
);
3121 builtin_type_float_dec
=
3122 init_type(TYPE_CODE_FLT
,
3123 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3124 0, "floating decimal",
3125 (struct objfile
*) NULL
);