1 /* Read a symbol table in MIPS' format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software
4 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work
5 by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* This module provides three functions: mipscoff_symfile_init,
24 which initializes to read a symbol file; mipscoff_new_init, which
25 discards existing cached information when all symbols are being
26 discarded; and mipscoff_symfile_read, which reads a symbol table
29 mipscoff_symfile_read only does the minimum work necessary for letting the
30 user "name" things symbolically; it does not read the entire symtab.
31 Instead, it reads the external and static symbols and puts them in partial
32 symbol tables. When more extensive information is requested of a
33 file, the corresponding partial symbol table is mutated into a full
34 fledged symbol table by going back and reading the symbols
35 for real. mipscoff_psymtab_to_symtab() is called indirectly through
36 a pointer in the psymtab to do this.
38 ECOFF symbol tables are mostly written in the byte order of the
39 target machine. However, one section of the table (the auxiliary
40 symbol information) is written in the host byte order. There is a
41 bit in the other symbol info which describes which host byte order
42 was used. ECOFF thereby takes the trophy from Intel `b.out' for
43 the most brain-dead adaptation of a file format to byte order.
45 This module can read all four of the known byte-order combinations,
46 on any type of host. */
56 #include "stabsread.h"
57 #include "complaints.h"
59 /* These are needed if the tm.h file does not contain the necessary
60 mips specific definitions. */
62 #ifndef MIPS_EFI_SYMBOL_NAME
63 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
65 #include "coff/symconst.h"
66 typedef struct mips_extra_func_info
{
69 } *mips_extra_func_info_t
;
79 #include <sys/types.h>
82 #include <sys/param.h>
87 #include "gdb-stabs.h"
91 #include "coff/internal.h"
92 #include "coff/mips.h" /* COFF-like aspects of ecoff files */
93 #include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
95 /* FIXME: coff/internal.h and aout/aout64.h both define N_ABS. We
96 want the definition from aout/aout64.h. */
99 #include "libaout.h" /* Private BFD a.out information. */
100 #include "aout/aout64.h"
101 #include "aout/stab_gnu.h" /* STABS information */
103 /* FIXME: libcoff.h and libaout.h both define a couple of macros. We
106 #undef obj_sym_filepos
108 #include "libcoff.h" /* Private BFD COFF information. */
109 #include "libecoff.h" /* Private BFD ECOFF information. */
111 #include "expression.h"
112 #include "language.h" /* Needed inside partial-stab.h */
114 /* Each partial symbol table entry contains a pointer to private data
115 for the read_symtab() function to use when expanding a partial
116 symbol table entry to a full symbol table entry.
118 For mipsread this structure contains the index of the FDR that this
119 psymtab represents and a pointer to the BFD that the psymtab was
122 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
123 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
124 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
130 EXTR
*extern_tab
; /* Pointer to external symbols for this file. */
131 int extern_count
; /* Size of extern_tab. */
132 struct mips_pending
**pending_list
;
135 /* Things we import explicitly from other modules */
137 extern int info_verbose
;
139 /* Various complaints about symbol reading that don't abort the process */
141 struct complaint bad_file_number_complaint
=
142 {"bad file number %d", 0, 0};
144 struct complaint index_complaint
=
145 {"bad aux index at symbol %s", 0, 0};
147 struct complaint aux_index_complaint
=
148 {"bad proc end in aux found from symbol %s", 0, 0};
150 struct complaint block_index_complaint
=
151 {"bad aux index at block symbol %s", 0, 0};
153 struct complaint unknown_ext_complaint
=
154 {"unknown external symbol %s", 0, 0};
156 struct complaint unknown_sym_complaint
=
157 {"unknown local symbol %s", 0, 0};
159 struct complaint unknown_st_complaint
=
160 {"with type %d", 0, 0};
162 struct complaint block_overflow_complaint
=
163 {"block containing %s overfilled", 0, 0};
165 struct complaint basic_type_complaint
=
166 {"cannot map MIPS basic type 0x%x", 0, 0};
168 struct complaint unknown_type_qual_complaint
=
169 {"unknown type qualifier 0x%x", 0, 0};
171 struct complaint array_bitsize_complaint
=
172 {"size of array target type not known, assuming %d bits", 0, 0};
174 struct complaint bad_tag_guess_complaint
=
175 {"guessed tag type of %s incorrectly", 0, 0};
177 struct complaint block_member_complaint
=
178 {"declaration block contains unhandled symbol type %d", 0, 0};
180 struct complaint stEnd_complaint
=
181 {"stEnd with storage class %d not handled", 0, 0};
183 struct complaint unknown_mips_symtype_complaint
=
184 {"unknown symbol type 0x%x", 0, 0};
186 struct complaint stab_unknown_complaint
=
187 {"unknown stabs symbol %s", 0, 0};
189 struct complaint pdr_for_nonsymbol_complaint
=
190 {"PDR for %s, but no symbol", 0, 0};
192 struct complaint pdr_static_symbol_complaint
=
193 {"can't handle PDR for static proc at 0x%x", 0, 0};
195 struct complaint bad_setjmp_pdr_complaint
=
196 {"fixing bad setjmp PDR from libc", 0, 0};
198 /* Macros and extra defs */
200 /* Already-parsed symbols are marked specially */
202 #define stParsed stType
204 /* Puns: hard to find whether -g was used and how */
206 #define MIN_GLEVEL GLEVEL_0
207 #define compare_glevel(a,b) \
208 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
209 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
211 /* Things that really are local to this module */
213 /* Remember what we deduced to be the source language of this psymtab. */
215 static enum language psymtab_language
= language_unknown
;
221 /* Pointer to current file decriptor record, and its index */
226 /* Index of current symbol */
230 /* Note how much "debuggable" this image is. We would like
231 to see at least one FDR with full symbols */
236 /* When examining .o files, report on undefined symbols */
238 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
240 /* Pseudo symbol to use when putting stabs into the symbol table. */
242 static char stabs_symbol
[] = STABS_SYMBOL
;
244 /* Extra builtin types */
246 struct type
*builtin_type_complex
;
247 struct type
*builtin_type_double_complex
;
248 struct type
*builtin_type_fixed_dec
;
249 struct type
*builtin_type_float_dec
;
250 struct type
*builtin_type_string
;
252 /* Forward declarations */
255 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
258 read_the_mips_symtab
PARAMS ((bfd
*));
261 upgrade_type
PARAMS ((struct type
**, int, union aux_ext
*, int));
264 parse_partial_symbols
PARAMS ((struct objfile
*,
265 struct section_offsets
*));
268 cross_ref
PARAMS ((union aux_ext
*, struct type
**, enum type_code
, char **,
272 fixup_sigtramp
PARAMS ((void));
274 static struct symbol
*
275 new_symbol
PARAMS ((char *));
278 new_type
PARAMS ((char *));
280 static struct block
*
281 new_block
PARAMS ((int));
283 static struct symtab
*
284 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
286 static struct linetable
*
287 new_linetable
PARAMS ((int));
289 static struct blockvector
*
290 new_bvect
PARAMS ((int));
293 parse_type
PARAMS ((union aux_ext
*, int *, int));
295 static struct symbol
*
296 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
297 enum address_class
));
299 static struct block
*
300 shrink_block
PARAMS ((struct block
*, struct symtab
*));
303 xzalloc
PARAMS ((unsigned int));
306 sort_blocks
PARAMS ((struct symtab
*));
309 compare_blocks
PARAMS ((const void *, const void *));
311 static struct partial_symtab
*
312 new_psymtab
PARAMS ((char *, struct objfile
*));
315 static struct partial_symtab
*
316 parse_fdr
PARAMS ((int, int, struct objfile
*));
320 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
323 add_block
PARAMS ((struct block
*, struct symtab
*));
326 add_symbol
PARAMS ((struct symbol
*, struct block
*));
329 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
331 static struct linetable
*
332 shrink_linetable
PARAMS ((struct linetable
*));
335 mips_next_symbol_text
PARAMS ((void));
337 /* Things we export to other modules */
339 /* Address bounds for the signal trampoline in inferior, if any */
340 /* FIXME: Nothing really seems to use this. Why is it here? */
342 CORE_ADDR sigtramp_address
, sigtramp_end
;
345 mipscoff_new_init (ignore
)
346 struct objfile
*ignore
;
348 sigtramp_address
= 0;
349 stabsread_new_init ();
350 buildsym_new_init ();
354 mipscoff_symfile_init (objfile
)
355 struct objfile
*objfile
;
357 if (objfile
->sym_private
!= NULL
)
359 mfree (objfile
->md
, objfile
->sym_private
);
361 objfile
->sym_private
= NULL
;
365 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
366 struct objfile
*objfile
;
367 struct section_offsets
*section_offsets
;
370 init_minimal_symbol_collection ();
371 make_cleanup (discard_minimal_symbols
, 0);
373 /* Now that the executable file is positioned at symbol table,
374 process it and define symbols accordingly. */
376 read_mips_symtab (objfile
, section_offsets
);
378 /* Install any minimal symbols that have been collected as the current
379 minimal symbols for this objfile. */
381 install_minimal_symbols (objfile
);
384 /* Perform any local cleanups required when we are done with a particular
385 objfile. I.E, we are in the process of discarding all symbol information
386 for an objfile, freeing up all memory held for it, and unlinking the
387 objfile struct from the global list of known objfiles. */
390 mipscoff_symfile_finish (objfile
)
391 struct objfile
*objfile
;
393 if (objfile
->sym_private
!= NULL
)
395 mfree (objfile
->md
, objfile
->sym_private
);
401 /* Allocate zeroed memory */
407 PTR p
= xmalloc (size
);
413 /* Exported procedure: Builds a symtab from the PST partial one.
414 Restores the environment in effect when PST was created, delegates
415 most of the work to an ancillary procedure, and sorts
416 and reorders the symtab list at the end */
419 mipscoff_psymtab_to_symtab (pst
)
420 struct partial_symtab
*pst
;
428 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
432 next_symbol_text_func
= mips_next_symbol_text
;
434 psymtab_to_symtab_1 (pst
, pst
->filename
);
436 /* Match with global symbols. This only needs to be done once,
437 after all of the symtabs and dependencies have been read in. */
438 scan_file_globals (pst
->objfile
);
441 printf_filtered ("done.\n");
444 /* Exported procedure: Is PC in the signal trampoline code */
447 in_sigtramp (pc
, ignore
)
449 char *ignore
; /* function name */
451 if (sigtramp_address
== 0)
453 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
456 /* File-level interface functions */
458 /* Read the symtab information from file ABFD into memory. */
461 read_the_mips_symtab (abfd
)
464 if (ecoff_slurp_symbolic_info (abfd
) == false)
465 error ("Error reading symbol table: %s", bfd_errmsg (bfd_error
));
468 /* Find a file descriptor given its index RF relative to a file CF */
478 fdrs
= ecoff_data (cur_bfd
)->fdr
;
480 /* Object files do not have the RFD table, all refs are absolute */
483 ecoff_swap_rfd_in (cur_bfd
,
484 ecoff_data (cur_bfd
)->external_rfd
+ f
->rfdBase
+ rf
,
489 /* Return a safer print NAME for a file descriptor */
496 return "<stripped file>";
499 return ecoff_data (cur_bfd
)->ss
+ f
->issBase
+ f
->rss
;
503 /* Read in and parse the symtab of the file OBJFILE. Symbols from
504 different sections are relocated via the SECTION_OFFSETS. */
507 read_mips_symtab (objfile
, section_offsets
)
508 struct objfile
*objfile
;
509 struct section_offsets
*section_offsets
;
511 cur_bfd
= objfile
->obfd
;
513 read_the_mips_symtab (objfile
->obfd
);
515 parse_partial_symbols (objfile
, section_offsets
);
518 /* Check to make sure file was compiled with -g. If not, warn the
519 user of this limitation. */
520 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
522 if (max_gdbinfo
== 0)
523 printf ("\n%s not compiled with -g, debugging support is limited.\n",
525 printf ("You should compile with -g2 or -g3 for best debugging support.\n");
531 /* Local utilities */
533 /* Map of FDR indexes to partial symtabs */
537 struct partial_symtab
*pst
; /* the psymtab proper */
538 int n_globals
; /* exported globals (external symbols) */
539 int globals_offset
; /* cumulative */
543 /* Utility stack, used to nest procedures and blocks properly.
544 It is a doubly linked list, to avoid too many alloc/free.
545 Since we might need it quite a few times it is NOT deallocated
548 static struct parse_stack
550 struct parse_stack
*next
, *prev
;
551 struct symtab
*cur_st
; /* Current symtab. */
552 struct block
*cur_block
; /* Block in it. */
553 int blocktype
; /* What are we parsing. */
554 int maxsyms
; /* Max symbols in this block. */
555 struct type
*cur_type
; /* Type we parse fields for. */
556 int cur_field
; /* Field number in cur_type. */
557 int procadr
; /* Start addres of this procedure */
558 int numargs
; /* Its argument count */
561 *top_stack
; /* Top stack ptr */
564 /* Enter a new lexical context */
569 struct parse_stack
*new;
571 /* Reuse frames if possible */
572 if (top_stack
&& top_stack
->prev
)
573 new = top_stack
->prev
;
575 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
576 /* Initialize new frame with previous content */
579 register struct parse_stack
*prev
= new->prev
;
582 top_stack
->prev
= new;
584 new->next
= top_stack
;
589 /* Exit a lexical context */
597 top_stack
= top_stack
->next
;
601 /* Cross-references might be to things we haven't looked at
602 yet, e.g. type references. To avoid too many type
603 duplications we keep a quick fixup table, an array
604 of lists of references indexed by file descriptor */
606 static struct mips_pending
608 struct mips_pending
*next
; /* link */
609 struct sym_ext
*s
; /* the symbol */
610 struct type
*t
; /* its partial type descriptor */
614 /* Check whether we already saw symbol SH in file FH as undefined */
616 static struct mips_pending
*
617 is_pending_symbol (fh
, sh
)
621 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
622 register struct mips_pending
*p
;
624 /* Linear search is ok, list is typically no more than 10 deep */
625 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
631 /* Add a new undef symbol SH of type T */
634 add_pending (fh
, sh
, t
)
639 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
640 struct mips_pending
*p
= is_pending_symbol (fh
, sh
);
642 /* Make sure we do not make duplicates */
645 p
= (struct mips_pending
*) xmalloc (sizeof (*p
));
648 p
->next
= pending_list
[f_idx
];
649 pending_list
[f_idx
] = p
;
653 /* Throw away undef entries when done with file index F_IDX */
654 /* FIXME -- storage leak. This is never called!!! --gnu */
662 register struct mips_pending
*p
, *q
;
664 for (p
= pending_list
[f_idx
]; p
; p
= q
)
669 pending_list
[f_idx
] = 0;
676 /* Parsing Routines proper. */
678 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
679 For blocks, procedures and types we open a new lexical context.
680 This is basically just a big switch on the symbol's type. Argument
681 AX is the base pointer of aux symbols for this file (fh->iauxBase).
682 EXT_SH points to the unswapped symbol, which is needed for struct,
683 union, etc., types; it is NULL for an EXTR. BIGEND says whether
684 aux symbols are big-endian or little-endian. Return count of
685 SYMR's handled (normally one).
687 FIXME: This modifies the symbol, but the only way we have to save
688 the modified information is to stuff it back into the BFD data. */
691 parse_symbol (sh
, ax
, ext_sh
, bigend
)
694 struct sym_ext
*ext_sh
;
700 struct mips_pending
*pend
;
704 enum address_class
class;
707 if (ext_sh
== (struct sym_ext
*) NULL
)
708 name
= ecoff_data (cur_bfd
)->ssext
+ sh
->iss
;
710 name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
->iss
;
717 case stGlobal
: /* external symbol, goes into global block */
719 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
721 s
= new_symbol (name
);
722 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
725 case stStatic
: /* static data, goes into current block. */
727 b
= top_stack
->cur_block
;
728 s
= new_symbol (name
);
729 if (sh
->sc
== scCommon
)
731 /* It is a FORTRAN common block. At least for SGI Fortran the
732 address is not in the symbol; we need to fix it later in
733 scan_file_globals. */
734 int bucket
= hashname (SYMBOL_NAME (s
));
735 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
736 global_sym_chain
[bucket
] = s
;
739 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
742 case stLocal
: /* local variable, goes into current block */
743 if (sh
->sc
== scRegister
)
745 class = LOC_REGISTER
;
747 sh
->value
+= FP0_REGNUM
- 32;
751 b
= top_stack
->cur_block
;
752 s
= new_symbol (name
);
753 SYMBOL_VALUE (s
) = sh
->value
;
755 data
: /* Common code for symbols describing data */
756 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
757 SYMBOL_CLASS (s
) = class;
760 /* Type could be missing in a number of cases */
761 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
762 sh
->index
== 0xfffff)
763 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
765 SYMBOL_TYPE (s
) = parse_type (ax
+ sh
->index
, 0, bigend
);
766 /* Value of a data symbol is its memory address */
769 case stParam
: /* arg to procedure, goes into current block */
771 top_stack
->numargs
++;
773 /* Special GNU C++ name. */
774 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
775 name
= "this"; /* FIXME, not alloc'd in obstack */
776 s
= new_symbol (name
);
778 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
782 /* Pass by value in register. */
783 SYMBOL_CLASS(s
) = LOC_REGPARM
;
785 sh
->value
+= FP0_REGNUM
-32;
788 /* Pass by reference on stack. */
789 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
792 /* Pass by reference in register. */
793 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
796 /* Pass by value on stack. */
797 SYMBOL_CLASS(s
) = LOC_ARG
;
800 SYMBOL_VALUE (s
) = sh
->value
;
801 SYMBOL_TYPE (s
) = parse_type (ax
+ sh
->index
, 0, bigend
);
802 add_symbol (s
, top_stack
->cur_block
);
804 /* FIXME: This has not been tested. See dbxread.c */
805 /* Add the type of this parameter to the function/procedure
806 type of this block. */
807 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
811 case stLabel
: /* label, goes into current block */
812 s
= new_symbol (name
);
813 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
814 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
815 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
816 SYMBOL_TYPE (s
) = builtin_type_int
;
817 add_symbol (s
, top_stack
->cur_block
);
821 /* I believe this is used only for file-local functions.
822 The comment in symconst.h ("load time only static procs") isn't
823 particularly clear on this point. */
824 prim_record_minimal_symbol (name
, sh
->value
, mst_file_text
);
827 case stProc
: /* Procedure, usually goes into global block */
828 s
= new_symbol (name
);
829 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
830 SYMBOL_CLASS (s
) = LOC_BLOCK
;
831 /* Type of the return value */
832 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
833 t
= builtin_type_int
;
835 t
= parse_type (ax
+ sh
->index
+ 1, 0, bigend
);
836 b
= top_stack
->cur_block
;
837 if (sh
->st
== stProc
)
839 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
840 /* The next test should normally be true,
841 but provides a hook for nested functions
842 (which we don't want to make global). */
843 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
844 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
848 /* Make a type for the procedure itself */
850 /* FIXME: This has not been tested yet! See dbxread.c */
851 /* Generate a template for the type of this function. The
852 types of the arguments will be added as we read the symbol
854 bcopy (SYMBOL_TYPE (s
), lookup_function_type (t
), sizeof (struct type
));
856 SYMBOL_TYPE (s
) = lookup_function_type (t
);
859 /* Create and enter a new lexical context */
860 b
= new_block (top_stack
->maxsyms
);
861 SYMBOL_BLOCK_VALUE (s
) = b
;
862 BLOCK_FUNCTION (b
) = s
;
863 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
864 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
865 add_block (b
, top_stack
->cur_st
);
867 /* Not if we only have partial info */
868 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
872 top_stack
->cur_block
= b
;
873 top_stack
->blocktype
= sh
->st
;
874 top_stack
->cur_type
= SYMBOL_TYPE (s
);
875 top_stack
->cur_field
= -1;
876 top_stack
->procadr
= sh
->value
;
877 top_stack
->numargs
= 0;
879 sh
->value
= (long) SYMBOL_TYPE (s
);
882 /* Beginning of code for structure, union, and enum definitions.
883 They all share a common set of local variables, defined here. */
885 enum type_code type_code
;
886 struct sym_ext
*ext_tsym
;
891 case stStruct
: /* Start a block defining a struct type */
892 type_code
= TYPE_CODE_STRUCT
;
893 goto structured_common
;
895 case stUnion
: /* Start a block defining a union type */
896 type_code
= TYPE_CODE_UNION
;
897 goto structured_common
;
899 case stEnum
: /* Start a block defining an enum type */
900 type_code
= TYPE_CODE_ENUM
;
901 goto structured_common
;
903 case stBlock
: /* Either a lexical block, or some type */
904 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
905 goto case_stBlock_code
; /* Lexical block */
907 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
909 /* Common code for handling struct, union, enum, and/or as-yet-
910 unknown-type blocks of info about structured data. `type_code'
911 has been set to the proper TYPE_CODE, if we know it. */
914 top_stack
->blocktype
= stBlock
;
916 s
= new_symbol (name
);
917 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
918 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
919 SYMBOL_VALUE (s
) = 0;
920 add_symbol (s
, top_stack
->cur_block
);
922 /* First count the number of fields and the highest value. */
925 for (ext_tsym
= ext_sh
+ 1; ; ext_tsym
++)
929 ecoff_swap_sym_in (cur_bfd
, ext_tsym
, &tsym
);
937 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
938 /* If the type of the member is Nil (or Void),
939 without qualifiers, assume the tag is an
941 if (tsym
.index
== indexNil
)
942 type_code
= TYPE_CODE_ENUM
;
945 ecoff_swap_tir_in (bigend
,
946 &ax
[tsym
.index
].a_ti
,
948 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
950 type_code
= TYPE_CODE_ENUM
;
953 if (tsym
.value
> max_value
)
954 max_value
= tsym
.value
;
960 complain (&block_member_complaint
, tsym
.st
);
961 /* These are said to show up in cfront-generated programs.
962 Apparently processing them like the following prevents
973 /* This is a no-op; is it trying to tell us something
974 we should be checking? */
975 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
979 /* This is something like a struct within a
980 struct. Skip over the fields of the inner
981 struct. The -1 is because the for loop will
982 increment ext_tsym. */
983 ext_tsym
= (ecoff_data (cur_bfd
)->external_sym
992 complain (&block_member_complaint
, tsym
.st
);
997 /* In an stBlock, there is no way to distinguish structs,
998 unions, and enums at this point. This is a bug in the
999 original design (that has been fixed with the recent
1000 addition of the stStruct, stUnion, and stEnum symbol
1001 types.) The way you can tell is if/when you see a variable
1002 or field of that type. In that case the variable's type
1003 (in the AUX table) says if the type is struct, union, or
1004 enum, and points back to the stBlock here. So you can
1005 patch the tag kind up later - but only if there actually is
1006 a variable or field of that type.
1008 So until we know for sure, we will guess at this point.
1010 If the first member has index==indexNil or a void type,
1011 assume we have an enumeration.
1012 Otherwise, if there is more than one member, and all
1013 the members have offset 0, assume we have a union.
1014 Otherwise, assume we have a struct.
1016 The heuristic could guess wrong in the case of of an
1017 enumeration with no members or a union with one (or zero)
1018 members, or when all except the last field of a struct have
1019 width zero. These are uncommon and/or illegal situations,
1020 and in any case guessing wrong probably doesn't matter
1023 But if we later do find out we were wrong, we fixup the tag
1024 kind. Members of an enumeration must be handled
1025 differently from struct/union fields, and that is harder to
1026 patch up, but luckily we shouldn't need to. (If there are
1027 any enumeration members, we can tell for sure it's an enum
1030 if (type_code
== TYPE_CODE_UNDEF
)
1031 if (nfields
> 1 && max_value
== 0)
1032 type_code
= TYPE_CODE_UNION
;
1034 type_code
= TYPE_CODE_STRUCT
;
1036 /* If this type was expected, use its partial definition */
1037 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1038 if (pend
!= (struct mips_pending
*) NULL
)
1041 t
= new_type (NULL
);
1043 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1045 TYPE_CODE (t
) = type_code
;
1046 TYPE_LENGTH (t
) = sh
->value
;
1047 TYPE_NFIELDS (t
) = nfields
;
1048 TYPE_FIELDS (t
) = f
= ((struct field
*)
1050 nfields
* sizeof (struct field
)));
1052 if (type_code
== TYPE_CODE_ENUM
)
1054 /* This is a non-empty enum. */
1055 for (ext_tsym
= ext_sh
+ 1; ; ext_tsym
++)
1058 struct symbol
*enum_sym
;
1060 ecoff_swap_sym_in (cur_bfd
, ext_tsym
, &tsym
);
1062 if (tsym
.st
!= stMember
)
1065 f
->bitpos
= tsym
.value
;
1067 f
->name
= (ecoff_data (cur_bfd
)->ss
1072 enum_sym
= ((struct symbol
*)
1073 obstack_alloc (¤t_objfile
->symbol_obstack
,
1074 sizeof (struct symbol
)));
1075 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1076 SYMBOL_NAME (enum_sym
) = f
->name
;
1077 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1078 SYMBOL_TYPE (enum_sym
) = t
;
1079 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1080 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1081 add_symbol (enum_sym
, top_stack
->cur_block
);
1083 /* Skip the stMembers that we've handled. */
1088 SYMBOL_TYPE (s
) = t
;
1089 /* make this the current type */
1090 top_stack
->cur_type
= t
;
1091 top_stack
->cur_field
= 0;
1092 /* Mark that symbol has a type, and say which one */
1093 sh
->value
= (long) t
;
1096 /* End of local variables shared by struct, union, enum, and
1097 block (as yet unknown struct/union/enum) processing. */
1101 /* beginnning of (code) block. Value of symbol
1102 is the displacement from procedure start */
1103 push_parse_stack ();
1104 top_stack
->blocktype
= stBlock
;
1105 b
= new_block (top_stack
->maxsyms
);
1106 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1107 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1108 top_stack
->cur_block
= b
;
1109 add_block (b
, top_stack
->cur_st
);
1112 case stEnd
: /* end (of anything) */
1113 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1115 /* Finished with type */
1116 top_stack
->cur_type
= 0;
1118 else if (sh
->sc
== scText
&&
1119 (top_stack
->blocktype
== stProc
||
1120 top_stack
->blocktype
== stStaticProc
))
1122 /* Finished with procedure */
1123 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1124 struct mips_extra_func_info
*e
;
1128 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1130 /* Make up special symbol to contain procedure specific info */
1131 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1132 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1133 SYMBOL_CLASS (s
) = LOC_CONST
;
1134 SYMBOL_TYPE (s
) = builtin_type_void
;
1135 e
= ((struct mips_extra_func_info
*)
1136 obstack_alloc (¤t_objfile
->symbol_obstack
,
1137 sizeof (struct mips_extra_func_info
)));
1138 SYMBOL_VALUE (s
) = (int) e
;
1139 e
->numargs
= top_stack
->numargs
;
1140 add_symbol (s
, top_stack
->cur_block
);
1142 /* Reallocate symbols, saving memory */
1143 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1145 /* f77 emits proc-level with address bounds==[0,0],
1146 So look for such child blocks, and patch them. */
1147 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1149 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1150 if (BLOCK_SUPERBLOCK (b_bad
) == b
1151 && BLOCK_START (b_bad
) == top_stack
->procadr
1152 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1154 BLOCK_START (b_bad
) = BLOCK_START (b
);
1155 BLOCK_END (b_bad
) = BLOCK_END (b
);
1159 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1161 /* End of (code) block. The value of the symbol is the
1162 displacement from the procedure`s start address of the
1163 end of this block. */
1164 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1165 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1167 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1169 /* End of file. Pop parse stack and ignore. Higher
1170 level code deals with this. */
1174 complain (&stEnd_complaint
, sh
->sc
);
1176 pop_parse_stack (); /* restore previous lexical context */
1179 case stMember
: /* member of struct or union */
1180 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1182 f
->bitpos
= sh
->value
;
1184 f
->type
= parse_type (ax
+ sh
->index
, &f
->bitsize
, bigend
);
1187 case stTypedef
: /* type definition */
1188 s
= new_symbol (name
);
1189 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1190 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1191 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1192 add_symbol (s
, top_stack
->cur_block
);
1193 SYMBOL_TYPE (s
) = parse_type (ax
+ sh
->index
, 0, bigend
);
1194 sh
->value
= (long) SYMBOL_TYPE (s
);
1197 case stFile
: /* file name */
1198 push_parse_stack ();
1199 top_stack
->blocktype
= sh
->st
;
1202 /* I`ve never seen these for C */
1204 break; /* register relocation */
1206 break; /* forwarding address */
1208 break; /* constant */
1210 complain (&unknown_mips_symtype_complaint
, sh
->st
);
1219 /* Parse the type information provided in the raw AX entries for
1220 the symbol SH. Return the bitfield size in BS, in case.
1221 We must byte-swap the AX entries before we use them; BIGEND says whether
1222 they are big-endian or little-endian (from fh->fBigendian). */
1224 static struct type
*
1225 parse_type (ax
, bs
, bigend
)
1230 /* Null entries in this map are treated specially */
1231 static struct type
**map_bt
[] =
1233 &builtin_type_void
, /* btNil */
1235 &builtin_type_char
, /* btChar */
1236 &builtin_type_unsigned_char
,/* btUChar */
1237 &builtin_type_short
, /* btShort */
1238 &builtin_type_unsigned_short
, /* btUShort */
1239 &builtin_type_int
, /* btInt */
1240 &builtin_type_unsigned_int
, /* btUInt */
1241 &builtin_type_long
, /* btLong */
1242 &builtin_type_unsigned_long
,/* btULong */
1243 &builtin_type_float
, /* btFloat */
1244 &builtin_type_double
, /* btDouble */
1251 &builtin_type_complex
, /* btComplex */
1252 &builtin_type_double_complex
, /* btDComplex */
1254 &builtin_type_fixed_dec
, /* btFixedDec */
1255 &builtin_type_float_dec
, /* btFloatDec */
1256 &builtin_type_string
, /* btString */
1259 &builtin_type_void
, /* btVoid */
1260 &builtin_type_long_long
, /* btLongLong */
1261 &builtin_type_unsigned_long_long
, /* btULongLong */
1265 struct type
*tp
= 0;
1268 enum type_code type_code
= TYPE_CODE_UNDEF
;
1270 /* Use aux as a type information record, map its basic type. */
1272 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1273 if (t
->bt
> (sizeof (map_bt
) / sizeof (*map_bt
)))
1275 complain (&basic_type_complaint
, t
->bt
);
1276 return builtin_type_int
;
1280 tp
= *map_bt
[t
->bt
];
1285 /* Cannot use builtin types -- build our own */
1289 tp
= lookup_pointer_type (builtin_type_void
);
1292 type_code
= TYPE_CODE_STRUCT
;
1295 type_code
= TYPE_CODE_UNION
;
1298 type_code
= TYPE_CODE_ENUM
;
1301 type_code
= TYPE_CODE_RANGE
;
1304 type_code
= TYPE_CODE_SET
;
1308 complain (&basic_type_complaint
, t
->bt
);
1309 return builtin_type_int
;
1313 /* Skip over any further type qualifiers (FIXME). */
1316 /* This is the way it would work if the compiler worked */
1321 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t1
);
1323 while (t1
->continued
);
1326 /* Move on to next aux */
1331 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1335 /* All these types really point to some (common) MIPS type
1336 definition, and only the type-qualifiers fully identify
1337 them. We'll make the same effort at sharing. */
1338 if (t
->bt
== btStruct
||
1342 /* btSet (I think) implies that the name is a tag name, not a typedef
1343 name. This apparently is a MIPS extension for C sets. */
1348 /* Try to cross reference this type */
1349 ax
+= cross_ref (ax
, &tp
, type_code
, &name
, bigend
);
1350 /* reading .o file ? */
1351 if (tp
== (struct type
*) NULL
)
1352 tp
= init_type (type_code
, 0, 0, (char *) NULL
,
1353 (struct objfile
*) NULL
);
1355 /* Usually, TYPE_CODE(tp) is already type_code. The main
1356 exception is if we guessed wrong re struct/union/enum. */
1357 if (TYPE_CODE (tp
) != type_code
)
1359 complain (&bad_tag_guess_complaint
, name
);
1360 TYPE_CODE (tp
) = type_code
;
1362 /* Do not set the tag name if it is a compiler generated tag name
1363 (.Fxx or .xxfake) for unnamed struct/union/enums. */
1365 TYPE_TAG_NAME (tp
) = NULL
;
1366 else if (TYPE_TAG_NAME (tp
) == NULL
|| !STREQ (TYPE_TAG_NAME (tp
), name
))
1367 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1368 ¤t_objfile
->type_obstack
);
1371 /* All these types really point to some (common) MIPS type
1372 definition, and only the type-qualifiers fully identify
1373 them. We'll make the same effort at sharing. */
1374 if (t
->bt
== btIndirect
||
1379 /* Try to cross reference this type */
1380 ax
+= cross_ref (ax
, &tp
, type_code
, &name
, bigend
);
1381 /* reading .o file ? */
1382 if (tp
== (struct type
*) NULL
)
1383 tp
= init_type (type_code
, 0, 0, (char *) NULL
,
1384 (struct objfile
*) NULL
);
1386 /* Usually, TYPE_CODE(tp) is already type_code. The main
1387 exception is if we guessed wrong re struct/union/enum. */
1388 if (TYPE_CODE (tp
) != type_code
)
1390 complain (&bad_tag_guess_complaint
, name
);
1391 TYPE_CODE (tp
) = type_code
;
1393 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1394 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1395 ¤t_objfile
->type_obstack
);
1398 /* Deal with range types */
1399 if (t
->bt
== btRange
)
1401 TYPE_NFIELDS (tp
) = 2;
1402 TYPE_FIELDS (tp
) = ((struct field
*)
1403 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1404 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1405 ¤t_objfile
->type_obstack
);
1406 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1408 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1409 ¤t_objfile
->type_obstack
);
1410 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1414 /* Parse all the type qualifiers now. If there are more
1415 than 6 the game will continue in the next aux */
1417 #define PARSE_TQ(tq) \
1418 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
1420 again
:PARSE_TQ (tq0
);
1431 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1437 /* Make up a complex type from a basic one. Type is passed by
1438 reference in TPP and side-effected as necessary. The type
1439 qualifier TQ says how to handle the aux symbols at AX for
1440 the symbol SX we are currently analyzing. BIGEND says whether
1441 aux symbols are big-endian or little-endian.
1442 Returns the number of aux symbols we parsed. */
1445 upgrade_type (tpp
, tq
, ax
, bigend
)
1454 /* Used in array processing */
1465 t
= lookup_pointer_type (*tpp
);
1470 t
= lookup_function_type (*tpp
);
1477 /* Determine and record the domain type (type of index) */
1478 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1484 rf
= AUX_GET_ISYM (bigend
, ax
);
1487 fh
= get_rfd (cur_fd
, rf
);
1489 indx
= parse_type ((ecoff_data (cur_bfd
)->external_aux
1492 (int *) NULL
, bigend
);
1494 /* Get the bounds, and create the array type. */
1496 lower
= AUX_GET_DNLOW (bigend
, ax
);
1498 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1500 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1502 range
= create_range_type ((struct type
*) NULL
, indx
,
1505 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1507 /* Check whether supplied array element bit size matches
1508 the known size of the element type. If this complaint
1509 ends up not happening, we can remove this code. It's
1510 here because we aren't sure we understand this *&%&$
1512 id
= TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) << 3; /* bitsize */
1515 /* Most likely an undefined type */
1517 TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) = id
>> 3;
1520 complain (&array_bitsize_complaint
, rf
);
1526 /* Volatile -- currently ignored */
1530 /* Const -- currently ignored */
1534 complain (&unknown_type_qual_complaint
, tq
);
1540 /* Parse a procedure descriptor record PR. Note that the procedure is
1541 parsed _after_ the local symbols, now we just insert the extra
1542 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1543 already been placed in the procedure's main block. Note also that
1544 images that have been partially stripped (ld -x) have been deprived
1545 of local symbols, and we have to cope with them here. FIRST_OFF is
1546 the offset of the first procedure for this FDR; we adjust the
1547 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1548 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1549 in question, or NULL to use top_stack->cur_block. */
1551 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1554 parse_procedure (pr
, search_symtab
, first_off
)
1556 struct symtab
*search_symtab
;
1557 unsigned long first_off
;
1559 struct symbol
*s
, *i
;
1561 struct mips_extra_func_info
*e
;
1564 /* Simple rule to find files linked "-x" */
1565 if (cur_fdr
->rss
== -1)
1569 /* Static procedure at address pr->adr. Sigh. */
1570 complain (&pdr_static_symbol_complaint
, pr
->adr
);
1578 ecoff_swap_ext_in (cur_bfd
,
1579 ecoff_data (cur_bfd
)->external_ext
+ pr
->isym
,
1581 sh_name
= ecoff_data (cur_bfd
)->ssext
+ she
.asym
.iss
;
1589 ecoff_swap_sym_in (cur_bfd
,
1590 (ecoff_data (cur_bfd
)->external_sym
1594 sh_name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1597 if (search_symtab
!= NULL
)
1600 /* This loses both in the case mentioned (want a static, find a global),
1601 but also if we are looking up a non-mangled name which happens to
1602 match the name of a mangled function. */
1603 /* We have to save the cur_fdr across the call to lookup_symbol.
1604 If the pdr is for a static function and if a global function with
1605 the same name exists, lookup_symbol will eventually read in the symtab
1606 for the global function and clobber cur_fdr. */
1607 FDR
*save_cur_fdr
= cur_fdr
;
1608 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1609 cur_fdr
= save_cur_fdr
;
1613 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1619 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1620 VAR_NAMESPACE
, LOC_BLOCK
);
1624 b
= SYMBOL_BLOCK_VALUE (s
);
1628 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1632 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1633 s
= new_symbol (sh_name
);
1634 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1635 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1636 /* Donno its type, hope int is ok */
1637 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1638 add_symbol (s
, top_stack
->cur_block
);
1639 /* Wont have symbols for this one */
1641 SYMBOL_BLOCK_VALUE (s
) = b
;
1642 BLOCK_FUNCTION (b
) = s
;
1643 BLOCK_START (b
) = pr
->adr
;
1644 /* BOUND used to be the end of procedure's text, but the
1645 argument is no longer passed in. */
1646 BLOCK_END (b
) = bound
;
1647 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1648 add_block (b
, top_stack
->cur_st
);
1652 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1656 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1658 e
->pdr
.isym
= (long) s
;
1659 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1661 /* Correct incorrect setjmp procedure descriptor from the library
1662 to make backtrace through setjmp work. */
1663 if (e
->pdr
.pcreg
== 0 && strcmp (sh_name
, "setjmp") == 0)
1665 complain (&bad_setjmp_pdr_complaint
, 0);
1666 e
->pdr
.pcreg
= RA_REGNUM
;
1667 e
->pdr
.regmask
= 0x80000000;
1668 e
->pdr
.regoffset
= -4;
1673 /* Parse the external symbol ES. Just call parse_symbol() after
1674 making sure we know where the aux are for it. For procedures,
1675 parsing of the PDRs has already provided all the needed
1676 information, we only parse them if SKIP_PROCEDURES is false,
1677 and only if this causes no symbol duplication.
1678 BIGEND says whether aux entries are big-endian or little-endian.
1680 This routine clobbers top_stack->cur_block and ->cur_st. */
1683 parse_external (es
, skip_procedures
, bigend
)
1685 int skip_procedures
;
1690 if (es
->ifd
!= ifdNil
)
1693 cur_fdr
= ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
1694 ax
= ecoff_data (cur_bfd
)->external_aux
+ cur_fdr
->iauxBase
;
1698 cur_fdr
= ecoff_data (cur_bfd
)->fdr
;
1702 /* Reading .o files */
1703 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1706 switch (es
->asym
.st
)
1726 /* FIXME: Turn this into a complaint? */
1728 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1730 ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1731 fdr_name (cur_fdr
));
1735 switch (es
->asym
.st
)
1738 /* If we have full symbols we do not need more */
1739 if (skip_procedures
)
1741 if (mylookup_symbol (ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1742 top_stack
->cur_block
,
1743 VAR_NAMESPACE
, LOC_BLOCK
))
1748 /* Note that the case of a symbol with indexNil must be handled
1749 anyways by parse_symbol(). */
1750 parse_symbol (&es
->asym
, ax
, (struct sym_ext
*) NULL
, bigend
);
1751 /* Note that parse_symbol changed es->asym. */
1758 /* Parse the line number info for file descriptor FH into
1759 GDB's linetable LT. MIPS' encoding requires a little bit
1760 of magic to get things out. Note also that MIPS' line
1761 numbers can go back and forth, apparently we can live
1762 with that and do not need to reorder our linetables */
1765 parse_lines (fh
, pr
, lt
)
1768 struct linetable
*lt
;
1770 unsigned char *base
;
1772 int delta
, count
, lineno
= 0;
1773 unsigned long first_off
= pr
->adr
;
1775 if (fh
->cbLineOffset
== 0)
1778 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1780 /* Scan by procedure descriptors */
1782 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1787 /* No code for this one */
1788 if (pr
->iline
== ilineNil
||
1789 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1792 /* Aurgh! To know where to stop expanding we must look-ahead. */
1793 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1794 if (pr
[l
].iline
!= -1)
1796 if (l
== (fh
->cpd
- j
))
1801 /* When procedures are moved around the linenumbers are
1802 attributed to the next procedure up. */
1803 if (pr
->iline
>= halt
)
1806 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
+ pr
->cbLineOffset
;
1807 adr
= fh
->adr
+ pr
->adr
- first_off
;
1808 l
= adr
>> 2; /* in words */
1809 halt
+= (adr
>> 2) - pr
->iline
;
1810 for (lineno
= pr
->lnLow
; l
< halt
;)
1812 count
= *base
& 0x0f;
1813 delta
= *base
++ >> 4;
1818 delta
= (base
[0] << 8) | base
[1];
1819 if (delta
>= 0x8000)
1823 lineno
+= delta
; /* first delta is 0 */
1824 k
= add_line (lt
, lineno
, l
, k
);
1830 /* Master parsing procedure for first-pass reading of file symbols
1831 into a partial_symtab. */
1834 parse_partial_symbols (objfile
, section_offsets
)
1835 struct objfile
*objfile
;
1836 struct section_offsets
*section_offsets
;
1839 HDRR
*hdr
= &ecoff_data (cur_bfd
)->symbolic_header
;
1840 /* Running pointers */
1842 struct ext_ext
*ext_out
;
1843 struct ext_ext
*ext_out_end
;
1845 register EXTR
*ext_in
;
1848 struct partial_symtab
*pst
;
1850 int past_first_source_file
= 0;
1852 /* List of current psymtab's include files */
1853 char **psymtab_include_list
;
1854 int includes_allocated
;
1857 struct pst_map
*fdr_to_pst
;
1858 /* Index within current psymtab dependency list */
1859 struct partial_symtab
**dependency_list
;
1860 int dependencies_used
, dependencies_allocated
;
1861 struct cleanup
*old_chain
;
1864 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
1865 sizeof (EXTR
) * hdr
->iextMax
);
1867 includes_allocated
= 30;
1869 psymtab_include_list
= (char **) alloca (includes_allocated
*
1871 next_symbol_text_func
= mips_next_symbol_text
;
1873 dependencies_allocated
= 30;
1874 dependencies_used
= 0;
1876 (struct partial_symtab
**) alloca (dependencies_allocated
*
1877 sizeof (struct partial_symtab
*));
1879 last_source_file
= NULL
;
1884 * Only parse the Local and External symbols, and the Relative FDR.
1885 * Fixup enough of the loader symtab to be able to use it.
1886 * Allocate space only for the file's portions we need to
1891 max_glevel
= MIN_GLEVEL
;
1893 /* Allocate the map FDR -> PST.
1894 Minor hack: -O3 images might claim some global data belongs
1895 to FDR -1. We`ll go along with that */
1896 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
1897 old_chain
= make_cleanup (free
, fdr_to_pst
);
1900 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
1901 fdr_to_pst
[-1].pst
= pst
;
1905 /* Pass 0 over external syms: swap them in. */
1906 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
1907 make_cleanup (free
, ext_block
);
1909 ext_out
= ecoff_data (cur_bfd
)->external_ext
;
1910 ext_out_end
= ext_out
+ hdr
->iextMax
;
1912 for (; ext_out
< ext_out_end
; ext_out
++, ext_in
++)
1913 ecoff_swap_ext_in (cur_bfd
, ext_out
, ext_in
);
1915 /* Pass 1 over external syms: Presize and partition the list */
1917 ext_in_end
= ext_in
+ hdr
->iextMax
;
1918 for (; ext_in
< ext_in_end
; ext_in
++)
1919 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
1921 /* Pass 1.5 over files: partition out global symbol space */
1923 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
1925 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
1926 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1927 fdr_to_pst
[f_idx
].n_globals
= 0;
1930 /* Pass 2 over external syms: fill in external symbols */
1932 ext_in_end
= ext_in
+ hdr
->iextMax
;
1933 for (; ext_in
< ext_in_end
; ext_in
++)
1935 enum minimal_symbol_type ms_type
= mst_text
;
1937 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
1938 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
1940 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
1943 name
= ecoff_data (cur_bfd
)->ssext
+ ext_in
->asym
.iss
;
1944 switch (ext_in
->asym
.st
)
1954 ms_type
= mst_unknown
;
1955 complain (&unknown_ext_complaint
, name
);
1957 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
);
1960 /* Pass 3 over files, over local syms: fill in static symbols */
1961 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
1963 struct partial_symtab
*save_pst
;
1966 cur_fdr
= fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
1970 fdr_to_pst
[f_idx
].pst
= NULL
;
1973 pst
= start_psymtab_common (objfile
, section_offsets
,
1975 fh
->cpd
? fh
->adr
: 0,
1976 objfile
->global_psymbols
.next
,
1977 objfile
->static_psymbols
.next
);
1978 pst
->read_symtab_private
= ((char *)
1979 obstack_alloc (&objfile
->psymbol_obstack
,
1980 sizeof (struct symloc
)));
1981 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
1984 /* Make everything point to everything. */
1985 FDR_IDX (pst
) = f_idx
;
1986 fdr_to_pst
[f_idx
].pst
= pst
;
1988 /* FIXME: This tampers with data from BFD. */
1989 fh
->ioptBase
= (int) pst
;
1991 CUR_BFD (pst
) = cur_bfd
;
1993 /* The way to turn this into a symtab is to call... */
1994 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
1996 pst
->texthigh
= pst
->textlow
;
1998 /* For stabs-in-ecoff files, the second symbol must be @stab.
1999 This symbol is emitted by mips-tfile to signal that the
2000 current object file uses encapsulated stabs instead of mips
2001 ecoff for local symbols. (It is the second symbol because
2002 the first symbol is the stFile used to signal the start of a
2004 processing_gcc_compilation
= 0;
2007 ecoff_swap_sym_in (cur_bfd
,
2008 (ecoff_data (cur_bfd
)->external_sym
2012 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2014 processing_gcc_compilation
= 2;
2017 if (processing_gcc_compilation
!= 0)
2019 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2024 ecoff_swap_sym_in (cur_bfd
,
2025 (ecoff_data (cur_bfd
)->external_sym
2029 type_code
= MIPS_UNMARK_STAB (sh
.index
);
2030 if (!MIPS_IS_STAB (&sh
))
2032 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2034 long procaddr
= sh
.value
;
2038 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2039 (ecoff_data (cur_bfd
)->external_aux
2042 ecoff_swap_sym_in (cur_bfd
,
2043 (ecoff_data (cur_bfd
)->external_sym
2050 long high
= procaddr
+ sh
.value
;
2051 if (high
> pst
->texthigh
)
2052 pst
->texthigh
= high
;
2057 #define SET_NAMESTRING() \
2058 namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
2059 #define CUR_SYMBOL_TYPE type_code
2060 #define CUR_SYMBOL_VALUE sh.value
2061 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2063 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2064 #define HANDLE_RBRAC(val) \
2065 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2066 #include "partial-stab.h"
2071 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2074 enum address_class
class;
2076 ecoff_swap_sym_in (cur_bfd
,
2077 (ecoff_data (cur_bfd
)->external_sym
2082 if (MIPS_IS_STAB (&sh
))
2088 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
||
2089 sh
.index
== 0xfffff)
2091 /* FIXME, premature? */
2096 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2104 case stProc
: /* Asm labels apparently */
2105 case stStaticProc
: /* Function */
2106 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2107 VAR_NAMESPACE
, LOC_BLOCK
,
2108 objfile
->static_psymbols
, sh
.value
,
2109 psymtab_language
, objfile
);
2110 /* Skip over procedure to next one. */
2111 if (sh
.index
>= hdr
->iauxMax
)
2113 /* Should not happen, but does when cross-compiling
2114 with the MIPS compiler. FIXME -- pull later. */
2115 complain (&index_complaint
, name
);
2116 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2119 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2120 (ecoff_data (cur_bfd
)->external_aux
2123 procaddr
= sh
.value
;
2125 if (new_sdx
<= cur_sdx
)
2127 /* This should not happen either... FIXME. */
2128 complain (&aux_index_complaint
, name
);
2129 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2133 ecoff_swap_sym_in (cur_bfd
,
2134 (ecoff_data (cur_bfd
)->external_sym
2141 high
= procaddr
+ sh
.value
;
2142 if (high
> pst
->texthigh
)
2143 pst
->texthigh
= high
;
2146 case stStatic
: /* Variable */
2150 case stTypedef
:/* Typedef */
2151 class = LOC_TYPEDEF
;
2154 case stConstant
: /* Constant decl */
2161 case stBlock
: /* { }, str, un, enum*/
2162 if (sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2164 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2165 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2166 objfile
->static_psymbols
,
2168 psymtab_language
, objfile
);
2170 /* Skip over the block */
2172 if (new_sdx
<= cur_sdx
)
2174 /* This happens with the Ultrix kernel. */
2175 complain (&block_index_complaint
, name
);
2176 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2181 case stFile
: /* File headers */
2182 case stLabel
: /* Labels */
2183 case stEnd
: /* Ends of files */
2186 case stLocal
: /* Local variables */
2187 /* Normally these are skipped because we skip over
2188 all blocks we see. However, these can occur
2189 as visible symbols in a .h file that contains code. */
2193 /* Both complaints are valid: one gives symbol name,
2194 the other the offending symbol type. */
2195 complain (&unknown_sym_complaint
, name
);
2196 complain (&unknown_st_complaint
, sh
.st
);
2200 /* Use this gdb symbol */
2201 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2202 VAR_NAMESPACE
, class,
2203 objfile
->static_psymbols
, sh
.value
,
2204 psymtab_language
, objfile
);
2206 cur_sdx
++; /* Go to next file symbol */
2209 /* Now do enter the external symbols. */
2210 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2211 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2212 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2213 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2214 for (; --cur_sdx
>= 0; ext_ptr
++)
2216 register struct partial_symbol
*psym
;
2217 enum address_class
class;
2221 if (ext_ptr
->ifd
!= f_idx
)
2223 psh
= &ext_ptr
->asym
;
2233 complain (&unknown_ext_complaint
,
2234 ecoff_data (cur_bfd
)->ssext
+ psh
->iss
);
2235 /* Fall through, pretend it's global. */
2240 name
= ecoff_data (cur_bfd
)->ssext
+ psh
->iss
;
2241 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2242 VAR_NAMESPACE
, class,
2243 objfile
->global_psymbols
, (CORE_ADDR
) psh
->value
,
2244 psymtab_language
, objfile
);
2248 end_psymtab (save_pst
, psymtab_include_list
, includes_used
,
2249 -1, save_pst
->texthigh
,
2250 dependency_list
, dependencies_used
);
2251 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2252 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2254 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2255 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2259 /* Now scan the FDRs for dependencies */
2260 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2263 fh
= f_idx
+ ecoff_data (cur_bfd
)->fdr
;
2264 pst
= fdr_to_pst
[f_idx
].pst
;
2266 /* This should catch stabs-in-ecoff. */
2271 { /* If there are no functions defined here ... */
2272 /* ...then presumably a .h file: drop reverse depends .h->.c */
2273 for (; s_id0
< fh
->crfd
; s_id0
++)
2277 ecoff_swap_rfd_in (cur_bfd
,
2278 (ecoff_data (cur_bfd
)->external_rfd
2284 s_id0
++; /* Skip self-dependency */
2289 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2291 ((struct partial_symtab
**)
2292 obstack_alloc (&objfile
->psymbol_obstack
,
2293 (pst
->number_of_dependencies
2294 * sizeof (struct partial_symtab
*))));
2295 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++)
2299 ecoff_swap_rfd_in (cur_bfd
,
2300 (ecoff_data (cur_bfd
)->external_rfd
2304 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2305 complain (&bad_file_number_complaint
, rh
);
2307 pst
->dependencies
[s_idx
- s_id0
] = fdr_to_pst
[rh
].pst
;
2310 do_cleanups (old_chain
);
2315 /* Do the initial analisys of the F_IDX-th file descriptor.
2316 Allocates a partial symtab for it, and builds the list
2317 of dependent files by recursion. LEV says at which level
2318 of recursion we are called (to pretty up debug traces) */
2320 static struct partial_symtab
*
2321 parse_fdr (f_idx
, lev
, objfile
)
2324 struct objfile
*objfile
;
2327 register struct partial_symtab
*pst
;
2330 fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
2332 /* Use this to indicate into which symtab this file was parsed */
2334 return (struct partial_symtab
*) fh
->ioptBase
;
2336 /* Debuggability level */
2337 if (compare_glevel (max_glevel
, fh
->glevel
) < 0)
2338 max_glevel
= fh
->glevel
;
2340 /* Make a new partial_symtab */
2341 pst
= new_psymtab (fdr_name (fh
), objfile
);
2349 pst
->textlow
= fh
->adr
;
2350 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
2353 /* Make everything point to everything. */
2354 FDR_IDX (pst
) = f_idx
;
2355 fdr_to_pst
[f_idx
].pst
= pst
;
2356 fh
->ioptBase
= (int) pst
;
2358 /* Analyze its dependencies */
2364 { /* If there are no functions defined here ... */
2365 /* ...then presumably a .h file: drop reverse depends .h->.c */
2366 for (; s_id0
< fh
->crfd
; s_id0
++)
2370 ecoff_swap_rfd_in (cur_bfd
,
2371 (ecoff_data (cur_bfd
)->external_rfd
2377 s_id0
++; /* Skip self-dependency */
2382 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
2383 pst
->dependencies
= ((struct partial_symtab
**)
2384 obstack_alloc (&objfile
->psymbol_obstack
,
2385 (pst
->number_of_dependencies
2386 * sizeof (struct partial_symtab
*))));
2387 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++)
2391 ecoff_swap_rfd_in (cur_bfd
,
2392 (ecoff_data (cur_bfd
)->external_rfd
2396 pst
->dependencies
[s_idx
- s_id0
] = parse_fdr (rh
, lev
+ 1, objfile
);
2405 mips_next_symbol_text ()
2410 ecoff_swap_sym_in (cur_bfd
,
2411 (ecoff_data (cur_bfd
)->external_sym
2415 return ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2418 /* Ancillary function to psymtab_to_symtab(). Does all the work
2419 for turning the partial symtab PST into a symtab, recurring
2420 first on all dependent psymtabs. The argument FILENAME is
2421 only passed so we can see in debug stack traces what file
2424 This function has a split personality, based on whether the
2425 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2426 The flow of control and even the memory allocation differs. FIXME. */
2429 psymtab_to_symtab_1 (pst
, filename
)
2430 struct partial_symtab
*pst
;
2436 struct linetable
*lines
;
2442 /* Read in all partial symbtabs on which this one is dependent.
2443 NOTE that we do have circular dependencies, sigh. We solved
2444 that by setting pst->readin before this point. */
2446 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2447 if (!pst
->dependencies
[i
]->readin
)
2449 /* Inform about additional files to be read in. */
2452 fputs_filtered (" ", stdout
);
2454 fputs_filtered ("and ", stdout
);
2456 printf_filtered ("%s...",
2457 pst
->dependencies
[i
]->filename
);
2458 wrap_here (""); /* Flush output */
2461 /* We only pass the filename for debug purposes */
2462 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2463 pst
->dependencies
[i
]->filename
);
2466 /* Do nothing if this is a dummy psymtab. */
2468 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2469 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2472 /* Now read the symbols for this symtab */
2474 cur_bfd
= CUR_BFD (pst
);
2475 current_objfile
= pst
->objfile
;
2476 cur_fd
= FDR_IDX (pst
);
2477 fh
= (cur_fd
== -1) ? (FDR
*) NULL
: ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
2480 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2481 processing_gcc_compilation
= 0;
2482 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2486 ecoff_swap_sym_in (cur_bfd
,
2487 (ecoff_data (cur_bfd
)->external_sym
2491 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2494 /* We indicate that this is a GCC compilation so that certain
2495 features will be enabled in stabsread/dbxread. */
2496 processing_gcc_compilation
= 2;
2500 if (processing_gcc_compilation
!= 0)
2502 struct pdr_ext
*pdr_ptr
;
2503 struct pdr_ext
*pdr_end
;
2505 unsigned long first_off
;
2507 /* This symbol table contains stabs-in-ecoff entries. */
2509 /* Parse local symbols first */
2511 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2513 current_objfile
= NULL
;
2516 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2522 ecoff_swap_sym_in (cur_bfd
,
2523 (ecoff_data (cur_bfd
)->external_sym
2527 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2529 if (MIPS_IS_STAB (&sh
))
2531 int type_code
= MIPS_UNMARK_STAB (sh
.index
);
2532 process_one_symbol (type_code
, 0, valu
, name
,
2533 pst
->section_offsets
, pst
->objfile
);
2534 if (type_code
== N_FUN
)
2536 /* Make up special symbol to contain
2537 procedure specific info */
2538 struct mips_extra_func_info
*e
=
2539 ((struct mips_extra_func_info
*)
2540 obstack_alloc (¤t_objfile
->symbol_obstack
,
2541 sizeof (struct mips_extra_func_info
)));
2542 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2543 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2544 SYMBOL_CLASS (s
) = LOC_CONST
;
2545 SYMBOL_TYPE (s
) = builtin_type_void
;
2546 SYMBOL_VALUE (s
) = (int) e
;
2547 add_symbol_to_list (s
, &local_symbols
);
2550 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2552 /* Handle encoded stab line number. */
2553 record_line (current_subfile
, sh
.index
, valu
);
2555 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2556 /* These are generated by gcc-2.x, do not complain */
2559 complain (&stab_unknown_complaint
, name
);
2561 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2564 /* Sort the symbol table now, we are done adding symbols to it.
2565 We must do this before parse_procedure calls lookup_symbol. */
2566 sort_symtab_syms (st
);
2568 /* This may not be necessary for stabs symtabs. FIXME. */
2571 /* Fill in procedure info next. */
2573 pdr_ptr
= ecoff_data (cur_bfd
)->external_pdr
+ fh
->ipdFirst
;
2574 pdr_end
= pdr_ptr
+ fh
->cpd
;
2575 for (; pdr_ptr
< pdr_end
; pdr_ptr
++)
2579 ecoff_swap_pdr_in (cur_bfd
, pdr_ptr
, &pr
);
2585 parse_procedure (&pr
, st
, first_off
);
2590 /* This symbol table contains ordinary ecoff entries. */
2592 /* FIXME: doesn't use pst->section_offsets. */
2598 /* How many symbols will we need */
2599 /* FIXME, this does not count enum values. */
2600 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2604 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2608 f_max
+= fh
->csym
+ fh
->cpd
;
2609 maxlines
= 2 * fh
->cline
;
2610 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2613 lines
= LINETABLE (st
);
2614 pending_list
= PST_PRIVATE (pst
)->pending_list
;
2615 if (pending_list
== 0)
2617 pending_list
= ((struct mips_pending
**)
2618 xzalloc (ecoff_data (cur_bfd
)->symbolic_header
.ifdMax
2619 * sizeof (struct mips_pending
*)));
2620 PST_PRIVATE (pst
)->pending_list
= pending_list
;
2623 /* Get a new lexical context */
2625 push_parse_stack ();
2626 top_stack
->cur_st
= st
;
2627 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2629 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2630 BLOCK_END (top_stack
->cur_block
) = 0;
2631 top_stack
->blocktype
= stFile
;
2632 top_stack
->maxsyms
= 2 * f_max
;
2633 top_stack
->cur_type
= 0;
2634 top_stack
->procadr
= 0;
2635 top_stack
->numargs
= 0;
2639 struct sym_ext
*sym_ptr
;
2640 struct sym_ext
*sym_end
;
2642 /* Parse local symbols first */
2643 sym_ptr
= ecoff_data (cur_bfd
)->external_sym
+ fh
->isymBase
;
2644 sym_end
= sym_ptr
+ fh
->csym
;
2645 while (sym_ptr
< sym_end
)
2650 ecoff_swap_sym_in (cur_bfd
, sym_ptr
, &sh
);
2651 c
= parse_symbol (&sh
,
2652 (ecoff_data (cur_bfd
)->external_aux
2654 sym_ptr
, fh
->fBigendian
);
2655 /* FIXME: We must swap the modified symbol back out,
2656 although we would rather not. See parse_symbol. */
2657 ecoff_swap_sym_out (cur_bfd
, &sh
, sym_ptr
);
2661 /* Linenumbers. At the end, check if we can save memory.
2662 parse_lines has to look ahead an arbitrary number of PDR
2663 structures, so we swap them all first. */
2667 struct cleanup
*old_chain
;
2668 struct pdr_ext
*pdr_ptr
;
2669 struct pdr_ext
*pdr_end
;
2673 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2675 old_chain
= make_cleanup (free
, pr_block
);
2677 pdr_ptr
= ecoff_data (cur_bfd
)->external_pdr
+ fh
->ipdFirst
;
2678 pdr_end
= pdr_ptr
+ fh
->cpd
;
2680 for (; pdr_ptr
< pdr_end
; pdr_ptr
++, pdr_in
++)
2681 ecoff_swap_pdr_in (cur_bfd
, pdr_ptr
, pdr_in
);
2683 parse_lines (fh
, pr_block
, lines
);
2684 if (lines
->nitems
< fh
->cline
)
2685 lines
= shrink_linetable (lines
);
2687 /* Fill in procedure info next. */
2689 pdr_in_end
= pdr_in
+ fh
->cpd
;
2690 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2691 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2693 do_cleanups (old_chain
);
2697 LINETABLE (st
) = lines
;
2699 /* .. and our share of externals.
2700 XXX use the global list to speed up things here. how?
2701 FIXME, Maybe quit once we have found the right number of ext's? */
2702 top_stack
->cur_st
= st
;
2703 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2705 top_stack
->blocktype
= stFile
;
2706 top_stack
->maxsyms
= (ecoff_data (cur_bfd
)->symbolic_header
.isymMax
2707 + ecoff_data (cur_bfd
)->symbolic_header
.ipdMax
2708 + ecoff_data (cur_bfd
)->symbolic_header
.iextMax
);
2710 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2711 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2712 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2714 /* If there are undefined, tell the user */
2715 if (n_undef_symbols
)
2717 printf_filtered ("File %s contains %d unresolved references:",
2718 st
->filename
, n_undef_symbols
);
2719 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2720 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2721 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2726 /* Sort the symbol table now, we are done adding symbols to it.*/
2727 sort_symtab_syms (st
);
2732 /* Now link the psymtab and the symtab. */
2735 current_objfile
= NULL
;
2738 /* Ancillary parsing procedures. */
2740 /* Lookup the type at relative index RN. Return it in TPP
2741 if found and in any event come up with its name PNAME.
2742 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2743 Return value says how many aux symbols we ate. */
2746 cross_ref (ax
, tpp
, type_code
, pname
, bigend
)
2749 enum type_code type_code
; /* Use to alloc new type if none is found. */
2757 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2759 /* Escape index means 'the next one' */
2760 if (rn
->rfd
== 0xfff)
2763 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2773 *pname
= "<undefined>";
2778 * Find the relative file descriptor and the symbol in it
2780 FDR
*fh
= get_rfd (cur_fd
, rf
);
2781 struct sym_ext
*esh
;
2785 /* If we have processed this symbol then we left a forwarding
2786 pointer to the corresponding GDB symbol. If not, we`ll put
2787 it in a list of pending symbols, to be processed later when
2788 the file will be. In any event, we collect the name for the
2789 type here. Which is why we made a first pass at strings. */
2791 esh
= ecoff_data (cur_bfd
)->external_sym
+ fh
->isymBase
+ rn
->index
;
2792 ecoff_swap_sym_in (cur_bfd
, esh
, &sh
);
2794 /* Careful, we might be looking at .o files */
2796 *pname
= "<undefined>";
2797 else if (rn
->rfd
== 0xfff && rn
->index
== 0)
2798 /* For structs, unions and enums, rn->rfd is 0xfff and the index
2799 is a relative symbol number for the type, but an index of 0
2800 seems to mean that we don't know. This is said to fix a problem
2801 with "info func opendir" on an SGI showing
2802 "struct BSDopendir.c *BSDopendir();". */
2803 *pname
= "<unknown>";
2805 *pname
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2807 /* Have we parsed it ? */
2808 if (sh
.value
!= 0 && sh
.st
== stParsed
)
2810 t
= (struct type
*) sh
.value
;
2815 /* Avoid duplicates */
2816 struct mips_pending
*p
= is_pending_symbol (fh
, esh
);
2821 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
2822 (struct objfile
*) NULL
);
2823 add_pending (fh
, esh
, *tpp
);
2828 /* We used one auxent normally, two if we got a "next one" rf. */
2833 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2834 keeping the symtab sorted */
2836 static struct symbol
*
2837 mylookup_symbol (name
, block
, namespace, class)
2839 register struct block
*block
;
2840 enum namespace namespace;
2841 enum address_class
class;
2843 register int bot
, top
, inc
;
2844 register struct symbol
*sym
;
2847 top
= BLOCK_NSYMS (block
);
2851 sym
= BLOCK_SYM (block
, bot
);
2852 if (SYMBOL_NAME (sym
)[0] == inc
2853 && SYMBOL_NAMESPACE (sym
) == namespace
2854 && SYMBOL_CLASS (sym
) == class
2855 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
2859 block
= BLOCK_SUPERBLOCK (block
);
2861 return mylookup_symbol (name
, block
, namespace, class);
2866 /* Add a new symbol S to a block B.
2867 Infrequently, we will need to reallocate the block to make it bigger.
2868 We only detect this case when adding to top_stack->cur_block, since
2869 that's the only time we know how big the block is. FIXME. */
2876 int nsyms
= BLOCK_NSYMS (b
)++;
2877 struct block
*origb
;
2878 struct parse_stack
*stackp
;
2880 if (b
== top_stack
->cur_block
&&
2881 nsyms
>= top_stack
->maxsyms
)
2883 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
2884 /* In this case shrink_block is actually grow_block, since
2885 BLOCK_NSYMS(b) is larger than its current size. */
2887 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2889 /* Now run through the stack replacing pointers to the
2890 original block. shrink_block has already done this
2891 for the blockvector and BLOCK_FUNCTION. */
2892 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
2894 if (stackp
->cur_block
== origb
)
2896 stackp
->cur_block
= b
;
2897 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2901 BLOCK_SYM (b
, nsyms
) = s
;
2904 /* Add a new block B to a symtab S */
2911 struct blockvector
*bv
= BLOCKVECTOR (s
);
2913 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
2914 (sizeof (struct blockvector
)
2915 + BLOCKVECTOR_NBLOCKS (bv
)
2916 * sizeof (bv
->block
)));
2917 if (bv
!= BLOCKVECTOR (s
))
2918 BLOCKVECTOR (s
) = bv
;
2920 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
2923 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2924 MIPS' linenumber encoding might need more than one byte
2925 to describe it, LAST is used to detect these continuation lines.
2927 Combining lines with the same line number seems like a bad idea.
2928 E.g: There could be a line number entry with the same line number after the
2929 prologue and GDB should not ignore it (this is a better way to find
2930 a prologue than mips_skip_prologue).
2931 But due to the compressed line table format there are line number entries
2932 for the same line which are needed to bridge the gap to the next
2933 line number entry. These entries have a bogus address info with them
2934 and we are unable to tell them from intended duplicate line number
2936 This is another reason why -ggdb debugging format is preferable. */
2939 add_line (lt
, lineno
, adr
, last
)
2940 struct linetable
*lt
;
2946 last
= -2; /* make sure we record first line */
2948 if (last
== lineno
) /* skip continuation lines */
2951 lt
->item
[lt
->nitems
].line
= lineno
;
2952 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2956 /* Sorting and reordering procedures */
2958 /* Blocks with a smaller low bound should come first */
2961 compare_blocks (arg1
, arg2
)
2962 const void *arg1
, *arg2
;
2964 register int addr_diff
;
2965 struct block
**b1
= (struct block
**) arg1
;
2966 struct block
**b2
= (struct block
**) arg2
;
2968 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
2970 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
2974 /* Sort the blocks of a symtab S.
2975 Reorder the blocks in the blockvector by code-address,
2976 as required by some MI search routines */
2982 struct blockvector
*bv
= BLOCKVECTOR (s
);
2984 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
2987 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
2988 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
2989 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
2990 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
2994 * This is very unfortunate: normally all functions are compiled in
2995 * the order they are found, but if the file is compiled -O3 things
2996 * are very different. It would be nice to find a reliable test
2997 * to detect -O3 images in advance.
2999 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3000 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3001 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3002 sizeof (struct block
*),
3006 register CORE_ADDR high
= 0;
3007 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3009 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3010 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3011 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3012 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3015 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3016 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3018 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3019 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3020 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3021 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3025 /* Constructor/restructor/destructor procedures */
3027 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3028 MAXSYMS and linenumbers MAXLINES we'll put in it */
3030 static struct symtab
*
3031 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3035 struct objfile
*objfile
;
3037 struct symtab
*s
= allocate_symtab (name
, objfile
);
3039 LINETABLE (s
) = new_linetable (maxlines
);
3041 /* All symtabs must have at least two blocks */
3042 BLOCKVECTOR (s
) = new_bvect (2);
3043 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3044 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3045 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3046 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3048 s
->free_code
= free_linetable
;
3053 /* Allocate a new partial_symtab NAME */
3055 static struct partial_symtab
*
3056 new_psymtab (name
, objfile
)
3058 struct objfile
*objfile
;
3060 struct partial_symtab
*psymtab
;
3062 psymtab
= allocate_psymtab (name
, objfile
);
3064 /* Keep a backpointer to the file's symbols */
3066 psymtab
->read_symtab_private
= ((char *)
3067 obstack_alloc (&objfile
->psymbol_obstack
,
3068 sizeof (struct symloc
)));
3069 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3070 CUR_BFD (psymtab
) = cur_bfd
;
3072 /* The way to turn this into a symtab is to call... */
3073 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
3078 /* Allocate a linetable array of the given SIZE. Since the struct
3079 already includes one item, we subtract one when calculating the
3080 proper size to allocate. */
3082 static struct linetable
*
3083 new_linetable (size
)
3086 struct linetable
*l
;
3088 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3089 l
= (struct linetable
*) xmalloc (size
);
3094 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3095 I am not so sure about the 3.4 ones.
3097 Since the struct linetable already includes one item, we subtract one when
3098 calculating the proper size to allocate. */
3100 static struct linetable
*
3101 shrink_linetable (lt
)
3102 struct linetable
*lt
;
3105 return (struct linetable
*) xrealloc ((PTR
) lt
,
3106 (sizeof (struct linetable
)
3108 * sizeof (lt
->item
))));
3111 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3113 static struct blockvector
*
3117 struct blockvector
*bv
;
3120 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3121 bv
= (struct blockvector
*) xzalloc (size
);
3123 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3128 /* Allocate and zero a new block of MAXSYMS symbols */
3130 static struct block
*
3134 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3136 return (struct block
*) xzalloc (size
);
3139 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3140 Shrink_block can also be used by add_symbol to grow a block. */
3142 static struct block
*
3148 struct blockvector
*bv
= BLOCKVECTOR (s
);
3151 /* Just reallocate it and fix references to the old one */
3153 new = (struct block
*) xrealloc ((PTR
) b
,
3154 (sizeof (struct block
)
3155 + ((BLOCK_NSYMS (b
) - 1)
3156 * sizeof (struct symbol
*))));
3158 /* Should chase pointers to old one. Fortunately, that`s just
3159 the block`s function and inferior blocks */
3160 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3161 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3162 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3163 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3164 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3165 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3166 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3170 /* Create a new symbol with printname NAME */
3172 static struct symbol
*
3176 struct symbol
*s
= ((struct symbol
*)
3177 obstack_alloc (¤t_objfile
->symbol_obstack
,
3178 sizeof (struct symbol
)));
3180 memset ((PTR
) s
, 0, sizeof (*s
));
3181 SYMBOL_NAME (s
) = name
;
3185 /* Create a new type with printname NAME */
3187 static struct type
*
3193 t
= alloc_type (current_objfile
);
3194 TYPE_NAME (t
) = name
;
3195 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3200 /* Things used for calling functions in the inferior.
3201 These functions are exported to our companion
3202 mips-tdep.c file and are here because they play
3203 with the symbol-table explicitly. */
3205 /* Sigtramp: make sure we have all the necessary information
3206 about the signal trampoline code. Since the official code
3207 from MIPS does not do so, we make up that information ourselves.
3208 If they fix the library (unlikely) this code will neutralize itself. */
3215 struct block
*b
, *b0
;
3217 sigtramp_address
= -1;
3219 /* We have to handle the following cases here:
3220 a) The Mips library has a sigtramp label within sigvec.
3221 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3222 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3225 b0
= SYMBOL_BLOCK_VALUE (s
);
3226 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3230 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3231 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3234 /* But maybe this program uses its own version of sigvec */
3238 /* Did we or MIPSco fix the library ? */
3239 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3241 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3242 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3246 sigtramp_address
= SYMBOL_VALUE (s
);
3247 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3249 /* But what symtab does it live in ? */
3250 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3253 * Ok, there goes the fix: turn it into a procedure, with all the
3254 * needed info. Note we make it a nested procedure of sigvec,
3255 * which is the way the (assembly) code is actually written.
3257 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3258 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3259 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3260 (struct objfile
*) NULL
);
3261 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3263 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3265 SYMBOL_BLOCK_VALUE (s
) = b
;
3266 BLOCK_START (b
) = sigtramp_address
;
3267 BLOCK_END (b
) = sigtramp_end
;
3268 BLOCK_FUNCTION (b
) = s
;
3269 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3273 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3275 struct mips_extra_func_info
*e
=
3276 ((struct mips_extra_func_info
*)
3277 xzalloc (sizeof (struct mips_extra_func_info
)));
3279 e
->numargs
= 0; /* the kernel thinks otherwise */
3280 /* align_longword(sigcontext + SIGFRAME) */
3281 e
->pdr
.frameoffset
= 0x150;
3282 e
->pdr
.framereg
= SP_REGNUM
;
3283 /* read_next_frame_reg provides the true pc at the time of signal */
3284 e
->pdr
.pcreg
= PC_REGNUM
;
3285 e
->pdr
.regmask
= -2;
3286 e
->pdr
.regoffset
= -(41 * sizeof (int));
3287 e
->pdr
.fregmask
= -1;
3288 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3289 e
->pdr
.isym
= (long) s
;
3290 e
->pdr
.adr
= sigtramp_address
;
3292 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3293 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3294 SYMBOL_VALUE (s
) = (int) e
;
3295 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3296 SYMBOL_CLASS (s
) = LOC_CONST
;
3297 SYMBOL_TYPE (s
) = builtin_type_void
;
3298 current_objfile
= NULL
;
3301 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3305 /* Fake up identical offsets for all sections. */
3307 struct section_offsets
*
3308 mipscoff_symfile_offsets (objfile
, addr
)
3309 struct objfile
*objfile
;
3312 struct section_offsets
*section_offsets
;
3315 section_offsets
= ((struct section_offsets
*)
3316 obstack_alloc (&objfile
->psymbol_obstack
,
3317 (sizeof (struct section_offsets
)
3318 + (sizeof (section_offsets
->offsets
)
3319 * (SECT_OFF_MAX
- 1)))));
3321 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3322 ANOFFSET (section_offsets
, i
) = addr
;
3324 return section_offsets
;
3327 /* Initialization */
3329 static struct sym_fns ecoff_sym_fns
=
3331 "ecoff", /* sym_name: name or name prefix of BFD target type */
3332 5, /* sym_namelen: number of significant sym_name chars */
3333 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3334 mipscoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3335 mipscoff_symfile_read
, /* sym_read: read a symbol file into symtab */
3336 mipscoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3337 mipscoff_symfile_offsets
, /* sym_offsets: dummy FIXME til implem sym reloc */
3338 NULL
/* next: pointer to next struct sym_fns */
3343 _initialize_mipsread ()
3345 add_symtab_fns (&ecoff_sym_fns
);
3347 /* Missing basic types */
3349 builtin_type_string
=
3350 init_type (TYPE_CODE_STRING
,
3351 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3353 (struct objfile
*) NULL
);
3354 builtin_type_complex
=
3355 init_type (TYPE_CODE_FLT
,
3356 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3358 (struct objfile
*) NULL
);
3359 builtin_type_double_complex
=
3360 init_type (TYPE_CODE_FLT
,
3361 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3362 0, "double complex",
3363 (struct objfile
*) NULL
);
3364 builtin_type_fixed_dec
=
3365 init_type (TYPE_CODE_INT
,
3366 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3368 (struct objfile
*) NULL
);
3369 builtin_type_float_dec
=
3370 init_type (TYPE_CODE_FLT
,
3371 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3372 0, "floating decimal",
3373 (struct objfile
*) NULL
);