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 /* These must match the corresponding definition in gcc/config/xm-mips.h.
92 At some point, these should probably go into a shared include file,
93 but currently gcc and gdb do not share any directories. */
95 #define CODE_MASK 0x8F300
96 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
97 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
98 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
99 #define STABS_SYMBOL "@stabs"
101 /* Each partial symbol table entry contains a pointer to private data for the
102 read_symtab() function to use when expanding a partial symbol table entry
103 to a full symbol table entry.
105 For mipsread this structure contains the index of the FDR that this psymtab
106 represents and a pointer to the symbol table header HDRR from the symbol
107 file that the psymtab was created from. */
109 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
110 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
111 #define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
116 EXTR
**extern_tab
; /* Pointer to external symbols for this file. */
117 int extern_count
; /* Size of extern_tab. */
120 /* Things we import explicitly from other modules */
122 extern int info_verbose
;
124 /* Various complaints about symbol reading that don't abort the process */
126 struct complaint bad_file_number_complaint
=
127 {"bad file number %d", 0, 0};
129 struct complaint index_complaint
=
130 {"bad aux index at symbol %s", 0, 0};
132 struct complaint aux_index_complaint
=
133 {"bad proc end in aux found from symbol %s", 0, 0};
135 struct complaint unknown_ext_complaint
=
136 {"unknown external symbol %s", 0, 0};
138 struct complaint unknown_sym_complaint
=
139 {"unknown local symbol %s", 0, 0};
141 struct complaint unknown_st_complaint
=
142 {"with type %d", 0, 0};
144 struct complaint block_overflow_complaint
=
145 {"block containing %s overfilled", 0, 0};
147 struct complaint basic_type_complaint
=
148 {"cannot map MIPS basic type 0x%x", 0, 0};
150 struct complaint unknown_type_qual_complaint
=
151 {"unknown type qualifier 0x%x", 0, 0};
153 struct complaint array_bitsize_complaint
=
154 {"size of array target type not known, assuming %d bits", 0, 0};
156 struct complaint bad_tag_guess_complaint
=
157 {"guessed tag type of %s incorrectly", 0, 0};
159 struct complaint block_member_complaint
=
160 {"declaration block contains unhandled symbol type %d", 0, 0};
162 struct complaint stEnd_complaint
=
163 {"stEnd with storage class %d not handled", 0, 0};
165 struct complaint unknown_mips_symtype_complaint
=
166 {"unknown symbol type 0x%x", 0, 0};
168 struct complaint stab_unknown_complaint
=
169 {"unknown stabs symbol %s", 0, 0};
171 struct complaint pdr_for_nonsymbol_complaint
=
172 {"PDR for %s, but no symbol", 0, 0};
174 struct complaint pdr_static_symbol_complaint
=
175 {"can't handle PDR for static proc at 0x%x", 0, 0};
177 /* Macros and extra defs */
179 /* Already-parsed symbols are marked specially */
181 #define stParsed stType
183 /* Puns: hard to find whether -g was used and how */
185 #define MIN_GLEVEL GLEVEL_0
186 #define compare_glevel(a,b) \
187 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
188 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
190 /* When looking at .o files, avoid tripping over zero pointers.
191 FIXME; places that use this should be fixed to convert from
192 external to internal format, rather than examining in-place. */
194 #define UNSAFE_DATA_ADDR(p) ((p) == 0)
196 /* Things that really are local to this module */
198 /* Remember what we deduced to be the source language of this psymtab. */
200 static enum language psymtab_language
= language_unknown
;
202 /* MIPS symtab header for the current file */
204 static HDRR
*cur_hdr
;
206 /* Pointer to current file decriptor record, and its index */
211 /* Index of current symbol */
215 /* Note how much "debuggable" this image is. We would like
216 to see at least one FDR with full symbols */
221 /* When examining .o files, report on undefined symbols */
223 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
225 /* Pseudo symbol to use when putting stabs into the symbol table. */
227 static char stabs_symbol
[] = STABS_SYMBOL
;
229 /* Extra builtin types */
231 struct type
*builtin_type_complex
;
232 struct type
*builtin_type_double_complex
;
233 struct type
*builtin_type_fixed_dec
;
234 struct type
*builtin_type_float_dec
;
235 struct type
*builtin_type_string
;
237 /* Forward declarations */
240 fixup_symtab
PARAMS ((HDRR
*, char *, file_ptr
, bfd
*));
243 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
246 read_the_mips_symtab
PARAMS ((bfd
*, CORE_ADDR
*));
249 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
252 parse_partial_symbols
PARAMS ((int, struct objfile
*,
253 struct section_offsets
*));
256 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
260 fixup_sigtramp
PARAMS ((void));
262 static struct symbol
*
263 new_symbol
PARAMS ((char *));
266 new_type
PARAMS ((char *));
268 static struct block
*
269 new_block
PARAMS ((int));
271 static struct symtab
*
272 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
274 static struct linetable
*
275 new_linetable
PARAMS ((int));
277 static struct blockvector
*
278 new_bvect
PARAMS ((int));
281 parse_type
PARAMS ((union aux_ext
*, int *, int));
283 static struct symbol
*
284 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
285 enum address_class
));
287 static struct block
*
288 shrink_block
PARAMS ((struct block
*, struct symtab
*));
291 xzalloc
PARAMS ((unsigned int));
294 sort_blocks
PARAMS ((struct symtab
*));
297 compare_blocks
PARAMS ((const void *, const void *));
299 static struct partial_symtab
*
300 new_psymtab
PARAMS ((char *, struct objfile
*));
303 static struct partial_symtab
*
304 parse_fdr
PARAMS ((int, int, struct objfile
*));
308 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
311 add_block
PARAMS ((struct block
*, struct symtab
*));
314 add_symbol
PARAMS ((struct symbol
*, struct block
*));
317 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
319 static struct linetable
*
320 shrink_linetable
PARAMS ((struct linetable
*));
323 mips_next_symbol_text
PARAMS ((void));
325 /* Things we export to other modules */
327 /* Address bounds for the signal trampoline in inferior, if any */
328 /* FIXME: Nothing really seems to use this. Why is it here? */
330 CORE_ADDR sigtramp_address
, sigtramp_end
;
333 mipscoff_new_init (ignore
)
334 struct objfile
*ignore
;
339 mipscoff_symfile_init (objfile
)
340 struct objfile
*objfile
;
342 if (objfile
-> sym_private
!= NULL
)
344 mfree (objfile
-> md
, objfile
-> sym_private
);
346 objfile
-> sym_private
= NULL
;
350 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
351 struct objfile
*objfile
;
352 struct section_offsets
*section_offsets
;
355 init_minimal_symbol_collection ();
356 make_cleanup (discard_minimal_symbols
, 0);
358 /* Now that the executable file is positioned at symbol table,
359 process it and define symbols accordingly. */
361 read_mips_symtab(objfile
, section_offsets
);
363 /* Install any minimal symbols that have been collected as the current
364 minimal symbols for this objfile. */
366 install_minimal_symbols (objfile
);
369 /* Perform any local cleanups required when we are done with a particular
370 objfile. I.E, we are in the process of discarding all symbol information
371 for an objfile, freeing up all memory held for it, and unlinking the
372 objfile struct from the global list of known objfiles. */
375 mipscoff_symfile_finish (objfile
)
376 struct objfile
*objfile
;
378 if (objfile
-> sym_private
!= NULL
)
380 mfree (objfile
-> md
, objfile
-> sym_private
);
383 /* If we have a file symbol header lying around, blow it away. */
392 /* Allocate zeroed memory */
398 PTR p
= xmalloc (size
);
404 /* Exported procedure: Builds a symtab from the PST partial one.
405 Restores the environment in effect when PST was created, delegates
406 most of the work to an ancillary procedure, and sorts
407 and reorders the symtab list at the end */
410 mipscoff_psymtab_to_symtab(pst
)
411 struct partial_symtab
*pst
;
418 printf_filtered("Reading in symbols for %s...", pst
->filename
);
421 /* Restore the header and list of pending typedefs */
422 cur_hdr
= CUR_HDR(pst
);
424 next_symbol_text_func
= mips_next_symbol_text
;
426 psymtab_to_symtab_1(pst
, pst
->filename
);
428 /* Match with global symbols. This only needs to be done once,
429 after all of the symtabs and dependencies have been read in. */
430 scan_file_globals (pst
->objfile
);
433 printf_filtered("done.\n");
436 /* Exported procedure: Is PC in the signal trampoline code */
439 in_sigtramp(pc
, ignore
)
441 char *ignore
; /* function name */
443 if (sigtramp_address
== 0)
445 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
448 /* File-level interface functions */
450 /* Read the symtab information from file ABFD into memory. Also,
451 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
454 read_the_mips_symtab(abfd
, end_of_text_segp
)
456 CORE_ADDR
*end_of_text_segp
;
458 int stsize
, st_hdrsize
;
460 struct hdr_ext hdr_ext
;
462 /* Header for executable/object file we read symbols from */
463 struct coff_exec filhdr
;
466 /* We need some info from the initial headers */
467 val
= bfd_seek(abfd
, (file_ptr
) 0, L_SET
);
468 val
= bfd_read((PTR
)&filhdr
, sizeof filhdr
, 1, abfd
);
470 if (end_of_text_segp
)
472 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
473 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
475 /* Find and read the symbol table header */
476 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
477 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
481 bfd_seek (abfd
, st_filptr
, L_SET
);
482 if (st_hdrsize
!= sizeof (hdr_ext
)) { /* Profanity check */
483 error ("Wrong header size: %d, not %d", st_hdrsize
,
486 if (bfd_read((PTR
)&hdr_ext
, st_hdrsize
, 1, abfd
) != st_hdrsize
)
488 ecoff_swap_hdr_in (abfd
, &hdr_ext
, &st_hdr
);
490 /* Find out how large the symbol table is */
491 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
492 + st_hdr
.iextMax
* cbEXTR
;
494 /* Allocate space for the symbol table. Read it in. */
495 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
497 memcpy((PTR
)cur_hdr
, (PTR
)&hdr_ext
, st_hdrsize
);
498 if (bfd_read((char *)cur_hdr
+ st_hdrsize
, stsize
, 1, abfd
) != stsize
)
501 /* Fixup file_pointers in it */
502 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
503 st_filptr
+ st_hdrsize
, abfd
);
507 error("Short read on %s", bfd_get_filename (abfd
));
511 /* Turn all file-relative pointers in the symtab described by HDR
512 into memory pointers, given that the symtab itself is located
513 at DATA in memory and F_PTR in the file.
515 Byte-swap all the data structures, in place, while we are at it --
516 except AUX entries, which we leave in their original byte order.
517 They will be swapped as they are used instead. (FIXME: we ought to
518 do all the data structures that way.) */
521 fixup_symtab (hdr
, data
, f_ptr
, abfd
)
532 struct rfd_ext
*rbase
;
534 /* This function depends on the external and internal forms
535 of the MIPS symbol table taking identical space. Check this
536 assumption at compile-time.
537 DO NOT DELETE THESE ENTRIES, OR COMMENT THEM OUT, JUST BECAUSE SOME
538 "LINT" OR COMPILER THINKS THEY ARE UNUSED! Thank you. */
539 static check_hdr1
[1 + sizeof (struct hdr_ext
) - sizeof (HDRR
)] = {0};
540 static check_hdr2
[1 + sizeof (HDRR
) - sizeof (struct hdr_ext
)] = {0};
541 static check_fdr1
[1 + sizeof (struct fdr_ext
) - sizeof (FDR
)] = {0};
542 static check_fdr2
[1 + sizeof (FDR
) - sizeof (struct fdr_ext
)] = {0};
543 static check_pdr1
[1 + sizeof (struct pdr_ext
) - sizeof (PDR
)] = {0};
544 static check_pdr2
[1 + sizeof (PDR
) - sizeof (struct pdr_ext
)] = {0};
545 static check_sym1
[1 + sizeof (struct sym_ext
) - sizeof (SYMR
)] = {0};
546 static check_sym2
[1 + sizeof (SYMR
) - sizeof (struct sym_ext
)] = {0};
547 static check_ext1
[1 + sizeof (struct ext_ext
) - sizeof (EXTR
)] = {0};
548 static check_ext2
[1 + sizeof (EXTR
) - sizeof (struct ext_ext
)] = {0};
549 static check_rfd1
[1 + sizeof (struct rfd_ext
) - sizeof (RFDT
)] = {0};
550 static check_rfd2
[1 + sizeof (RFDT
) - sizeof (struct rfd_ext
)] = {0};
552 /* Swap in the header record. */
553 ecoff_swap_hdr_in (abfd
, hdr
, hdr
);
556 * These fields are useless (and empty) by now:
557 * hdr->cbDnOffset, hdr->cbOptOffset
558 * We use them for other internal purposes.
561 hdr
->cbOptOffset
= 0;
564 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
578 /* Fix all the RFD's. */
579 rbase
= (struct rfd_ext
*)(hdr
->cbRfdOffset
);
580 for (i
= 0; i
< hdr
->crfd
; i
++) {
581 ecoff_swap_rfd_in (abfd
, rbase
+i
, (pRFDT
) rbase
+i
);
584 /* Fix all string pointers inside the symtab, and
585 the FDR records. Also fix other miscellany. */
587 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
588 register unsigned code_offset
;
590 /* Header itself, and strings */
591 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
593 /* Swap in the FDR */
594 ecoff_swap_fdr_in (abfd
, fh
, fh
);
596 fh
->issBase
+= hdr
->cbSsOffset
;
598 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
601 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
603 /* FIXME! Probably don't want to do this here! */
604 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
605 sh
= (SYMR
*)fh
->isymBase
+ s_idx
;
606 ecoff_swap_sym_in (abfd
, sh
, sh
);
608 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
614 /* cannot fix fh->ipdFirst because it is a short */
615 #define IPDFIRST(h,fh) \
616 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
618 /* Optional symbols (actually used for partial_symtabs) */
624 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(union aux_ext
);
625 /* Relative file descriptor table */
626 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
630 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
632 /* Procedure symbols. (XXX This should be done later) */
633 code_offset
= fh
->adr
;
634 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
635 unsigned name
, only_ext
;
637 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
638 ecoff_swap_pdr_in (abfd
, pr
, pr
);
640 /* Simple rule to find files linked "-x" */
641 only_ext
= fh
->rss
== -1;
643 if (pr
->isym
== -1) {
644 /* static function */
648 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
649 sh
= &((EXTR
*)name
)->asym
;
653 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
654 /* Included code ? */
655 if (s_idx
== 0 && pr
->adr
!= 0)
656 code_offset
-= pr
->adr
;
659 /* Turn index into a pointer */
662 /* Fix line numbers */
663 pr
->cbLineOffset
+= fh
->cbLineOffset
;
665 /* Relocate address */
667 pr
->adr
+= code_offset
;
671 /* External symbols: swap in, and fix string */
672 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
673 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
674 ecoff_swap_ext_in (abfd
, esh
, esh
);
675 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
680 /* Find a file descriptor given its index RF relative to a file CF */
688 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
689 /* Object files do not have the RFD table, all refs are absolute */
691 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
692 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
693 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
696 /* Return a safer print NAME for a file descriptor */
702 if (name
== (char *) -1)
703 return "<stripped file>";
704 if (UNSAFE_DATA_ADDR(name
))
710 /* Read in and parse the symtab of the file OBJFILE. Symbols from
711 different sections are relocated via the SECTION_OFFSETS. */
714 read_mips_symtab (objfile
, section_offsets
)
715 struct objfile
*objfile
;
716 struct section_offsets
*section_offsets
;
718 CORE_ADDR end_of_text_seg
;
720 read_the_mips_symtab(objfile
->obfd
, &end_of_text_seg
);
722 parse_partial_symbols(end_of_text_seg
, objfile
, section_offsets
);
726 * Check to make sure file was compiled with -g.
727 * If not, warn the user of this limitation.
729 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
730 if (max_gdbinfo
== 0)
732 "\n%s not compiled with -g, debugging support is limited.\n",
735 "You should compile with -g2 or -g3 for best debugging support.\n");
741 /* Local utilities */
743 /* Map of FDR indexes to partial symtabs */
746 struct partial_symtab
*pst
; /* the psymtab proper */
747 int n_globals
; /* exported globals (external symbols) */
748 int globals_offset
; /* cumulative */
752 /* Utility stack, used to nest procedures and blocks properly.
753 It is a doubly linked list, to avoid too many alloc/free.
754 Since we might need it quite a few times it is NOT deallocated
757 static struct parse_stack
{
758 struct parse_stack
*next
, *prev
;
759 struct symtab
*cur_st
; /* Current symtab. */
760 struct block
*cur_block
; /* Block in it. */
761 int blocktype
; /* What are we parsing. */
762 int maxsyms
; /* Max symbols in this block. */
763 struct type
*cur_type
; /* Type we parse fields for. */
764 int cur_field
; /* Field number in cur_type. */
765 int procadr
; /* Start addres of this procedure */
766 int numargs
; /* Its argument count */
767 } *top_stack
; /* Top stack ptr */
770 /* Enter a new lexical context */
775 struct parse_stack
*new;
777 /* Reuse frames if possible */
778 if (top_stack
&& top_stack
->prev
)
779 new = top_stack
->prev
;
781 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
782 /* Initialize new frame with previous content */
784 register struct parse_stack
*prev
= new->prev
;
787 top_stack
->prev
= new;
789 new->next
= top_stack
;
794 /* Exit a lexical context */
802 top_stack
= top_stack
->next
;
806 /* Cross-references might be to things we haven't looked at
807 yet, e.g. type references. To avoid too many type
808 duplications we keep a quick fixup table, an array
809 of lists of references indexed by file descriptor */
811 static struct mips_pending
{
812 struct mips_pending
*next
; /* link */
813 SYMR
*s
; /* the symbol */
814 struct type
*t
; /* its partial type descriptor */
818 /* Check whether we already saw symbol SH in file FH as undefined */
820 static struct mips_pending
*
821 is_pending_symbol(fh
, sh
)
825 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
826 register struct mips_pending
*p
;
828 /* Linear search is ok, list is typically no more than 10 deep */
829 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
835 /* Add a new undef symbol SH of type T */
838 add_pending(fh
, sh
, t
)
843 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
844 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
846 /* Make sure we do not make duplicates */
848 p
= (struct mips_pending
*) xmalloc(sizeof(*p
));
851 p
->next
= pending_list
[f_idx
];
852 pending_list
[f_idx
] = p
;
854 sh
->reserved
= 1; /* for quick check */
857 /* Throw away undef entries when done with file index F_IDX */
858 /* FIXME -- storage leak. This is never called!!! --gnu */
866 register struct mips_pending
*p
, *q
;
868 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
872 pending_list
[f_idx
] = 0;
878 prepend_tag_kind(tag_name
, type_code
)
880 enum type_code type_code
;
888 case TYPE_CODE_STRUCT
:
891 case TYPE_CODE_UNION
:
898 result
= (char*)obstack_alloc (¤t_objfile
->symbol_obstack
,
899 strlen(prefix
) + strlen(tag_name
) + 1);
900 sprintf(result
, "%s%s", prefix
, tag_name
);
905 /* Parsing Routines proper. */
907 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
908 For blocks, procedures and types we open a new lexical context.
909 This is basically just a big switch on the symbol's type.
910 Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
911 BIGEND says whether aux symbols are big-endian or little-endian.
912 Return count of SYMR's handled (normally one). */
915 parse_symbol(sh
, ax
, bigend
)
926 /* When a symbol is cross-referenced from other files/symbols
927 we mark it explicitly */
928 int pend
= (sh
->reserved
== 1);
929 enum address_class
class;
937 case stGlobal
: /* external symbol, goes into global block */
939 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
941 s
= new_symbol((char *)sh
->iss
);
942 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
945 case stStatic
: /* static data, goes into current block. */
947 b
= top_stack
->cur_block
;
948 s
= new_symbol((char *)sh
->iss
);
949 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
952 case stLocal
: /* local variable, goes into current block */
953 if (sh
->sc
== scRegister
) {
954 class = LOC_REGISTER
;
956 sh
->value
+= FP0_REGNUM
-32;
959 b
= top_stack
->cur_block
;
960 s
= new_symbol((char *)sh
->iss
);
961 SYMBOL_VALUE(s
) = sh
->value
;
963 data
: /* Common code for symbols describing data */
964 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
965 SYMBOL_CLASS(s
) = class;
968 /* Type could be missing in a number of cases */
969 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
970 sh
->index
== 0xfffff)
971 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
973 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
974 /* Value of a data symbol is its memory address */
977 case stParam
: /* arg to procedure, goes into current block */
979 top_stack
->numargs
++;
981 name
= (char*)sh
->iss
;
982 /* Special GNU C++ name. */
983 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
984 name
= "this"; /* FIXME, not alloc'd in obstack */
985 s
= new_symbol(name
);
987 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
988 if (sh
->sc
== scRegister
) {
989 SYMBOL_CLASS(s
) = LOC_REGPARM
;
991 sh
->value
+= FP0_REGNUM
-32;
993 SYMBOL_CLASS(s
) = LOC_ARG
;
994 SYMBOL_VALUE(s
) = sh
->value
;
995 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
996 add_symbol(s
, top_stack
->cur_block
);
998 /* FIXME: This has not been tested. See dbxread.c */
999 /* Add the type of this parameter to the function/procedure
1000 type of this block. */
1001 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
1005 case stLabel
: /* label, goes into current block */
1006 s
= new_symbol((char *)sh
->iss
);
1007 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
1008 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
1009 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
1010 SYMBOL_TYPE(s
) = builtin_type_int
;
1011 add_symbol(s
, top_stack
->cur_block
);
1014 case stProc
: /* Procedure, usually goes into global block */
1015 case stStaticProc
: /* Static procedure, goes into current block */
1016 s
= new_symbol((char *)sh
->iss
);
1017 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1018 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1019 /* Type of the return value */
1020 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1021 t
= builtin_type_int
;
1023 t
= parse_type(ax
+ sh
->index
+ 1, 0, bigend
);
1024 b
= top_stack
->cur_block
;
1025 if (sh
->st
== stProc
) {
1026 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1027 /* The next test should normally be true,
1028 but provides a hook for nested functions
1029 (which we don't want to make global). */
1030 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
1031 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
1035 /* Make a type for the procedure itself */
1037 /* FIXME: This has not been tested yet! See dbxread.c */
1038 /* Generate a template for the type of this function. The
1039 types of the arguments will be added as we read the symbol
1041 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
1043 SYMBOL_TYPE(s
) = lookup_function_type (t
);
1046 /* Create and enter a new lexical context */
1047 b
= new_block(top_stack
->maxsyms
);
1048 SYMBOL_BLOCK_VALUE(s
) = b
;
1049 BLOCK_FUNCTION(b
) = s
;
1050 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
1051 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1052 add_block(b
, top_stack
->cur_st
);
1054 /* Not if we only have partial info */
1055 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
1059 top_stack
->cur_block
= b
;
1060 top_stack
->blocktype
= sh
->st
;
1061 top_stack
->cur_type
= SYMBOL_TYPE(s
);
1062 top_stack
->cur_field
= -1;
1063 top_stack
->procadr
= sh
->value
;
1064 top_stack
->numargs
= 0;
1066 sh
->value
= (long) SYMBOL_TYPE(s
);
1069 /* Beginning of code for structure, union, and enum definitions.
1070 They all share a common set of local variables, defined here. */
1072 enum type_code type_code
;
1078 case stStruct
: /* Start a block defining a struct type */
1079 type_code
= TYPE_CODE_STRUCT
;
1080 goto structured_common
;
1082 case stUnion
: /* Start a block defining a union type */
1083 type_code
= TYPE_CODE_UNION
;
1084 goto structured_common
;
1086 case stEnum
: /* Start a block defining an enum type */
1087 type_code
= TYPE_CODE_ENUM
;
1088 goto structured_common
;
1090 case stBlock
: /* Either a lexical block, or some type */
1091 if (sh
->sc
!= scInfo
)
1092 goto case_stBlock_code
; /* Lexical block */
1094 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
1096 /* Common code for handling struct, union, enum, and/or as-yet-
1097 unknown-type blocks of info about structured data. `type_code'
1098 has been set to the proper TYPE_CODE, if we know it. */
1101 top_stack
->blocktype
= stBlock
;
1103 s
= new_symbol((char *)sh
->iss
);
1104 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
1105 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1106 SYMBOL_VALUE(s
) = 0;
1107 add_symbol(s
, top_stack
->cur_block
);
1109 /* First count the number of fields and the highest value. */
1112 for (tsym
= sh
+1; tsym
->st
!= stEnd
; tsym
++)
1114 if (tsym
->st
== stMember
) {
1115 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
1116 /* If the type of the member is Nil (or Void),
1117 without qualifiers, assume the tag is an
1119 if (tsym
->index
== indexNil
)
1120 type_code
= TYPE_CODE_ENUM
;
1122 ecoff_swap_tir_in (bigend
,
1123 &ax
[tsym
->index
].a_ti
,
1125 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
1126 && tir
.tq0
== tqNil
)
1127 type_code
= TYPE_CODE_ENUM
;
1130 if (tsym
->value
> max_value
)
1131 max_value
= tsym
->value
;
1133 else if (tsym
->st
== stBlock
1134 || tsym
->st
== stUnion
1135 || tsym
->st
== stEnum
1136 || tsym
->st
== stStruct
1137 || tsym
->st
== stParsed
) {
1138 if (tsym
->sc
== scVariant
) ; /*UNIMPLEMENTED*/
1139 if (tsym
->index
!= 0)
1140 tsym
= ((SYMR
*)cur_fdr
->isymBase
)
1143 else complain (&block_member_complaint
, tsym
->st
);
1146 /* In an stBlock, there is no way to distinguish structs,
1147 unions, and enums at this point. This is a bug in the
1148 original design (that has been fixed with the
1149 recent addition of the stStruct, stUnion, and stEnum
1150 symbol types.) The way you can tell is if/when you
1151 see a variable or field of that type. In that case
1152 the variable's type (in the AUX table) says if the
1153 type is struct, union, or enum,
1154 and points back to the stBlock here.
1155 So you can patch the tag kind up later - but only
1156 if there actually is a variable or field of that type.
1158 So until we know for sure, we will guess at this point.
1160 If the first member has index==indexNil or a void type,
1161 assume we have an enumeration.
1162 Otherwise, if there is more than one member, and all
1163 the members have offset 0, assume we have a union.
1164 Otherwise, assume we have a struct.
1166 The heuristic could guess wrong in the case of
1167 of an enumeration with no members or a union
1168 with one (or zero) members, or when all except the
1169 last field of a struct have width zero.
1170 These are uncommon and/or illegal situations, and
1171 in any case guessing wrong probably doesn't matter much.
1173 But if we later do find out we were wrong,
1174 we fixup the tag kind. Members of an enumeration
1175 must be handled differently from struct/union fields,
1176 and that is harder to patch up, but luckily we
1177 shouldn't need to. (If there are any enumeration
1178 members, we can tell for sure it's an enum here.) */
1180 if (type_code
== TYPE_CODE_UNDEF
)
1181 if (nfields
> 1 && max_value
== 0)
1182 type_code
= TYPE_CODE_UNION
;
1184 type_code
= TYPE_CODE_STRUCT
;
1186 /* If this type was expected, use its partial definition */
1188 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
1190 t
= new_type(prepend_tag_kind((char *)sh
->iss
,
1193 TYPE_CODE(t
) = type_code
;
1194 TYPE_LENGTH(t
) = sh
->value
;
1195 TYPE_NFIELDS(t
) = nfields
;
1196 TYPE_FIELDS(t
) = f
= (struct field
*)
1197 TYPE_ALLOC (t
, nfields
* sizeof (struct field
));
1199 if (type_code
== TYPE_CODE_ENUM
) {
1200 /* This is a non-empty enum. */
1201 for (tsym
= sh
+ 1; tsym
->st
== stMember
; tsym
++) {
1202 struct symbol
*enum_sym
;
1203 f
->bitpos
= tsym
->value
;
1205 f
->name
= (char*)tsym
->iss
;
1208 enum_sym
= (struct symbol
*)
1209 obstack_alloc (¤t_objfile
->symbol_obstack
,
1210 sizeof (struct symbol
));
1211 memset ((PTR
)enum_sym
, 0, sizeof (struct symbol
));
1212 SYMBOL_NAME (enum_sym
) = f
->name
;
1213 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1214 SYMBOL_TYPE (enum_sym
) = t
;
1215 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1216 SYMBOL_VALUE (enum_sym
) = tsym
->value
;
1217 add_symbol(enum_sym
, top_stack
->cur_block
);
1219 /* Skip the stMembers that we've handled. */
1225 /* make this the current type */
1226 top_stack
->cur_type
= t
;
1227 top_stack
->cur_field
= 0;
1228 /* Mark that symbol has a type, and say which one */
1229 sh
->value
= (long) t
;
1232 /* End of local variables shared by struct, union, enum, and
1233 block (as yet unknown struct/union/enum) processing. */
1237 /* beginnning of (code) block. Value of symbol
1238 is the displacement from procedure start */
1240 top_stack
->blocktype
= stBlock
;
1241 b
= new_block(top_stack
->maxsyms
);
1242 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
1243 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1244 top_stack
->cur_block
= b
;
1245 add_block(b
, top_stack
->cur_st
);
1248 case stEnd
: /* end (of anything) */
1249 if (sh
->sc
== scInfo
) {
1250 /* Finished with type */
1251 top_stack
->cur_type
= 0;
1252 } else if (sh
->sc
== scText
&&
1253 (top_stack
->blocktype
== stProc
||
1254 top_stack
->blocktype
== stStaticProc
)) {
1255 /* Finished with procedure */
1256 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
1257 struct mips_extra_func_info
*e
;
1261 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
1263 /* Make up special symbol to contain procedure specific
1265 s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
1266 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
1267 SYMBOL_CLASS(s
) = LOC_CONST
;
1268 SYMBOL_TYPE(s
) = builtin_type_void
;
1269 e
= (struct mips_extra_func_info
*)
1270 obstack_alloc (¤t_objfile
->symbol_obstack
,
1271 sizeof (struct mips_extra_func_info
));
1272 SYMBOL_VALUE(s
) = (int)e
;
1273 e
->numargs
= top_stack
->numargs
;
1274 add_symbol(s
, top_stack
->cur_block
);
1276 /* Reallocate symbols, saving memory */
1277 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1279 /* f77 emits proc-level with address bounds==[0,0],
1280 So look for such child blocks, and patch them. */
1281 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
1282 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
1283 if (BLOCK_SUPERBLOCK(b_bad
) == b
1284 && BLOCK_START(b_bad
) == top_stack
->procadr
1285 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
1286 BLOCK_START(b_bad
) = BLOCK_START(b
);
1287 BLOCK_END(b_bad
) = BLOCK_END(b
);
1290 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
1291 /* End of (code) block. The value of the symbol
1292 is the displacement from the procedure`s start
1293 address of the end of this block. */
1294 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1295 shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
1296 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
) {
1297 /* End of file. Pop parse stack and ignore. Higher
1298 level code deals with this. */
1300 } else complain (&stEnd_complaint
, sh
->sc
);
1302 pop_parse_stack(); /* restore previous lexical context */
1305 case stMember
: /* member of struct or union */
1306 f
= &TYPE_FIELDS(top_stack
->cur_type
)[top_stack
->cur_field
++];
1307 f
->name
= (char*)sh
->iss
;
1308 f
->bitpos
= sh
->value
;
1310 f
->type
= parse_type(ax
+ sh
->index
, &f
->bitsize
, bigend
);
1313 case stTypedef
: /* type definition */
1314 s
= new_symbol((char *)sh
->iss
);
1315 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1316 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1317 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1318 add_symbol(s
, top_stack
->cur_block
);
1319 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, 0, bigend
);
1320 sh
->value
= (long) SYMBOL_TYPE(s
);
1323 case stFile
: /* file name */
1325 top_stack
->blocktype
= sh
->st
;
1328 /* I`ve never seen these for C */
1330 break; /* register relocation */
1332 break; /* forwarding address */
1334 break; /* constant */
1336 complain(&unknown_mips_symtype_complaint
, sh
->st
);
1343 /* Parse the type information provided in the raw AX entries for
1344 the symbol SH. Return the bitfield size in BS, in case.
1345 We must byte-swap the AX entries before we use them; BIGEND says whether
1346 they are big-endian or little-endian (from fh->fBigendian). */
1348 static struct type
*
1349 parse_type(ax
, bs
, bigend
)
1354 /* Null entries in this map are treated specially */
1355 static struct type
**map_bt
[] =
1357 &builtin_type_void
, /* btNil */
1359 &builtin_type_char
, /* btChar */
1360 &builtin_type_unsigned_char
, /* btUChar */
1361 &builtin_type_short
, /* btShort */
1362 &builtin_type_unsigned_short
, /* btUShort */
1363 &builtin_type_int
, /* btInt */
1364 &builtin_type_unsigned_int
, /* btUInt */
1365 &builtin_type_long
, /* btLong */
1366 &builtin_type_unsigned_long
, /* btULong */
1367 &builtin_type_float
, /* btFloat */
1368 &builtin_type_double
, /* btDouble */
1375 &builtin_type_complex
, /* btComplex */
1376 &builtin_type_double_complex
, /* btDComplex */
1378 &builtin_type_fixed_dec
, /* btFixedDec */
1379 &builtin_type_float_dec
, /* btFloatDec */
1380 &builtin_type_string
, /* btString */
1383 &builtin_type_void
, /* btVoid */
1384 &builtin_type_long_long
, /* btLongLong */
1385 &builtin_type_unsigned_long_long
,/* btULongLong */
1389 struct type
*tp
= 0;
1392 enum type_code type_code
;
1394 /* Use aux as a type information record, map its basic type. */
1396 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1397 if (t
->bt
> (sizeof (map_bt
)/sizeof (*map_bt
))) {
1398 complain (&basic_type_complaint
, t
->bt
);
1399 return builtin_type_int
;
1401 if (map_bt
[t
->bt
]) {
1402 tp
= *map_bt
[t
->bt
];
1406 /* Cannot use builtin types -- build our own */
1409 tp
= lookup_pointer_type (builtin_type_void
);
1413 type_code
= TYPE_CODE_STRUCT
;
1417 type_code
= TYPE_CODE_UNION
;
1421 type_code
= TYPE_CODE_ENUM
;
1425 type_code
= TYPE_CODE_RANGE
;
1429 type_code
= TYPE_CODE_SET
;
1434 complain (&basic_type_complaint
, t
->bt
);
1435 return builtin_type_int
;
1439 /* Skip over any further type qualifiers (FIXME). */
1441 /* This is the way it would work if the compiler worked */
1445 ecoff_swap_tir_in (bigend
, ax
, t1
);
1446 } while (t1
->continued
);
1449 /* Move on to next aux */
1453 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1457 /* All these types really point to some (common) MIPS type
1458 definition, and only the type-qualifiers fully identify
1459 them. We'll make the same effort at sharing. */
1460 if (t
->bt
== btIndirect
||
1461 t
->bt
== btStruct
||
1464 t
->bt
== btTypedef
||
1467 char name
[256], *pn
;
1469 /* Try to cross reference this type */
1470 ax
+= cross_ref(ax
, &tp
, type_code
, &pn
, bigend
);
1471 /* reading .o file ? */
1472 if (UNSAFE_DATA_ADDR(tp
))
1473 tp
= init_type(type_code
, 0, 0, (char *) NULL
,
1474 (struct objfile
*) NULL
);
1475 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1476 sprintf(name
, fmt
, pn
);
1478 /* Usually, TYPE_CODE(tp) is already type_code. The main
1479 exception is if we guessed wrong re struct/union/enum. */
1480 if (TYPE_CODE(tp
) != type_code
) {
1481 complain (&bad_tag_guess_complaint
, name
);
1482 TYPE_CODE(tp
) = type_code
;
1484 if (TYPE_NAME(tp
) == NULL
|| !STREQ (TYPE_NAME(tp
), name
))
1485 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
),
1486 ¤t_objfile
-> type_obstack
);
1489 /* Deal with range types */
1490 if (t
->bt
== btRange
) {
1491 TYPE_NFIELDS (tp
) = 2;
1492 TYPE_FIELDS (tp
) = (struct field
*)
1493 TYPE_ALLOC (tp
, 2 * sizeof (struct field
));
1494 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1495 ¤t_objfile
-> type_obstack
);
1496 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1498 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1499 ¤t_objfile
-> type_obstack
);
1500 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1504 /* Parse all the type qualifiers now. If there are more
1505 than 6 the game will continue in the next aux */
1507 #define PARSE_TQ(tq) \
1508 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1510 again
: PARSE_TQ(tq0
);
1520 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1526 /* Make up a complex type from a basic one. Type is passed by
1527 reference in TPP and side-effected as necessary. The type
1528 qualifier TQ says how to handle the aux symbols at AX for
1529 the symbol SX we are currently analyzing. BIGEND says whether
1530 aux symbols are big-endian or little-endian.
1531 Returns the number of aux symbols we parsed. */
1534 upgrade_type(tpp
, tq
, ax
, bigend
)
1543 /* Used in array processing */
1552 t
= lookup_pointer_type (*tpp
);
1557 t
= lookup_function_type (*tpp
);
1562 /* We should probably try to use create_range_type and
1563 create_array_type here. FIXME! */
1565 t
= init_type(TYPE_CODE_ARRAY
, 0, 0, (char *) NULL
,
1566 (struct objfile
*) NULL
);
1567 TYPE_TARGET_TYPE(t
) = *tpp
;
1569 /* Determine and record the domain type (type of index) */
1570 ecoff_swap_rndx_in (bigend
, ax
, &rndx
);
1575 rf
= AUX_GET_ISYM (bigend
, ax
);
1578 fh
= get_rfd(cur_fd
, rf
);
1580 /* Fields are kept in an array */
1581 /* FIXME - Memory leak! */
1582 if (TYPE_NFIELDS(t
))
1583 TYPE_FIELDS(t
) = (struct field
*)
1584 xrealloc((PTR
) TYPE_FIELDS(t
),
1585 (TYPE_NFIELDS(t
)+1) * sizeof(struct field
));
1587 TYPE_FIELDS(t
) = (struct field
*)
1588 xzalloc(sizeof(struct field
));
1589 f
= &(TYPE_FIELD(t
,TYPE_NFIELDS(t
)));
1591 memset((PTR
)f
, 0, sizeof(struct field
));
1593 /* XXX */ f
->type
= parse_type(id
+ (union aux_ext
*)fh
->iauxBase
,
1594 &f
->bitsize
, bigend
);
1597 lower
= AUX_GET_DNLOW (bigend
, ax
);
1599 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1601 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1603 /* Check whether supplied array element bit size matches
1604 the known size of the element type. If this complaint
1605 ends up not happening, we can remove this code. It's
1606 here because we aren't sure we understand this *&%&$
1608 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1610 /* Most likely an undefined type */
1612 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1615 complain (&array_bitsize_complaint
, rf
);
1617 TYPE_LENGTH(t
) = (upper
< 0) ? 0 :
1618 (upper
- lower
+ 1) * (rf
>> 3);
1623 /* Volatile -- currently ignored */
1627 /* Const -- currently ignored */
1631 complain (&unknown_type_qual_complaint
, tq
);
1637 /* Parse a procedure descriptor record PR. Note that the procedure
1638 is parsed _after_ the local symbols, now we just insert the extra
1639 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has already
1640 been placed in the procedure's main block. Note also that images that
1641 have been partially stripped (ld -x) have been deprived
1642 of local symbols, and we have to cope with them here.
1643 The procedure's code ends at BOUND */
1646 parse_procedure (pr
, bound
, have_stabs
)
1651 struct symbol
*s
, *i
;
1652 SYMR
*sh
= (SYMR
*)pr
->isym
;
1654 struct mips_extra_func_info
*e
;
1657 /* Static procedure at address pr->adr. Sigh. */
1658 if (sh
== (SYMR
*)-1) {
1659 complain (&pdr_static_symbol_complaint
, pr
->adr
);
1662 sh_name
= (char*)sh
->iss
;
1664 s
= lookup_symbol(sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1666 s
= mylookup_symbol(sh_name
, top_stack
->cur_block
,
1667 VAR_NAMESPACE
, LOC_BLOCK
);
1670 b
= SYMBOL_BLOCK_VALUE(s
);
1672 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1676 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1677 s
= new_symbol(sh_name
);
1678 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1679 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1680 /* Donno its type, hope int is ok */
1681 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1682 add_symbol(s
, top_stack
->cur_block
);
1683 /* Wont have symbols for this one */
1685 SYMBOL_BLOCK_VALUE(s
) = b
;
1686 BLOCK_FUNCTION(b
) = s
;
1687 BLOCK_START(b
) = pr
->adr
;
1688 BLOCK_END(b
) = bound
;
1689 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1690 add_block(b
, top_stack
->cur_st
);
1694 i
= mylookup_symbol(MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1698 e
= (struct mips_extra_func_info
*)SYMBOL_VALUE(i
);
1700 e
->pdr
.isym
= (long)s
;
1704 /* Parse the external symbol ES. Just call parse_symbol() after
1705 making sure we know where the aux are for it. For procedures,
1706 parsing of the PDRs has already provided all the needed
1707 information, we only parse them if SKIP_PROCEDURES is false,
1708 and only if this causes no symbol duplication.
1709 BIGEND says whether aux entries are big-endian or little-endian.
1711 This routine clobbers top_stack->cur_block and ->cur_st. */
1714 parse_external(es
, skip_procedures
, bigend
)
1716 int skip_procedures
;
1721 if (es
->ifd
!= ifdNil
) {
1723 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1724 ax
= (union aux_ext
*)cur_fdr
->iauxBase
;
1726 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1730 /* Reading .o files */
1731 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1733 switch (es
->asym
.st
) {
1735 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1736 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1737 case stLabel
: what
= "label"; n_undef_labels
++; break;
1738 default : what
= "symbol"; break;
1741 /* FIXME: Turn this into a complaint? */
1743 printf_filtered("Warning: %s `%s' is undefined (in %s)\n",
1744 what
, es
->asym
.iss
, fdr_name((char *)cur_fdr
->rss
));
1748 switch (es
->asym
.st
) {
1750 /* If we have full symbols we do not need more */
1751 if (skip_procedures
)
1753 if (mylookup_symbol ((char *)es
->asym
.iss
, top_stack
->cur_block
,
1754 VAR_NAMESPACE
, LOC_BLOCK
))
1760 * Note that the case of a symbol with indexNil
1761 * must be handled anyways by parse_symbol().
1763 parse_symbol(&es
->asym
, ax
, bigend
);
1770 /* Parse the line number info for file descriptor FH into
1771 GDB's linetable LT. MIPS' encoding requires a little bit
1772 of magic to get things out. Note also that MIPS' line
1773 numbers can go back and forth, apparently we can live
1774 with that and do not need to reorder our linetables */
1779 struct linetable
*lt
;
1781 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1783 int delta
, count
, lineno
= 0;
1789 /* Scan by procedure descriptors */
1791 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1794 /* No code for this one */
1795 if (pr
->iline
== ilineNil
||
1796 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1799 * Aurgh! To know where to stop expanding we
1802 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1803 if (pr
[l
].iline
!= -1)
1805 if (l
== (fh
->cpd
- j
))
1810 * When procedures are moved around the linenumbers
1811 * are attributed to the next procedure up
1813 if (pr
->iline
>= halt
) continue;
1815 base
= (unsigned char*)pr
->cbLineOffset
;
1816 l
= pr
->adr
>> 2; /* in words */
1817 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1818 for (lineno
= pr
->lnLow
; l
< halt
;) {
1819 count
= *base
& 0x0f;
1820 delta
= *base
++ >> 4;
1824 delta
= (base
[0] << 8) | base
[1];
1825 if (delta
>= 0x8000)
1829 lineno
+= delta
;/* first delta is 0 */
1830 k
= add_line(lt
, lineno
, l
, k
);
1836 /* Master parsing procedure for first-pass reading of file symbols
1837 into a partial_symtab.
1839 Parses the symtab described by the global symbolic header CUR_HDR.
1840 END_OF_TEXT_SEG gives the address just after the text segment for
1841 the symtab we are reading. */
1844 parse_partial_symbols (end_of_text_seg
, objfile
, section_offsets
)
1845 int end_of_text_seg
;
1846 struct objfile
*objfile
;
1847 struct section_offsets
*section_offsets
;
1850 HDRR
*hdr
= cur_hdr
;
1851 /* Running pointers */
1855 struct partial_symtab
*pst
;
1857 int past_first_source_file
= 0;
1859 /* List of current psymtab's include files */
1860 char **psymtab_include_list
;
1861 int includes_allocated
;
1864 struct pst_map
* fdr_to_pst
;
1865 /* Index within current psymtab dependency list */
1866 struct partial_symtab
**dependency_list
;
1867 int dependencies_used
, dependencies_allocated
;
1868 struct cleanup
*old_chain
;
1871 extern_tab
= (EXTR
**)obstack_alloc (&objfile
->psymbol_obstack
,
1872 sizeof(EXTR
*) * hdr
->iextMax
);
1874 includes_allocated
= 30;
1876 psymtab_include_list
= (char **) alloca (includes_allocated
*
1878 next_symbol_text_func
= mips_next_symbol_text
;
1880 dependencies_allocated
= 30;
1881 dependencies_used
= 0;
1883 (struct partial_symtab
**) alloca (dependencies_allocated
*
1884 sizeof (struct partial_symtab
*));
1886 last_source_file
= NULL
;
1891 * Only parse the Local and External symbols, and the Relative FDR.
1892 * Fixup enough of the loader symtab to be able to use it.
1893 * Allocate space only for the file's portions we need to
1898 max_glevel
= MIN_GLEVEL
;
1900 /* Allocate the map FDR -> PST.
1901 Minor hack: -O3 images might claim some global data belongs
1902 to FDR -1. We`ll go along with that */
1903 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1904 old_chain
= make_cleanup (free
, fdr_to_pst
);
1907 struct partial_symtab
* pst
= new_psymtab("", objfile
);
1908 fdr_to_pst
[-1].pst
= pst
;
1912 /* Pass 1 over external syms: Presize and partition the list */
1913 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1914 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1915 fdr_to_pst
[esh
->ifd
].n_globals
++;
1918 /* Pass 1.5 over files: partition out global symbol space */
1920 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1921 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1922 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1923 fdr_to_pst
[f_idx
].n_globals
= 0;
1926 /* Pass 2 over external syms: fill in external symbols */
1927 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1928 enum minimal_symbol_type ms_type
= mst_text
;
1929 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1931 extern_tab
[fdr_to_pst
[esh
->ifd
].globals_offset
1932 + fdr_to_pst
[esh
->ifd
].n_globals
++] = esh
;
1934 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1937 switch (esh
->asym
.st
) {
1946 ms_type
= mst_unknown
;
1947 complain (&unknown_ext_complaint
, esh
->asym
.iss
);
1949 name
= (char *)esh
->asym
.iss
;
1950 prim_record_minimal_symbol (name
, esh
->asym
.value
, ms_type
);
1953 /* Pass 3 over files, over local syms: fill in static symbols */
1954 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1955 struct partial_symtab
*save_pst
;
1958 cur_fdr
= fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1960 if (fh
->csym
== 0) {
1961 fdr_to_pst
[f_idx
].pst
= NULL
;
1964 pst
= start_psymtab_common (objfile
, section_offsets
, (char*)fh
->rss
,
1965 fh
->cpd
? fh
->adr
: 0,
1966 objfile
->global_psymbols
.next
,
1967 objfile
->static_psymbols
.next
);
1968 pst
->read_symtab_private
= (char *)
1969 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1972 /* Make everything point to everything. */
1973 FDR_IDX(pst
) = f_idx
;
1974 fdr_to_pst
[f_idx
].pst
= pst
;
1975 fh
->ioptBase
= (int)pst
;
1977 CUR_HDR(pst
) = cur_hdr
;
1979 /* The way to turn this into a symtab is to call... */
1980 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1982 pst
->texthigh
= pst
->textlow
;
1984 /* For stabs-in-ecoff files, the second symbol must be @stab.
1985 This symbol is emitted by mips-tfile to signal
1986 that the current object file uses encapsulated stabs
1987 instead of mips ecoff for local symbols.
1988 (It is the second symbol because the first symbol is
1989 the stFile used to signal the start of a file). */
1991 && STREQ((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)) {
1992 processing_gcc_compilation
= 2;
1993 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
1996 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
1997 type_code
= MIPS_UNMARK_STAB(sh
->index
);
1998 if (!MIPS_IS_STAB(sh
)) {
1999 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
) {
2000 long procaddr
= sh
->value
;
2001 sh
= AUX_GET_ISYM (fh
->fBigendian
,
2002 sh
->index
+ (union aux_ext
*)(fh
->iauxBase
))
2003 + (SYMR
*) fh
->isymBase
- 1;
2004 if (sh
->st
== stEnd
) {
2005 long high
= procaddr
+ sh
->value
;
2006 if (high
> pst
->texthigh
)
2007 pst
->texthigh
= high
;
2012 #define SET_NAMESTRING() namestring = (char*)sh->iss
2013 #define CUR_SYMBOL_TYPE type_code
2014 #define CUR_SYMBOL_VALUE sh->value
2015 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2017 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2018 #define HANDLE_RBRAC(val) \
2019 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2020 #include "partial-stab.h"
2024 processing_gcc_compilation
= 0;
2025 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2027 enum address_class
class;
2028 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2030 if (MIPS_IS_STAB(sh
)) {
2035 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
2036 sh
->index
== 0xfffff) {
2037 /* FIXME, premature? */
2042 name
= (char *)(sh
->iss
);
2049 case stProc
: /* Asm labels apparently */
2050 case stStaticProc
: /* Function */
2051 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2052 VAR_NAMESPACE
, LOC_BLOCK
,
2053 objfile
->static_psymbols
, sh
->value
,
2054 psymtab_language
, objfile
);
2055 /* Skip over procedure to next one. */
2056 if (sh
->index
>= hdr
->iauxMax
)
2058 /* Should not happen, but does when cross-compiling
2059 with the MIPS compiler. FIXME -- pull later. */
2060 complain (&index_complaint
, name
);
2061 new_sdx
= cur_sdx
+1; /* Don't skip at all */
2064 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2065 sh
->index
+ (union aux_ext
*)fh
->iauxBase
);
2066 procaddr
= sh
->value
;
2068 if (new_sdx
<= cur_sdx
)
2070 /* This should not happen either... FIXME. */
2071 complain (&aux_index_complaint
, name
);
2072 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2076 sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
- 1;
2077 if (sh
->st
!= stEnd
)
2079 high
= procaddr
+ sh
->value
;
2080 if (high
> pst
->texthigh
)
2081 pst
->texthigh
= high
;
2084 case stStatic
: /* Variable */
2088 case stTypedef
: /* Typedef */
2089 class = LOC_TYPEDEF
;
2092 case stConstant
: /* Constant decl */
2099 case stBlock
: /* { }, str, un, enum*/
2100 if (sh
->sc
== scInfo
) {
2101 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2102 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2103 objfile
->static_psymbols
,
2105 psymtab_language
, objfile
);
2107 /* Skip over the block */
2108 cur_sdx
= sh
->index
;
2111 case stFile
: /* File headers */
2112 case stLabel
: /* Labels */
2113 case stEnd
: /* Ends of files */
2116 case stLocal
: /* Local variables */
2117 /* Normally these are skipped because we skip over
2118 all blocks we see. However, these can occur
2119 as visible symbols in a .h file that contains code. */
2123 /* Both complaints are valid: one gives symbol name,
2124 the other the offending symbol type. */
2125 complain (&unknown_sym_complaint
, sh
->iss
);
2126 complain (&unknown_st_complaint
, sh
->st
);
2130 /* Use this gdb symbol */
2131 ADD_PSYMBOL_TO_LIST(name
, strlen(name
),
2132 VAR_NAMESPACE
, class,
2133 objfile
->static_psymbols
, sh
->value
,
2134 psymtab_language
, objfile
);
2136 cur_sdx
++; /* Go to next file symbol */
2139 /* Now do enter the external symbols. */
2140 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2141 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2142 PST_PRIVATE(save_pst
)->extern_count
= cur_sdx
;
2143 PST_PRIVATE(save_pst
)->extern_tab
= ext_ptr
;
2144 for (; --cur_sdx
>= 0; ext_ptr
++) {
2145 register struct partial_symbol
*psym
;
2146 enum address_class
class;
2148 if ((*ext_ptr
)->ifd
!= f_idx
)
2150 sh
= &(*ext_ptr
)->asym
;
2159 complain (&unknown_ext_complaint
, sh
->iss
);
2160 /* Fall through, pretend it's global. */
2165 if (objfile
->global_psymbols
.next
>=
2166 objfile
->global_psymbols
.list
+ objfile
->global_psymbols
.size
)
2167 extend_psymbol_list (&objfile
->global_psymbols
, objfile
);
2168 psym
= objfile
->global_psymbols
.next
++;
2169 SYMBOL_NAME (psym
) = (char*)sh
->iss
;
2170 SYMBOL_NAMESPACE (psym
) = VAR_NAMESPACE
;
2171 SYMBOL_CLASS (psym
) = class;
2172 SYMBOL_VALUE_ADDRESS (psym
) = (CORE_ADDR
)sh
->value
;
2176 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2177 -1, save_pst
->texthigh
,
2178 dependency_list
, dependencies_used
);
2179 if (objfile
-> ei
.entry_point
>= save_pst
->textlow
&&
2180 objfile
-> ei
.entry_point
< save_pst
->texthigh
)
2182 objfile
-> ei
.entry_file_lowpc
= save_pst
->textlow
;
2183 objfile
-> ei
.entry_file_highpc
= save_pst
->texthigh
;
2187 /* Mark the last code address, and remember it for later */
2188 hdr
->cbDnOffset
= end_of_text_seg
;
2190 /* Now scan the FDRs for dependencies */
2191 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
2193 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
2194 pst
= fdr_to_pst
[f_idx
].pst
;
2196 /* This should catch stabs-in-ecoff. */
2200 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2201 /* ...then presumably a .h file: drop reverse depends .h->.c */
2202 for (; s_id0
< fh
->crfd
; s_id0
++) {
2203 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2205 s_id0
++; /* Skip self-dependency */
2210 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2211 pst
->dependencies
= (struct partial_symtab
**)
2212 obstack_alloc (&objfile
->psymbol_obstack
,
2213 pst
->number_of_dependencies
*
2214 sizeof (struct partial_symtab
*));
2215 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2216 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2217 if (*rh
< 0 || *rh
>= hdr
->ifdMax
)
2218 complain(&bad_file_number_complaint
, *rh
);
2220 pst
->dependencies
[s_idx
-s_id0
] = fdr_to_pst
[*rh
].pst
;
2223 do_cleanups (old_chain
);
2228 /* Do the initial analisys of the F_IDX-th file descriptor.
2229 Allocates a partial symtab for it, and builds the list
2230 of dependent files by recursion. LEV says at which level
2231 of recursion we are called (to pretty up debug traces) */
2233 static struct partial_symtab
*
2234 parse_fdr(f_idx
, lev
, objfile
)
2237 struct objfile
*objfile
;
2240 register struct partial_symtab
*pst
;
2243 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
2245 /* Use this to indicate into which symtab this file was parsed */
2247 return (struct partial_symtab
*) fh
->ioptBase
;
2249 /* Debuggability level */
2250 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
2251 max_glevel
= fh
->glevel
;
2253 /* Make a new partial_symtab */
2254 pst
= new_psymtab(fh
->rss
, objfile
);
2259 pst
->textlow
= fh
->adr
;
2260 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2263 /* Make everything point to everything. */
2264 FDR_IDX(pst
) = f_idx
;
2265 fdr_to_pst
[f_idx
].pst
= pst
;
2266 fh
->ioptBase
= (int)pst
;
2268 /* Analyze its dependencies */
2273 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
2274 /* ...then presumably a .h file: drop reverse depends .h->.c */
2275 for (; s_id0
< fh
->crfd
; s_id0
++) {
2276 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
2278 s_id0
++; /* Skip self-dependency */
2283 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2284 pst
->dependencies
= (struct partial_symtab
**)
2285 obstack_alloc (&objfile
->psymbol_obstack
,
2286 pst
->number_of_dependencies
*
2287 sizeof (struct partial_symtab
*));
2288 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
2289 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
2291 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1, objfile
);
2299 mips_next_symbol_text ()
2302 return (char*)((SYMR
*)cur_fdr
->isymBase
)[cur_sdx
].iss
;
2305 /* Ancillary function to psymtab_to_symtab(). Does all the work
2306 for turning the partial symtab PST into a symtab, recurring
2307 first on all dependent psymtabs. The argument FILENAME is
2308 only passed so we can see in debug stack traces what file
2311 This function has a split personality, based on whether the
2312 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2313 The flow of control and even the memory allocation differs. FIXME. */
2316 psymtab_to_symtab_1(pst
, filename
)
2317 struct partial_symtab
*pst
;
2323 struct linetable
*lines
;
2330 /* Read in all partial symbtabs on which this one is dependent.
2331 NOTE that we do have circular dependencies, sigh. We solved
2332 that by setting pst->readin before this point. */
2334 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2335 if (!pst
->dependencies
[i
]->readin
) {
2336 /* Inform about additional files to be read in. */
2339 fputs_filtered (" ", stdout
);
2341 fputs_filtered ("and ", stdout
);
2343 printf_filtered ("%s...",
2344 pst
->dependencies
[i
]->filename
);
2345 wrap_here (""); /* Flush output */
2348 /* We only pass the filename for debug purposes */
2349 psymtab_to_symtab_1(pst
->dependencies
[i
],
2350 pst
->dependencies
[i
]->filename
);
2353 /* Now read the symbols for this symtab */
2355 current_objfile
= pst
->objfile
;
2356 cur_fd
= FDR_IDX(pst
);
2357 fh
= (cur_fd
== -1) ? 0 : (FDR
*) (cur_hdr
->cbFdOffset
) + FDR_IDX(pst
);
2360 /* BOUND is the highest core address of this file's procedures */
2361 bound
= (cur_fd
== cur_hdr
->ifdMax
- 1) ?
2362 cur_hdr
->cbDnOffset
:
2365 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2366 if (fh
&& fh
->csym
>= 2
2367 && STREQ((char *)(((SYMR
*)fh
->isymBase
)[1].iss
), stabs_symbol
)) {
2370 * This symbol table contains stabs-in-ecoff entries.
2375 /* We indicate that this is a GCC compilation so that certain features
2376 will be enabled in stabsread/dbxread. */
2377 processing_gcc_compilation
= 2;
2378 /* Parse local symbols first */
2380 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2382 current_objfile
= NULL
;
2385 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++) {
2386 register SYMR
*sh
= cur_sdx
+ (SYMR
*) fh
->isymBase
;
2387 char *name
= (char*)sh
->iss
;
2388 CORE_ADDR valu
= sh
->value
;
2389 if (MIPS_IS_STAB(sh
)) {
2390 int type_code
= MIPS_UNMARK_STAB(sh
->index
);
2391 process_one_symbol (type_code
, 0, valu
, name
,
2392 pst
->section_offsets
, pst
->objfile
);
2393 if (type_code
== N_FUN
) {
2394 /* Make up special symbol to contain
2395 procedure specific info */
2396 struct mips_extra_func_info
*e
=
2397 (struct mips_extra_func_info
*)
2398 obstack_alloc(¤t_objfile
->symbol_obstack
,
2399 sizeof(struct mips_extra_func_info
));
2400 struct symbol
*s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
2401 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2402 SYMBOL_CLASS(s
) = LOC_CONST
;
2403 SYMBOL_TYPE(s
) = builtin_type_void
;
2404 SYMBOL_VALUE(s
) = (int)e
;
2405 add_symbol_to_list (s
, &local_symbols
);
2408 else if (sh
->st
== stLabel
&& sh
->index
!= indexNil
) {
2409 /* Handle encoded stab line number. */
2410 record_line (current_subfile
, sh
->index
, valu
);
2412 else complain (&stab_unknown_complaint
, sh
->iss
);
2414 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
);
2417 /* Sort the symbol table now, we are done adding symbols to it.
2418 We must do this before parse_procedure calls lookup_symbol. */
2419 sort_symtab_syms(st
);
2421 /* This may not be necessary for stabs symtabs. FIXME. */
2424 /* Fill in procedure info next. We need to look-ahead to
2425 find out where each procedure's code ends. */
2427 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2428 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2429 parse_procedure (pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 1);
2434 * This symbol table contains ordinary ecoff entries.
2437 /* FIXME: doesn't use pst->section_offsets. */
2443 processing_gcc_compilation
= 0;
2445 /* How many symbols will we need */
2446 /* FIXME, this does not count enum values. */
2447 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2450 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2452 f_max
+= fh
->csym
+ fh
->cpd
;
2453 maxlines
= 2 * fh
->cline
;
2454 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2457 lines
= LINETABLE(st
);
2458 pending_list
= (struct mips_pending
**) cur_hdr
->cbOptOffset
;
2459 if (pending_list
== 0) {
2460 pending_list
= (struct mips_pending
**)
2461 xzalloc(cur_hdr
->ifdMax
* sizeof(struct mips_pending
*));
2462 cur_hdr
->cbOptOffset
= (int)pending_list
;
2465 /* Get a new lexical context */
2468 top_stack
->cur_st
= st
;
2469 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(st
),
2471 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2472 BLOCK_END(top_stack
->cur_block
) = 0;
2473 top_stack
->blocktype
= stFile
;
2474 top_stack
->maxsyms
= 2*f_max
;
2475 top_stack
->cur_type
= 0;
2476 top_stack
->procadr
= 0;
2477 top_stack
->numargs
= 0;
2483 /* Parse local symbols first */
2485 for (cur_sdx
= 0; cur_sdx
< fh
->csym
; ) {
2486 sh
= (SYMR
*) (fh
->isymBase
) + cur_sdx
;
2487 cur_sdx
+= parse_symbol(sh
, (union aux_ext
*)fh
->iauxBase
,
2491 /* Linenumbers. At the end, check if we can save memory */
2493 parse_lines(fh
, lines
);
2494 if (lines
->nitems
< fh
->cline
)
2495 lines
= shrink_linetable(lines
);
2497 /* Fill in procedure info next. We need to look-ahead to
2498 find out where each procedure's code ends. */
2500 for (i
= 0; i
<= fh
->cpd
-1; i
++) {
2501 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + i
;
2502 parse_procedure(pr
, i
< fh
->cpd
-1 ? pr
[1].adr
: bound
, 0);
2506 LINETABLE(st
) = lines
;
2508 /* .. and our share of externals.
2509 XXX use the global list to speed up things here. how?
2510 FIXME, Maybe quit once we have found the right number of ext's? */
2511 top_stack
->cur_st
= st
;
2512 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
2514 top_stack
->blocktype
= stFile
;
2515 top_stack
->maxsyms
=
2516 cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
2518 ext_ptr
= PST_PRIVATE(pst
)->extern_tab
;
2519 for (i
= PST_PRIVATE(pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2520 parse_external(*ext_ptr
, 1, fh
->fBigendian
);
2522 /* If there are undefined, tell the user */
2523 if (n_undef_symbols
) {
2524 printf_filtered("File %s contains %d unresolved references:",
2525 st
->filename
, n_undef_symbols
);
2526 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2527 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2528 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2533 /* Sort the symbol table now, we are done adding symbols to it.*/
2534 sort_symtab_syms(st
);
2539 /* Now link the psymtab and the symtab. */
2542 current_objfile
= NULL
;
2545 /* Ancillary parsing procedures. */
2547 /* Lookup the type at relative index RN. Return it in TPP
2548 if found and in any event come up with its name PNAME.
2549 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2550 Return value says how many aux symbols we ate. */
2553 cross_ref(ax
, tpp
, type_code
, pname
, bigend
)
2556 enum type_code type_code
; /* Use to alloc new type if none is found. */
2564 ecoff_swap_rndx_in (bigend
, ax
, rn
);
2566 /* Escape index means 'the next one' */
2567 if (rn
->rfd
== 0xfff) {
2569 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2576 *pname
= "<undefined>";
2579 * Find the relative file descriptor and the symbol in it
2581 FDR
*fh
= get_rfd(cur_fd
, rf
);
2586 * If we have processed this symbol then we left a forwarding
2587 * pointer to the corresponding GDB symbol. If not, we`ll put
2588 * it in a list of pending symbols, to be processed later when
2589 * the file f will be. In any event, we collect the name for
2590 * the type here. Which is why we made a first pass at
2593 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2595 /* Careful, we might be looking at .o files */
2596 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2599 /* Have we parsed it ? */
2600 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2601 t
= (struct type
*) sh
->value
;
2604 /* Avoid duplicates */
2605 struct mips_pending
*p
= is_pending_symbol(fh
, sh
);
2609 *tpp
= init_type(type_code
, 0, 0, (char *) NULL
,
2610 (struct objfile
*) NULL
);
2611 add_pending(fh
, sh
, *tpp
);
2616 /* We used one auxent normally, two if we got a "next one" rf. */
2621 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2622 keeping the symtab sorted */
2624 static struct symbol
*
2625 mylookup_symbol (name
, block
, namespace, class)
2627 register struct block
*block
;
2628 enum namespace namespace;
2629 enum address_class
class;
2631 register int bot
, top
, inc
;
2632 register struct symbol
*sym
;
2635 top
= BLOCK_NSYMS(block
);
2638 sym
= BLOCK_SYM(block
, bot
);
2639 if (SYMBOL_NAME(sym
)[0] == inc
2640 && SYMBOL_NAMESPACE(sym
) == namespace
2641 && SYMBOL_CLASS(sym
) == class
2642 && STREQ(SYMBOL_NAME(sym
), name
))
2646 block
= BLOCK_SUPERBLOCK (block
);
2648 return mylookup_symbol (name
, block
, namespace, class);
2653 /* Add a new symbol S to a block B.
2654 Infrequently, we will need to reallocate the block to make it bigger.
2655 We only detect this case when adding to top_stack->cur_block, since
2656 that's the only time we know how big the block is. FIXME. */
2663 int nsyms
= BLOCK_NSYMS(b
)++;
2664 struct block
*origb
;
2665 struct parse_stack
*stackp
;
2667 if (b
== top_stack
->cur_block
&&
2668 nsyms
>= top_stack
->maxsyms
) {
2669 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
2670 /* In this case shrink_block is actually grow_block, since
2671 BLOCK_NSYMS(b) is larger than its current size. */
2673 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2675 /* Now run through the stack replacing pointers to the
2676 original block. shrink_block has already done this
2677 for the blockvector and BLOCK_FUNCTION. */
2678 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2679 if (stackp
->cur_block
== origb
) {
2680 stackp
->cur_block
= b
;
2681 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2685 BLOCK_SYM(b
,nsyms
) = s
;
2688 /* Add a new block B to a symtab S */
2695 struct blockvector
*bv
= BLOCKVECTOR(s
);
2697 bv
= (struct blockvector
*)xrealloc((PTR
) bv
,
2698 sizeof(struct blockvector
) +
2699 BLOCKVECTOR_NBLOCKS(bv
)
2700 * sizeof(bv
->block
));
2701 if (bv
!= BLOCKVECTOR(s
))
2702 BLOCKVECTOR(s
) = bv
;
2704 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2707 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2708 MIPS' linenumber encoding might need more than one byte
2709 to describe it, LAST is used to detect these continuation lines */
2712 add_line(lt
, lineno
, adr
, last
)
2713 struct linetable
*lt
;
2719 last
= -2; /* make sure we record first line */
2721 if (last
== lineno
) /* skip continuation lines */
2724 lt
->item
[lt
->nitems
].line
= lineno
;
2725 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2729 /* Sorting and reordering procedures */
2731 /* Blocks with a smaller low bound should come first */
2734 compare_blocks(arg1
, arg2
)
2735 const void *arg1
, *arg2
;
2737 register int addr_diff
;
2738 struct block
**b1
= (struct block
**) arg1
;
2739 struct block
**b2
= (struct block
**) arg2
;
2741 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2743 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2747 /* Sort the blocks of a symtab S.
2748 Reorder the blocks in the blockvector by code-address,
2749 as required by some MI search routines */
2755 struct blockvector
*bv
= BLOCKVECTOR(s
);
2757 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2759 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2760 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2761 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2762 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2766 * This is very unfortunate: normally all functions are compiled in
2767 * the order they are found, but if the file is compiled -O3 things
2768 * are very different. It would be nice to find a reliable test
2769 * to detect -O3 images in advance.
2771 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2772 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2773 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2774 sizeof(struct block
*),
2778 register CORE_ADDR high
= 0;
2779 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2781 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2782 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2783 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2784 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2787 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2788 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2790 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2791 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2792 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2793 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2797 /* Constructor/restructor/destructor procedures */
2799 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2800 MAXSYMS and linenumbers MAXLINES we'll put in it */
2802 static struct symtab
*
2803 new_symtab(name
, maxsyms
, maxlines
, objfile
)
2807 struct objfile
*objfile
;
2809 struct symtab
*s
= allocate_symtab (name
, objfile
);
2811 LINETABLE(s
) = new_linetable(maxlines
);
2813 /* All symtabs must have at least two blocks */
2814 BLOCKVECTOR(s
) = new_bvect(2);
2815 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2816 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2817 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2818 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2820 s
->free_code
= free_linetable
;
2825 /* Allocate a new partial_symtab NAME */
2827 static struct partial_symtab
*
2828 new_psymtab(name
, objfile
)
2830 struct objfile
*objfile
;
2832 struct partial_symtab
*psymtab
;
2834 /* FIXME -- why (char *) -1 rather than NULL? */
2835 psymtab
= allocate_psymtab (name
== (char *) -1 ? "<no name>" : name
,
2838 /* Keep a backpointer to the file's symbols */
2840 psymtab
-> read_symtab_private
= (char *)
2841 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2842 CUR_HDR(psymtab
) = cur_hdr
;
2844 /* The way to turn this into a symtab is to call... */
2845 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
2850 /* Allocate a linetable array of the given SIZE. Since the struct
2851 already includes one item, we subtract one when calculating the
2852 proper size to allocate. */
2854 static struct linetable
*
2858 struct linetable
*l
;
2860 size
= (size
-1) * sizeof(l
->item
) + sizeof(struct linetable
);
2861 l
= (struct linetable
*)xmalloc(size
);
2866 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2867 I am not so sure about the 3.4 ones.
2869 Since the struct linetable already includes one item, we subtract one when
2870 calculating the proper size to allocate. */
2872 static struct linetable
*
2873 shrink_linetable(lt
)
2874 struct linetable
* lt
;
2877 return (struct linetable
*) xrealloc ((PTR
)lt
,
2878 sizeof(struct linetable
)
2879 + (lt
->nitems
- 1) * sizeof(lt
->item
));
2882 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2884 static struct blockvector
*
2888 struct blockvector
*bv
;
2891 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2892 bv
= (struct blockvector
*) xzalloc(size
);
2894 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2899 /* Allocate and zero a new block of MAXSYMS symbols */
2901 static struct block
*
2905 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2907 return (struct block
*)xzalloc (size
);
2910 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2911 Shrink_block can also be used by add_symbol to grow a block. */
2913 static struct block
*
2919 struct blockvector
*bv
= BLOCKVECTOR(s
);
2922 /* Just reallocate it and fix references to the old one */
2924 new = (struct block
*) xrealloc ((PTR
)b
, sizeof(struct block
) +
2925 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2927 /* Should chase pointers to old one. Fortunately, that`s just
2928 the block`s function and inferior blocks */
2929 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2930 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2931 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2932 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2933 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2934 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2935 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2939 /* Create a new symbol with printname NAME */
2941 static struct symbol
*
2945 struct symbol
*s
= (struct symbol
*)
2946 obstack_alloc (¤t_objfile
->symbol_obstack
, sizeof (struct symbol
));
2948 memset ((PTR
)s
, 0, sizeof (*s
));
2949 SYMBOL_NAME(s
) = name
;
2953 /* Create a new type with printname NAME */
2955 static struct type
*
2961 t
= alloc_type (current_objfile
);
2962 TYPE_NAME(t
) = name
;
2963 TYPE_CPLUS_SPECIFIC(t
) = (struct cplus_struct_type
*)
2964 &cplus_struct_default
;
2969 /* Things used for calling functions in the inferior.
2970 These functions are exported to our companion
2971 mips-tdep.c file and are here because they play
2972 with the symbol-table explicitly. */
2974 /* Sigtramp: make sure we have all the necessary information
2975 about the signal trampoline code. Since the official code
2976 from MIPS does not do so, we make up that information ourselves.
2977 If they fix the library (unlikely) this code will neutralize itself. */
2984 struct block
*b
, *b0
;
2986 sigtramp_address
= -1;
2988 /* We know it is sold as sigvec */
2989 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2991 /* Most programs do not play with signals */
2993 s
= lookup_symbol("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
2996 b0
= SYMBOL_BLOCK_VALUE(s
);
2998 /* A label of sigvec, to be more precise */
2999 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3002 /* But maybe this program uses its own version of sigvec */
3006 /* Did we or MIPSco fix the library ? */
3007 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
3009 sigtramp_address
= BLOCK_START(SYMBOL_BLOCK_VALUE(s
));
3010 sigtramp_end
= BLOCK_END(SYMBOL_BLOCK_VALUE(s
));
3014 sigtramp_address
= SYMBOL_VALUE(s
);
3015 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3017 /* But what symtab does it live in ? */
3018 st
= find_pc_symtab(SYMBOL_VALUE(s
));
3021 * Ok, there goes the fix: turn it into a procedure, with all the
3022 * needed info. Note we make it a nested procedure of sigvec,
3023 * which is the way the (assembly) code is actually written.
3025 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
3026 SYMBOL_CLASS(s
) = LOC_BLOCK
;
3027 SYMBOL_TYPE(s
) = init_type(TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3028 (struct objfile
*) NULL
);
3029 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
3031 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3033 SYMBOL_BLOCK_VALUE(s
) = b
;
3034 BLOCK_START(b
) = sigtramp_address
;
3035 BLOCK_END(b
) = sigtramp_end
;
3036 BLOCK_FUNCTION(b
) = s
;
3037 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
3041 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3043 struct mips_extra_func_info
*e
=
3044 (struct mips_extra_func_info
*)
3045 xzalloc(sizeof(struct mips_extra_func_info
));
3047 e
->numargs
= 0; /* the kernel thinks otherwise */
3048 /* align_longword(sigcontext + SIGFRAME) */
3049 e
->pdr
.frameoffset
= 0x150;
3050 e
->pdr
.framereg
= SP_REGNUM
;
3052 e
->pdr
.regmask
= -2;
3053 e
->pdr
.regoffset
= -(41 * sizeof(int));
3054 e
->pdr
.fregmask
= -1;
3055 e
->pdr
.fregoffset
= -(37 * sizeof(int));
3056 e
->pdr
.isym
= (long)s
;
3058 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3059 s
= new_symbol(MIPS_EFI_SYMBOL_NAME
);
3060 SYMBOL_VALUE(s
) = (int) e
;
3061 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
3062 SYMBOL_CLASS(s
) = LOC_CONST
;
3063 SYMBOL_TYPE(s
) = builtin_type_void
;
3064 current_objfile
= NULL
;
3067 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
3071 /* Fake up identical offsets for all sections. */
3073 struct section_offsets
*
3074 mipscoff_symfile_offsets (objfile
, addr
)
3075 struct objfile
*objfile
;
3078 struct section_offsets
*section_offsets
;
3081 section_offsets
= (struct section_offsets
*)
3082 obstack_alloc (&objfile
-> psymbol_obstack
,
3083 sizeof (struct section_offsets
) +
3084 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
3086 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3087 ANOFFSET (section_offsets
, i
) = addr
;
3089 return section_offsets
;
3092 /* Initialization */
3094 static struct sym_fns ecoff_sym_fns
=
3096 "ecoff", /* sym_name: name or name prefix of BFD target type */
3097 5, /* sym_namelen: number of significant sym_name chars */
3098 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3099 mipscoff_symfile_init
,/* sym_init: read initial info, setup for sym_read() */
3100 mipscoff_symfile_read
,/* sym_read: read a symbol file into symtab */
3101 mipscoff_symfile_finish
,/* sym_finish: finished with file, cleanup */
3102 mipscoff_symfile_offsets
,/* sym_offsets: dummy FIXME til implem sym reloc */
3103 NULL
/* next: pointer to next struct sym_fns */
3108 _initialize_mipsread ()
3110 add_symtab_fns (&ecoff_sym_fns
);
3112 /* Missing basic types */
3114 builtin_type_string
=
3115 init_type(TYPE_CODE_STRING
,
3116 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3118 (struct objfile
*) NULL
);
3119 builtin_type_complex
=
3120 init_type(TYPE_CODE_FLT
,
3121 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3123 (struct objfile
*) NULL
);
3124 builtin_type_double_complex
=
3125 init_type(TYPE_CODE_FLT
,
3126 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3127 0, "double complex",
3128 (struct objfile
*) NULL
);
3129 builtin_type_fixed_dec
=
3130 init_type(TYPE_CODE_INT
,
3131 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3133 (struct objfile
*) NULL
);
3134 builtin_type_float_dec
=
3135 init_type(TYPE_CODE_FLT
,
3136 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3137 0, "floating decimal",
3138 (struct objfile
*) NULL
);