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
;
76 #include <sys/types.h>
79 #include <sys/param.h>
84 #include "gdb-stabs.h"
88 #include "coff/internal.h"
89 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
91 /* FIXME: coff/internal.h and aout/aout64.h both define N_ABS. We
92 want the definition from aout/aout64.h. */
95 #include "libaout.h" /* Private BFD a.out information. */
96 #include "aout/aout64.h"
97 #include "aout/stab_gnu.h" /* STABS information */
99 /* FIXME: libcoff.h and libaout.h both define a couple of macros. We
102 #undef obj_sym_filepos
104 #include "libcoff.h" /* Private BFD COFF information. */
105 #include "libecoff.h" /* Private BFD ECOFF information. */
107 #include "expression.h"
108 #include "language.h" /* Needed inside partial-stab.h */
110 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
111 #ifndef ECOFF_REG_TO_REGNUM
112 #define ECOFF_REG_TO_REGNUM(num) (num)
115 /* Information is passed among various mipsread routines for accessing
116 symbol files. A pointer to this structure is kept in the sym_private
117 field of the objfile struct. */
119 struct ecoff_symfile_info
{
120 struct mips_pending
**pending_list
;
122 #define ECOFF_SYMFILE_INFO(o) ((struct ecoff_symfile_info *)((o)->sym_private))
123 #define ECOFF_PENDING_LIST(o) (ECOFF_SYMFILE_INFO(o)->pending_list)
126 /* Each partial symbol table entry contains a pointer to private data
127 for the read_symtab() function to use when expanding a partial
128 symbol table entry to a full symbol table entry.
130 For mipsread this structure contains the index of the FDR that this
131 psymtab represents and a pointer to the BFD that the psymtab was
134 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
135 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
136 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
142 EXTR
*extern_tab
; /* Pointer to external symbols for this file. */
143 int extern_count
; /* Size of extern_tab. */
144 enum language pst_language
;
147 /* Things we import explicitly from other modules */
149 extern int info_verbose
;
151 /* Various complaints about symbol reading that don't abort the process */
153 struct complaint bad_file_number_complaint
=
154 {"bad file number %d", 0, 0};
156 struct complaint index_complaint
=
157 {"bad aux index at symbol %s", 0, 0};
159 struct complaint aux_index_complaint
=
160 {"bad proc end in aux found from symbol %s", 0, 0};
162 struct complaint block_index_complaint
=
163 {"bad aux index at block symbol %s", 0, 0};
165 struct complaint unknown_ext_complaint
=
166 {"unknown external symbol %s", 0, 0};
168 struct complaint unknown_sym_complaint
=
169 {"unknown local symbol %s", 0, 0};
171 struct complaint unknown_st_complaint
=
172 {"with type %d", 0, 0};
174 struct complaint block_overflow_complaint
=
175 {"block containing %s overfilled", 0, 0};
177 struct complaint basic_type_complaint
=
178 {"cannot map MIPS basic type 0x%x for %s", 0, 0};
180 struct complaint unknown_type_qual_complaint
=
181 {"unknown type qualifier 0x%x", 0, 0};
183 struct complaint array_index_type_complaint
=
184 {"illegal array index type for %s, assuming int", 0, 0};
186 struct complaint bad_tag_guess_complaint
=
187 {"guessed tag type of %s incorrectly", 0, 0};
189 struct complaint block_member_complaint
=
190 {"declaration block contains unhandled symbol type %d", 0, 0};
192 struct complaint stEnd_complaint
=
193 {"stEnd with storage class %d not handled", 0, 0};
195 struct complaint unknown_mips_symtype_complaint
=
196 {"unknown symbol type 0x%x", 0, 0};
198 struct complaint stab_unknown_complaint
=
199 {"unknown stabs symbol %s", 0, 0};
201 struct complaint pdr_for_nonsymbol_complaint
=
202 {"PDR for %s, but no symbol", 0, 0};
204 struct complaint pdr_static_symbol_complaint
=
205 {"can't handle PDR for static proc at 0x%lx", 0, 0};
207 struct complaint bad_setjmp_pdr_complaint
=
208 {"fixing bad setjmp PDR from libc", 0, 0};
210 struct complaint bad_fbitfield_complaint
=
211 {"can't handle TIR fBitfield for %s", 0, 0};
213 struct complaint bad_continued_complaint
=
214 {"illegal TIR continued for %s", 0, 0};
216 struct complaint bad_rfd_entry_complaint
=
217 {"bad rfd entry for %s: file %d, index %d", 0, 0};
219 struct complaint unexpected_type_code_complaint
=
220 {"unexpected type code for %s", 0, 0};
222 struct complaint unable_to_cross_ref_complaint
=
223 {"unable to cross ref btTypedef for %s", 0, 0};
225 struct complaint illegal_forward_tq0_complaint
=
226 {"illegal tq0 in forward typedef for %s", 0, 0};
228 struct complaint illegal_forward_bt_complaint
=
229 {"illegal bt %d in forward typedef for %s", 0, 0};
231 struct complaint bad_linetable_guess_complaint
=
232 {"guessed size of linetable for %s incorrectly", 0, 0};
234 /* Macros and extra defs */
236 /* Puns: hard to find whether -g was used and how */
238 #define MIN_GLEVEL GLEVEL_0
239 #define compare_glevel(a,b) \
240 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
241 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
243 /* Things that really are local to this module */
245 /* Remember what we deduced to be the source language of this psymtab. */
247 static enum language psymtab_language
= language_unknown
;
253 /* Pointer to current file decriptor record, and its index */
258 /* Index of current symbol */
262 /* Note how much "debuggable" this image is. We would like
263 to see at least one FDR with full symbols */
268 /* When examining .o files, report on undefined symbols */
270 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
272 /* Pseudo symbol to use when putting stabs into the symbol table. */
274 static char stabs_symbol
[] = STABS_SYMBOL
;
276 /* Extra builtin types */
278 struct type
*builtin_type_complex
;
279 struct type
*builtin_type_double_complex
;
280 struct type
*builtin_type_fixed_dec
;
281 struct type
*builtin_type_float_dec
;
282 struct type
*builtin_type_string
;
284 /* Forward declarations */
287 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
290 read_the_mips_symtab
PARAMS ((bfd
*));
293 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
296 parse_partial_symbols
PARAMS ((struct objfile
*,
297 struct section_offsets
*));
300 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
301 char **, int, char *));
304 fixup_sigtramp
PARAMS ((void));
306 static struct symbol
*
307 new_symbol
PARAMS ((char *));
310 new_type
PARAMS ((char *));
312 static struct block
*
313 new_block
PARAMS ((int));
315 static struct symtab
*
316 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
318 static struct linetable
*
319 new_linetable
PARAMS ((int));
321 static struct blockvector
*
322 new_bvect
PARAMS ((int));
325 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int));
328 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
330 static struct symbol
*
331 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
332 enum address_class
));
334 static struct block
*
335 shrink_block
PARAMS ((struct block
*, struct symtab
*));
338 xzalloc
PARAMS ((unsigned int));
341 sort_blocks
PARAMS ((struct symtab
*));
344 compare_blocks
PARAMS ((const void *, const void *));
346 static struct partial_symtab
*
347 new_psymtab
PARAMS ((char *, struct objfile
*));
350 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
353 add_block
PARAMS ((struct block
*, struct symtab
*));
356 add_symbol
PARAMS ((struct symbol
*, struct block
*));
359 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
361 static struct linetable
*
362 shrink_linetable
PARAMS ((struct linetable
*));
365 mips_next_symbol_text
PARAMS ((void));
367 /* Things we export to other modules */
369 /* Address bounds for the signal trampoline in inferior, if any */
370 /* FIXME: Nothing really seems to use this. Why is it here? */
372 CORE_ADDR sigtramp_address
, sigtramp_end
;
375 mipscoff_new_init (ignore
)
376 struct objfile
*ignore
;
378 sigtramp_address
= 0;
379 stabsread_new_init ();
380 buildsym_new_init ();
384 mipscoff_symfile_init (objfile
)
385 struct objfile
*objfile
;
387 if (objfile
->sym_private
!= NULL
)
389 mfree (objfile
->md
, objfile
->sym_private
);
391 objfile
->sym_private
= (PTR
)
392 xmmalloc (objfile
->md
, sizeof (struct ecoff_symfile_info
));
396 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
397 struct objfile
*objfile
;
398 struct section_offsets
*section_offsets
;
401 struct cleanup
* back_to
;
403 init_minimal_symbol_collection ();
404 back_to
= make_cleanup (discard_minimal_symbols
, 0);
406 /* Now that the executable file is positioned at symbol table,
407 process it and define symbols accordingly. */
409 read_mips_symtab (objfile
, section_offsets
);
411 /* Install any minimal symbols that have been collected as the current
412 minimal symbols for this objfile. */
414 install_minimal_symbols (objfile
);
416 do_cleanups (back_to
);
419 /* Perform any local cleanups required when we are done with a particular
420 objfile. I.E, we are in the process of discarding all symbol information
421 for an objfile, freeing up all memory held for it, and unlinking the
422 objfile struct from the global list of known objfiles. */
425 mipscoff_symfile_finish (objfile
)
426 struct objfile
*objfile
;
428 if (objfile
->sym_private
!= NULL
)
430 mfree (objfile
->md
, objfile
->sym_private
);
436 /* Allocate zeroed memory */
442 PTR p
= xmalloc (size
);
448 /* Exported procedure: Builds a symtab from the PST partial one.
449 Restores the environment in effect when PST was created, delegates
450 most of the work to an ancillary procedure, and sorts
451 and reorders the symtab list at the end */
454 mipscoff_psymtab_to_symtab (pst
)
455 struct partial_symtab
*pst
;
463 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
467 next_symbol_text_func
= mips_next_symbol_text
;
469 psymtab_to_symtab_1 (pst
, pst
->filename
);
471 /* Match with global symbols. This only needs to be done once,
472 after all of the symtabs and dependencies have been read in. */
473 scan_file_globals (pst
->objfile
);
476 printf_filtered ("done.\n");
479 /* Exported procedure: Is PC in the signal trampoline code */
482 in_sigtramp (pc
, ignore
)
484 char *ignore
; /* function name */
486 if (sigtramp_address
== 0)
488 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
491 /* File-level interface functions */
493 /* Read the symtab information from file ABFD into memory. */
496 read_the_mips_symtab (abfd
)
499 if (ecoff_slurp_symbolic_info (abfd
) == false)
500 error ("Error reading symbol table: %s", bfd_errmsg (bfd_error
));
503 /* Find a file descriptor given its index RF relative to a file CF */
513 fdrs
= ecoff_data (cur_bfd
)->fdr
;
515 /* Object files do not have the RFD table, all refs are absolute */
518 (*ecoff_backend (cur_bfd
)->swap_rfd_in
)
520 ((char *) ecoff_data (cur_bfd
)->external_rfd
521 + (f
->rfdBase
+ rf
) * ecoff_backend (cur_bfd
)->external_rfd_size
),
526 /* Return a safer print NAME for a file descriptor */
533 return "<stripped file>";
536 return ecoff_data (cur_bfd
)->ss
+ f
->issBase
+ f
->rss
;
540 /* Read in and parse the symtab of the file OBJFILE. Symbols from
541 different sections are relocated via the SECTION_OFFSETS. */
544 read_mips_symtab (objfile
, section_offsets
)
545 struct objfile
*objfile
;
546 struct section_offsets
*section_offsets
;
548 cur_bfd
= objfile
->obfd
;
550 read_the_mips_symtab (objfile
->obfd
);
552 parse_partial_symbols (objfile
, section_offsets
);
555 /* Check to make sure file was compiled with -g. If not, warn the
556 user of this limitation. */
557 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
559 if (max_gdbinfo
== 0)
560 printf ("\n%s not compiled with -g, debugging support is limited.\n",
562 printf ("You should compile with -g2 or -g3 for best debugging support.\n");
568 /* Local utilities */
570 /* Map of FDR indexes to partial symtabs */
574 struct partial_symtab
*pst
; /* the psymtab proper */
575 long n_globals
; /* exported globals (external symbols) */
576 long globals_offset
; /* cumulative */
580 /* Utility stack, used to nest procedures and blocks properly.
581 It is a doubly linked list, to avoid too many alloc/free.
582 Since we might need it quite a few times it is NOT deallocated
585 static struct parse_stack
587 struct parse_stack
*next
, *prev
;
588 struct symtab
*cur_st
; /* Current symtab. */
589 struct block
*cur_block
; /* Block in it. */
591 /* What are we parsing. stFile, or stBlock are for files and
592 blocks. stProc or stStaticProc means we have seen the start of a
593 procedure, but not the start of the block within in. When we see
594 the start of that block, we change it to stNil, without pushing a
595 new block, i.e. stNil means both a procedure and a block. */
599 int maxsyms
; /* Max symbols in this block. */
600 struct type
*cur_type
; /* Type we parse fields for. */
601 int cur_field
; /* Field number in cur_type. */
602 CORE_ADDR procadr
; /* Start addres of this procedure */
603 int numargs
; /* Its argument count */
606 *top_stack
; /* Top stack ptr */
609 /* Enter a new lexical context */
614 struct parse_stack
*new;
616 /* Reuse frames if possible */
617 if (top_stack
&& top_stack
->prev
)
618 new = top_stack
->prev
;
620 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
621 /* Initialize new frame with previous content */
624 register struct parse_stack
*prev
= new->prev
;
627 top_stack
->prev
= new;
629 new->next
= top_stack
;
634 /* Exit a lexical context */
642 top_stack
= top_stack
->next
;
646 /* Cross-references might be to things we haven't looked at
647 yet, e.g. type references. To avoid too many type
648 duplications we keep a quick fixup table, an array
649 of lists of references indexed by file descriptor */
653 struct mips_pending
*next
; /* link */
654 char *s
; /* the unswapped symbol */
655 struct type
*t
; /* its partial type descriptor */
659 /* Check whether we already saw symbol SH in file FH */
661 static struct mips_pending
*
662 is_pending_symbol (fh
, sh
)
666 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
667 register struct mips_pending
*p
;
668 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
670 /* Linear search is ok, list is typically no more than 10 deep */
671 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
677 /* Add a new symbol SH of type T */
680 add_pending (fh
, sh
, t
)
685 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
686 struct mips_pending
*p
= is_pending_symbol (fh
, sh
);
688 /* Make sure we do not make duplicates */
691 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
693 p
= ((struct mips_pending
*)
694 obstack_alloc (¤t_objfile
->psymbol_obstack
,
695 sizeof (struct mips_pending
)));
698 p
->next
= pending_list
[f_idx
];
699 pending_list
[f_idx
] = p
;
704 /* Parsing Routines proper. */
706 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
707 For blocks, procedures and types we open a new lexical context.
708 This is basically just a big switch on the symbol's type. Argument
709 AX is the base pointer of aux symbols for this file (fh->iauxBase).
710 EXT_SH points to the unswapped symbol, which is needed for struct,
711 union, etc., types; it is NULL for an EXTR. BIGEND says whether
712 aux symbols are big-endian or little-endian. Return count of
713 SYMR's handled (normally one). */
716 parse_symbol (sh
, ax
, ext_sh
, bigend
)
722 const bfd_size_type external_sym_size
723 = ecoff_backend (cur_bfd
)->external_sym_size
;
724 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
725 ecoff_backend (cur_bfd
)->swap_sym_in
;
729 struct mips_pending
*pend
;
733 enum address_class
class;
735 long svalue
= sh
->value
;
738 if (ext_sh
== (char *) NULL
)
739 name
= ecoff_data (cur_bfd
)->ssext
+ sh
->iss
;
741 name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
->iss
;
748 case stGlobal
: /* external symbol, goes into global block */
750 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
752 s
= new_symbol (name
);
753 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
756 case stStatic
: /* static data, goes into current block. */
758 b
= top_stack
->cur_block
;
759 s
= new_symbol (name
);
760 if (sh
->sc
== scCommon
)
762 /* It is a FORTRAN common block. At least for SGI Fortran the
763 address is not in the symbol; we need to fix it later in
764 scan_file_globals. */
765 int bucket
= hashname (SYMBOL_NAME (s
));
766 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
767 global_sym_chain
[bucket
] = s
;
770 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
773 case stLocal
: /* local variable, goes into current block */
774 if (sh
->sc
== scRegister
)
776 class = LOC_REGISTER
;
777 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
781 b
= top_stack
->cur_block
;
782 s
= new_symbol (name
);
783 SYMBOL_VALUE (s
) = svalue
;
785 data
: /* Common code for symbols describing data */
786 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
787 SYMBOL_CLASS (s
) = class;
790 /* Type could be missing in a number of cases */
791 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
792 sh
->index
== 0xfffff)
793 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
795 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
796 /* Value of a data symbol is its memory address */
799 case stParam
: /* arg to procedure, goes into current block */
801 top_stack
->numargs
++;
803 /* Special GNU C++ name. */
804 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
805 name
= "this"; /* FIXME, not alloc'd in obstack */
806 s
= new_symbol (name
);
808 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
812 /* Pass by value in register. */
813 SYMBOL_CLASS(s
) = LOC_REGPARM
;
814 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
817 /* Pass by reference on stack. */
818 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
821 /* Pass by reference in register. */
822 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
823 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
826 /* Pass by value on stack. */
827 SYMBOL_CLASS(s
) = LOC_ARG
;
830 SYMBOL_VALUE (s
) = svalue
;
831 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
832 add_symbol (s
, top_stack
->cur_block
);
834 /* FIXME: This has not been tested. See dbxread.c */
835 /* Add the type of this parameter to the function/procedure
836 type of this block. */
837 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
841 case stLabel
: /* label, goes into current block */
842 s
= new_symbol (name
);
843 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
844 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
845 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
846 SYMBOL_TYPE (s
) = builtin_type_int
;
847 add_symbol (s
, top_stack
->cur_block
);
850 case stProc
: /* Procedure, usually goes into global block */
851 case stStaticProc
: /* Static procedure, goes into current block */
852 s
= new_symbol (name
);
853 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
854 SYMBOL_CLASS (s
) = LOC_BLOCK
;
855 /* Type of the return value */
856 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
857 t
= builtin_type_int
;
859 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
860 b
= top_stack
->cur_block
;
861 if (sh
->st
== stProc
)
863 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
864 /* The next test should normally be true,
865 but provides a hook for nested functions
866 (which we don't want to make global). */
867 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
868 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
872 /* Make a type for the procedure itself */
874 /* FIXME: This has not been tested yet! See dbxread.c */
875 /* Generate a template for the type of this function. The
876 types of the arguments will be added as we read the symbol
878 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
880 SYMBOL_TYPE (s
) = lookup_function_type (t
);
883 /* Create and enter a new lexical context */
884 b
= new_block (top_stack
->maxsyms
);
885 SYMBOL_BLOCK_VALUE (s
) = b
;
886 BLOCK_FUNCTION (b
) = s
;
887 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
888 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
889 add_block (b
, top_stack
->cur_st
);
891 /* Not if we only have partial info */
892 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
896 top_stack
->cur_block
= b
;
897 top_stack
->blocktype
= sh
->st
;
898 top_stack
->cur_type
= SYMBOL_TYPE (s
);
899 top_stack
->cur_field
= -1;
900 top_stack
->procadr
= sh
->value
;
901 top_stack
->numargs
= 0;
904 /* Beginning of code for structure, union, and enum definitions.
905 They all share a common set of local variables, defined here. */
907 enum type_code type_code
;
913 case stStruct
: /* Start a block defining a struct type */
914 type_code
= TYPE_CODE_STRUCT
;
915 goto structured_common
;
917 case stUnion
: /* Start a block defining a union type */
918 type_code
= TYPE_CODE_UNION
;
919 goto structured_common
;
921 case stEnum
: /* Start a block defining an enum type */
922 type_code
= TYPE_CODE_ENUM
;
923 goto structured_common
;
925 case stBlock
: /* Either a lexical block, or some type */
926 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
927 goto case_stBlock_code
; /* Lexical block */
929 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
931 /* Common code for handling struct, union, enum, and/or as-yet-
932 unknown-type blocks of info about structured data. `type_code'
933 has been set to the proper TYPE_CODE, if we know it. */
936 top_stack
->blocktype
= stBlock
;
938 /* First count the number of fields and the highest value. */
941 for (ext_tsym
= ext_sh
+ external_sym_size
;
943 ext_tsym
+= external_sym_size
)
947 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
955 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
956 /* If the type of the member is Nil (or Void),
957 without qualifiers, assume the tag is an
959 if (tsym
.index
== indexNil
)
960 type_code
= TYPE_CODE_ENUM
;
963 ecoff_swap_tir_in (bigend
,
964 &ax
[tsym
.index
].a_ti
,
966 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
968 type_code
= TYPE_CODE_ENUM
;
971 if (tsym
.value
> max_value
)
972 max_value
= tsym
.value
;
981 /* This is a no-op; is it trying to tell us something
982 we should be checking? */
983 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
987 /* This is something like a struct within a
988 struct. Skip over the fields of the inner
989 struct. The -1 is because the for loop will
990 increment ext_tsym. */
991 ext_tsym
= ((char *) ecoff_data (cur_bfd
)->external_sym
992 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
993 * external_sym_size
));
999 /* mips cc puts out a typedef for struct x if it is not yet
1000 defined when it encounters
1001 struct y { struct x *xp; };
1006 complain (&block_member_complaint
, tsym
.st
);
1011 /* In an stBlock, there is no way to distinguish structs,
1012 unions, and enums at this point. This is a bug in the
1013 original design (that has been fixed with the recent
1014 addition of the stStruct, stUnion, and stEnum symbol
1015 types.) The way you can tell is if/when you see a variable
1016 or field of that type. In that case the variable's type
1017 (in the AUX table) says if the type is struct, union, or
1018 enum, and points back to the stBlock here. So you can
1019 patch the tag kind up later - but only if there actually is
1020 a variable or field of that type.
1022 So until we know for sure, we will guess at this point.
1024 If the first member has index==indexNil or a void type,
1025 assume we have an enumeration.
1026 Otherwise, if there is more than one member, and all
1027 the members have offset 0, assume we have a union.
1028 Otherwise, assume we have a struct.
1030 The heuristic could guess wrong in the case of of an
1031 enumeration with no members or a union with one (or zero)
1032 members, or when all except the last field of a struct have
1033 width zero. These are uncommon and/or illegal situations,
1034 and in any case guessing wrong probably doesn't matter
1037 But if we later do find out we were wrong, we fixup the tag
1038 kind. Members of an enumeration must be handled
1039 differently from struct/union fields, and that is harder to
1040 patch up, but luckily we shouldn't need to. (If there are
1041 any enumeration members, we can tell for sure it's an enum
1044 if (type_code
== TYPE_CODE_UNDEF
)
1045 if (nfields
> 1 && max_value
== 0)
1046 type_code
= TYPE_CODE_UNION
;
1048 type_code
= TYPE_CODE_STRUCT
;
1050 /* Create a new type or use the pending type. */
1051 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1052 if (pend
== (struct mips_pending
*) NULL
)
1054 t
= new_type (NULL
);
1055 add_pending (cur_fdr
, ext_sh
, t
);
1060 /* Alpha cc unnamed structs do not get a tag name. */
1062 TYPE_TAG_NAME (t
) = NULL
;
1064 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1067 TYPE_CODE (t
) = type_code
;
1068 TYPE_LENGTH (t
) = sh
->value
;
1069 TYPE_NFIELDS (t
) = nfields
;
1070 TYPE_FIELDS (t
) = f
= ((struct field
*)
1072 nfields
* sizeof (struct field
)));
1074 if (type_code
== TYPE_CODE_ENUM
)
1076 /* This is a non-empty enum. */
1077 for (ext_tsym
= ext_sh
+ external_sym_size
;
1079 ext_tsym
+= external_sym_size
)
1082 struct symbol
*enum_sym
;
1084 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1086 if (tsym
.st
!= stMember
)
1089 f
->bitpos
= tsym
.value
;
1091 f
->name
= (ecoff_data (cur_bfd
)->ss
1096 enum_sym
= ((struct symbol
*)
1097 obstack_alloc (¤t_objfile
->symbol_obstack
,
1098 sizeof (struct symbol
)));
1099 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1100 SYMBOL_NAME (enum_sym
) = f
->name
;
1101 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1102 SYMBOL_TYPE (enum_sym
) = t
;
1103 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1104 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1105 add_symbol (enum_sym
, top_stack
->cur_block
);
1107 /* Skip the stMembers that we've handled. */
1112 /* make this the current type */
1113 top_stack
->cur_type
= t
;
1114 top_stack
->cur_field
= 0;
1116 /* Do not create a symbol for alpha cc unnamed structs. */
1119 s
= new_symbol (name
);
1120 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1121 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1122 SYMBOL_VALUE (s
) = 0;
1123 SYMBOL_TYPE (s
) = t
;
1125 /* gcc puts out an empty struct for an opaque struct definitions. */
1126 if (TYPE_NFIELDS (t
) == 0)
1128 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1129 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1131 add_symbol (s
, top_stack
->cur_block
);
1134 /* End of local variables shared by struct, union, enum, and
1135 block (as yet unknown struct/union/enum) processing. */
1139 /* beginnning of (code) block. Value of symbol
1140 is the displacement from procedure start */
1141 push_parse_stack ();
1143 /* Do not start a new block if this is the outermost block of a
1144 procedure. This allows the LOC_BLOCK symbol to point to the
1145 block with the local variables, so funcname::var works. */
1146 if (top_stack
->blocktype
== stProc
1147 || top_stack
->blocktype
== stStaticProc
)
1149 top_stack
->blocktype
= stNil
;
1153 top_stack
->blocktype
= stBlock
;
1154 b
= new_block (top_stack
->maxsyms
);
1155 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1156 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1157 top_stack
->cur_block
= b
;
1158 add_block (b
, top_stack
->cur_st
);
1161 case stEnd
: /* end (of anything) */
1162 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1164 /* Finished with type */
1165 top_stack
->cur_type
= 0;
1167 else if (sh
->sc
== scText
&&
1168 (top_stack
->blocktype
== stProc
||
1169 top_stack
->blocktype
== stStaticProc
))
1171 /* Finished with procedure */
1172 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1173 struct mips_extra_func_info
*e
;
1177 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1179 /* Make up special symbol to contain procedure specific info */
1180 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1181 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1182 SYMBOL_CLASS (s
) = LOC_CONST
;
1183 SYMBOL_TYPE (s
) = builtin_type_void
;
1184 e
= ((struct mips_extra_func_info
*)
1185 obstack_alloc (¤t_objfile
->symbol_obstack
,
1186 sizeof (struct mips_extra_func_info
)));
1187 SYMBOL_VALUE (s
) = (long) e
;
1188 e
->numargs
= top_stack
->numargs
;
1189 add_symbol (s
, top_stack
->cur_block
);
1191 /* Reallocate symbols, saving memory */
1192 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1194 /* f77 emits proc-level with address bounds==[0,0],
1195 So look for such child blocks, and patch them. */
1196 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1198 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1199 if (BLOCK_SUPERBLOCK (b_bad
) == b
1200 && BLOCK_START (b_bad
) == top_stack
->procadr
1201 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1203 BLOCK_START (b_bad
) = BLOCK_START (b
);
1204 BLOCK_END (b_bad
) = BLOCK_END (b
);
1208 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1210 /* End of (code) block. The value of the symbol is the
1211 displacement from the procedure`s start address of the
1212 end of this block. */
1213 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1214 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1216 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1218 /* End of outermost block. Pop parse stack and ignore. The
1219 following stEnd of stProc will take care of the block. */
1222 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1224 /* End of file. Pop parse stack and ignore. Higher
1225 level code deals with this. */
1229 complain (&stEnd_complaint
, sh
->sc
);
1231 pop_parse_stack (); /* restore previous lexical context */
1234 case stMember
: /* member of struct or union */
1235 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1237 f
->bitpos
= sh
->value
;
1239 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1240 f
->bitsize
= bitsize
;
1243 case stTypedef
: /* type definition */
1244 /* Typedefs for forward declarations and opaque structs from alpha cc
1245 are handled by cross_ref, skip them. */
1249 /* Parse the type or use the pending type. */
1250 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1251 if (pend
== (struct mips_pending
*) NULL
)
1253 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1254 add_pending (cur_fdr
, ext_sh
, t
);
1259 /* mips cc puts out a typedef with the name of the struct for forward
1260 declarations. These should not go into the symbol table and
1261 TYPE_NAME should not be set for them.
1262 They can't be distinguished from an intentional typedef to
1263 the same name however:
1265 struct x { int ix; int jx; };
1269 struct xx {int ixx; int jxx; };
1270 generates a cross referencing stTypedef for x and xx.
1271 The user visible effect of this is that the type of a pointer
1272 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1273 The problem is fixed with alpha cc. */
1275 s
= new_symbol (name
);
1276 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1277 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1278 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1279 SYMBOL_TYPE (s
) = t
;
1280 add_symbol (s
, top_stack
->cur_block
);
1282 /* Incomplete definitions of structs should not get a name. */
1283 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1284 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1285 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1286 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1288 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1289 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1291 /* If we are giving a name to a type such as "pointer to
1292 foo" or "function returning foo", we better not set
1293 the TYPE_NAME. If the program contains "typedef char
1294 *caddr_t;", we don't want all variables of type char
1295 * to print as caddr_t. This is not just a
1296 consequence of GDB's type management; CC and GCC (at
1297 least through version 2.4) both output variables of
1298 either type char * or caddr_t with the type
1299 refering to the stTypedef symbol for caddr_t. If a future
1300 compiler cleans this up it GDB is not ready for it
1301 yet, but if it becomes ready we somehow need to
1302 disable this check (without breaking the PCC/GCC2.4
1307 Fortunately, this check seems not to be necessary
1308 for anything except pointers or functions. */
1311 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1315 case stFile
: /* file name */
1316 push_parse_stack ();
1317 top_stack
->blocktype
= sh
->st
;
1320 /* I`ve never seen these for C */
1322 break; /* register relocation */
1324 break; /* forwarding address */
1326 break; /* constant */
1328 complain (&unknown_mips_symtype_complaint
, sh
->st
);
1335 /* Parse the type information provided in the raw AX entries for
1336 the symbol SH. Return the bitfield size in BS, in case.
1337 We must byte-swap the AX entries before we use them; BIGEND says whether
1338 they are big-endian or little-endian (from fh->fBigendian). */
1340 static struct type
*
1341 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1344 unsigned int aux_index
;
1349 /* Null entries in this map are treated specially */
1350 static struct type
**map_bt
[] =
1352 &builtin_type_void
, /* btNil */
1354 &builtin_type_char
, /* btChar */
1355 &builtin_type_unsigned_char
,/* btUChar */
1356 &builtin_type_short
, /* btShort */
1357 &builtin_type_unsigned_short
, /* btUShort */
1358 &builtin_type_int
, /* btInt */
1359 &builtin_type_unsigned_int
, /* btUInt */
1360 &builtin_type_long
, /* btLong */
1361 &builtin_type_unsigned_long
,/* btULong */
1362 &builtin_type_float
, /* btFloat */
1363 &builtin_type_double
, /* btDouble */
1370 &builtin_type_complex
, /* btComplex */
1371 &builtin_type_double_complex
, /* btDComplex */
1373 &builtin_type_fixed_dec
, /* btFixedDec */
1374 &builtin_type_float_dec
, /* btFloatDec */
1375 &builtin_type_string
, /* btString */
1378 &builtin_type_void
, /* btVoid */
1379 0, /* DEC C++: Pointer to member */
1380 0, /* DEC C++: Virtual function table */
1381 0, /* DEC C++: Class (Record) */
1382 &builtin_type_long
, /* btLong64 */
1383 &builtin_type_unsigned_long
, /* btULong64 */
1384 &builtin_type_long_long
, /* btLongLong64 */
1385 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1386 &builtin_type_unsigned_long
, /* btAdr64 */
1387 &builtin_type_long
, /* btInt64 */
1388 &builtin_type_unsigned_long
, /* btUInt64 */
1392 struct type
*tp
= 0;
1393 enum type_code type_code
= TYPE_CODE_UNDEF
;
1395 /* Handle corrupt aux indices. */
1396 if (aux_index
>= (ecoff_data (cur_bfd
)->fdr
+ fd
)->caux
)
1398 complain (&index_complaint
, sym_name
);
1399 return builtin_type_int
;
1403 /* Use aux as a type information record, map its basic type. */
1404 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1405 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1407 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1408 return builtin_type_int
;
1412 tp
= *map_bt
[t
->bt
];
1417 /* Cannot use builtin types -- build our own */
1421 tp
= lookup_pointer_type (builtin_type_void
);
1424 type_code
= TYPE_CODE_STRUCT
;
1427 type_code
= TYPE_CODE_UNION
;
1430 type_code
= TYPE_CODE_ENUM
;
1433 type_code
= TYPE_CODE_RANGE
;
1436 type_code
= TYPE_CODE_SET
;
1439 /* alpha cc uses this for typedefs. The true type will be
1440 obtained by crossreferencing below. */
1441 type_code
= TYPE_CODE_ERROR
;
1444 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1445 return builtin_type_int
;
1449 /* Move on to next aux */
1454 /* Inhibit core dumps with some cfront generated objects that
1456 if (bs
== (int *)NULL
)
1458 complain (&bad_fbitfield_complaint
, sym_name
);
1459 return builtin_type_int
;
1461 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1465 /* All these types really point to some (common) MIPS type
1466 definition, and only the type-qualifiers fully identify
1467 them. We'll make the same effort at sharing. */
1468 if (t
->bt
== btStruct
||
1472 /* btSet (I think) implies that the name is a tag name, not a typedef
1473 name. This apparently is a MIPS extension for C sets. */
1478 /* Try to cross reference this type, build new type on failure. */
1479 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1480 if (tp
== (struct type
*) NULL
)
1481 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1483 /* Make sure that TYPE_CODE(tp) has an expected type code.
1484 Any type may be returned from cross_ref if file indirect entries
1486 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1487 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1488 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1490 complain (&unexpected_type_code_complaint
, sym_name
);
1495 /* Usually, TYPE_CODE(tp) is already type_code. The main
1496 exception is if we guessed wrong re struct/union/enum.
1497 But for struct vs. union a wrong guess is harmless, so
1498 don't complain(). */
1499 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1500 && type_code
!= TYPE_CODE_ENUM
)
1501 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1502 && type_code
== TYPE_CODE_ENUM
))
1504 complain (&bad_tag_guess_complaint
, sym_name
);
1507 if (TYPE_CODE (tp
) != type_code
)
1509 TYPE_CODE (tp
) = type_code
;
1512 /* Do not set the tag name if it is a compiler generated tag name
1513 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1514 if (name
[0] == '.' || name
[0] == '\0')
1515 TYPE_TAG_NAME (tp
) = NULL
;
1516 else if (TYPE_TAG_NAME (tp
) == NULL
1517 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1518 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1519 ¤t_objfile
->type_obstack
);
1523 /* All these types really point to some (common) MIPS type
1524 definition, and only the type-qualifiers fully identify
1525 them. We'll make the same effort at sharing.
1526 FIXME: btIndirect cannot happen here as it is handled by the
1527 switch t->bt above. And we are not doing any guessing on range types. */
1528 if (t
->bt
== btIndirect
||
1533 /* Try to cross reference this type, build new type on failure. */
1534 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1535 if (tp
== (struct type
*) NULL
)
1536 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1538 /* Make sure that TYPE_CODE(tp) has an expected type code.
1539 Any type may be returned from cross_ref if file indirect entries
1541 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1543 complain (&unexpected_type_code_complaint
, sym_name
);
1547 /* Usually, TYPE_CODE(tp) is already type_code. The main
1548 exception is if we guessed wrong re struct/union/enum. */
1549 if (TYPE_CODE (tp
) != type_code
)
1551 complain (&bad_tag_guess_complaint
, sym_name
);
1552 TYPE_CODE (tp
) = type_code
;
1554 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1555 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1556 ¤t_objfile
->type_obstack
);
1559 if (t
->bt
== btTypedef
)
1563 /* Try to cross reference this type, it should succeed. */
1564 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1565 if (tp
== (struct type
*) NULL
)
1567 complain (&unable_to_cross_ref_complaint
, sym_name
);
1568 tp
= builtin_type_int
;
1572 /* Deal with range types */
1573 if (t
->bt
== btRange
)
1575 TYPE_NFIELDS (tp
) = 2;
1576 TYPE_FIELDS (tp
) = ((struct field
*)
1577 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1578 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1579 ¤t_objfile
->type_obstack
);
1580 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1582 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1583 ¤t_objfile
->type_obstack
);
1584 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1588 /* Parse all the type qualifiers now. If there are more
1589 than 6 the game will continue in the next aux */
1593 #define PARSE_TQ(tq) \
1594 if (t->tq != tqNil) \
1595 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1607 /* mips cc 2.x and gcc never put out continued aux entries. */
1611 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1615 /* Complain for illegal continuations due to corrupt aux entries. */
1617 complain (&bad_continued_complaint
, sym_name
);
1622 /* Make up a complex type from a basic one. Type is passed by
1623 reference in TPP and side-effected as necessary. The type
1624 qualifier TQ says how to handle the aux symbols at AX for
1625 the symbol SX we are currently analyzing. BIGEND says whether
1626 aux symbols are big-endian or little-endian.
1627 Returns the number of aux symbols we parsed. */
1630 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1641 /* Used in array processing */
1652 t
= lookup_pointer_type (*tpp
);
1657 t
= lookup_function_type (*tpp
);
1664 /* Determine and record the domain type (type of index) */
1665 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1671 rf
= AUX_GET_ISYM (bigend
, ax
);
1674 fh
= get_rfd (fd
, rf
);
1676 indx
= parse_type (fd
,
1677 ecoff_data (cur_bfd
)->external_aux
+ fh
->iauxBase
,
1678 id
, (int *) NULL
, bigend
, sym_name
);
1680 /* The bounds type should be an integer type, but might be anything
1681 else due to corrupt aux entries. */
1682 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1684 complain (&array_index_type_complaint
, sym_name
);
1685 indx
= builtin_type_int
;
1688 /* Get the bounds, and create the array type. */
1690 lower
= AUX_GET_DNLOW (bigend
, ax
);
1692 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1694 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1696 range
= create_range_type ((struct type
*) NULL
, indx
,
1699 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1701 /* We used to fill in the supplied array element bitsize
1702 here if the TYPE_LENGTH of the target type was zero.
1703 This happens for a `pointer to an array of anonymous structs',
1704 but in this case the array element bitsize is also zero,
1705 so nothing is gained.
1706 And we used to check the TYPE_LENGTH of the target type against
1707 the supplied array element bitsize.
1708 gcc causes a mismatch for `pointer to array of object',
1709 since the sdb directives it uses do not have a way of
1710 specifying the bitsize, but it does no harm (the
1711 TYPE_LENGTH should be correct) and we should be able to
1712 ignore the erroneous bitsize from the auxiliary entry safely.
1713 dbx seems to ignore it too. */
1719 /* Volatile -- currently ignored */
1723 /* Const -- currently ignored */
1727 complain (&unknown_type_qual_complaint
, tq
);
1733 /* Parse a procedure descriptor record PR. Note that the procedure is
1734 parsed _after_ the local symbols, now we just insert the extra
1735 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1736 already been placed in the procedure's main block. Note also that
1737 images that have been partially stripped (ld -x) have been deprived
1738 of local symbols, and we have to cope with them here. FIRST_OFF is
1739 the offset of the first procedure for this FDR; we adjust the
1740 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1741 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1742 in question, or NULL to use top_stack->cur_block. */
1744 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1747 parse_procedure (pr
, search_symtab
, first_off
)
1749 struct symtab
*search_symtab
;
1750 unsigned long first_off
;
1752 struct symbol
*s
, *i
;
1754 struct mips_extra_func_info
*e
;
1757 /* Simple rule to find files linked "-x" */
1758 if (cur_fdr
->rss
== -1)
1762 /* Static procedure at address pr->adr. Sigh. */
1763 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1771 (*ecoff_backend (cur_bfd
)->swap_ext_in
)
1773 ((char *) ecoff_data (cur_bfd
)->external_ext
1774 + pr
->isym
* ecoff_backend (cur_bfd
)->external_ext_size
),
1776 sh_name
= ecoff_data (cur_bfd
)->ssext
+ she
.asym
.iss
;
1784 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
1786 ((char *) ecoff_data (cur_bfd
)->external_sym
1787 + ((cur_fdr
->isymBase
+ pr
->isym
)
1788 * ecoff_backend (cur_bfd
)->external_sym_size
)),
1790 sh_name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1793 if (search_symtab
!= NULL
)
1796 /* This loses both in the case mentioned (want a static, find a global),
1797 but also if we are looking up a non-mangled name which happens to
1798 match the name of a mangled function. */
1799 /* We have to save the cur_fdr across the call to lookup_symbol.
1800 If the pdr is for a static function and if a global function with
1801 the same name exists, lookup_symbol will eventually read in the symtab
1802 for the global function and clobber cur_fdr. */
1803 FDR
*save_cur_fdr
= cur_fdr
;
1804 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1805 cur_fdr
= save_cur_fdr
;
1809 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1815 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1816 VAR_NAMESPACE
, LOC_BLOCK
);
1820 b
= SYMBOL_BLOCK_VALUE (s
);
1824 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1828 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1829 s
= new_symbol (sh_name
);
1830 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1831 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1832 /* Donno its type, hope int is ok */
1833 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1834 add_symbol (s
, top_stack
->cur_block
);
1835 /* Wont have symbols for this one */
1837 SYMBOL_BLOCK_VALUE (s
) = b
;
1838 BLOCK_FUNCTION (b
) = s
;
1839 BLOCK_START (b
) = pr
->adr
;
1840 /* BOUND used to be the end of procedure's text, but the
1841 argument is no longer passed in. */
1842 BLOCK_END (b
) = bound
;
1843 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1844 add_block (b
, top_stack
->cur_st
);
1848 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1852 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1854 e
->pdr
.isym
= (long) s
;
1855 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1857 /* Correct incorrect setjmp procedure descriptor from the library
1858 to make backtrace through setjmp work. */
1859 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1861 complain (&bad_setjmp_pdr_complaint
, 0);
1862 e
->pdr
.pcreg
= RA_REGNUM
;
1863 e
->pdr
.regmask
= 0x80000000;
1864 e
->pdr
.regoffset
= -4;
1867 /* Fake PC_REGNUM for alpha __sigtramp so that read_next_frame_reg
1868 will use the saved user pc from the sigcontext. */
1869 if (STREQ (sh_name
, "__sigtramp"))
1870 e
->pdr
.pcreg
= PC_REGNUM
;
1874 /* Parse the external symbol ES. Just call parse_symbol() after
1875 making sure we know where the aux are for it. For procedures,
1876 parsing of the PDRs has already provided all the needed
1877 information, we only parse them if SKIP_PROCEDURES is false,
1878 and only if this causes no symbol duplication.
1879 BIGEND says whether aux entries are big-endian or little-endian.
1881 This routine clobbers top_stack->cur_block and ->cur_st. */
1884 parse_external (es
, skip_procedures
, bigend
)
1886 int skip_procedures
;
1891 if (es
->ifd
!= ifdNil
)
1894 cur_fdr
= ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
1895 ax
= ecoff_data (cur_bfd
)->external_aux
+ cur_fdr
->iauxBase
;
1899 cur_fdr
= ecoff_data (cur_bfd
)->fdr
;
1903 /* Reading .o files */
1904 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1907 switch (es
->asym
.st
)
1910 /* These are generated for static symbols in .o files,
1931 /* FIXME: Turn this into a complaint? */
1933 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1935 ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1936 fdr_name (cur_fdr
));
1940 switch (es
->asym
.st
)
1943 /* If we have full symbols we do not need more */
1944 if (skip_procedures
)
1946 if (mylookup_symbol (ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1947 top_stack
->cur_block
,
1948 VAR_NAMESPACE
, LOC_BLOCK
))
1953 /* Note that the case of a symbol with indexNil must be handled
1954 anyways by parse_symbol(). */
1955 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1962 /* Parse the line number info for file descriptor FH into
1963 GDB's linetable LT. MIPS' encoding requires a little bit
1964 of magic to get things out. Note also that MIPS' line
1965 numbers can go back and forth, apparently we can live
1966 with that and do not need to reorder our linetables */
1969 parse_lines (fh
, pr
, lt
, maxlines
)
1972 struct linetable
*lt
;
1975 unsigned char *base
;
1977 int delta
, count
, lineno
= 0;
1978 unsigned long first_off
= pr
->adr
;
1980 if (fh
->cbLine
== 0)
1983 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1985 /* Scan by procedure descriptors */
1987 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1991 unsigned char *halt
;
1993 /* No code for this one */
1994 if (pr
->iline
== ilineNil
||
1995 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1998 /* Determine start and end address of compressed line bytes for
2000 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
2001 if (j
!= (fh
->cpd
- 1))
2002 halt
= base
+ pr
[1].cbLineOffset
;
2004 halt
= base
+ fh
->cbLine
;
2005 base
+= pr
->cbLineOffset
;
2007 adr
= fh
->adr
+ pr
->adr
- first_off
;
2008 l
= adr
>> 2; /* in words */
2009 for (lineno
= pr
->lnLow
; base
< halt
; )
2011 count
= *base
& 0x0f;
2012 delta
= *base
++ >> 4;
2017 delta
= (base
[0] << 8) | base
[1];
2018 if (delta
>= 0x8000)
2022 lineno
+= delta
; /* first delta is 0 */
2024 /* Complain if the line table overflows. Could happen
2025 with corrupt binaries. */
2026 if (lt
->nitems
>= maxlines
)
2028 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2031 k
= add_line (lt
, lineno
, l
, k
);
2037 /* Master parsing procedure for first-pass reading of file symbols
2038 into a partial_symtab. */
2041 parse_partial_symbols (objfile
, section_offsets
)
2042 struct objfile
*objfile
;
2043 struct section_offsets
*section_offsets
;
2045 const struct ecoff_backend_data
* const backend
= ecoff_backend (cur_bfd
);
2046 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
2047 const bfd_size_type external_rfd_size
= backend
->external_rfd_size
;
2048 const bfd_size_type external_ext_size
= backend
->external_ext_size
;
2049 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2050 = backend
->swap_ext_in
;
2051 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2052 = backend
->swap_sym_in
;
2053 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2054 = backend
->swap_rfd_in
;
2056 HDRR
*hdr
= &ecoff_data (cur_bfd
)->symbolic_header
;
2057 /* Running pointers */
2062 register EXTR
*ext_in
;
2065 struct partial_symtab
*pst
;
2067 int past_first_source_file
= 0;
2069 /* List of current psymtab's include files */
2070 char **psymtab_include_list
;
2071 int includes_allocated
;
2074 struct pst_map
*fdr_to_pst
;
2075 /* Index within current psymtab dependency list */
2076 struct partial_symtab
**dependency_list
;
2077 int dependencies_used
, dependencies_allocated
;
2078 struct cleanup
*old_chain
;
2080 enum language prev_language
;
2082 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2083 sizeof (EXTR
) * hdr
->iextMax
);
2085 includes_allocated
= 30;
2087 psymtab_include_list
= (char **) alloca (includes_allocated
*
2089 next_symbol_text_func
= mips_next_symbol_text
;
2091 dependencies_allocated
= 30;
2092 dependencies_used
= 0;
2094 (struct partial_symtab
**) alloca (dependencies_allocated
*
2095 sizeof (struct partial_symtab
*));
2097 last_source_file
= NULL
;
2102 * Only parse the Local and External symbols, and the Relative FDR.
2103 * Fixup enough of the loader symtab to be able to use it.
2104 * Allocate space only for the file's portions we need to
2109 max_glevel
= MIN_GLEVEL
;
2111 /* Allocate the map FDR -> PST.
2112 Minor hack: -O3 images might claim some global data belongs
2113 to FDR -1. We`ll go along with that */
2114 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2115 old_chain
= make_cleanup (free
, fdr_to_pst
);
2118 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2119 fdr_to_pst
[-1].pst
= pst
;
2123 /* Allocate the global pending list. */
2124 ECOFF_PENDING_LIST (objfile
) =
2125 ((struct mips_pending
**)
2126 obstack_alloc (&objfile
->psymbol_obstack
,
2127 hdr
->ifdMax
* sizeof (struct mips_pending
*)));
2128 memset ((PTR
) ECOFF_PENDING_LIST (objfile
), 0,
2129 hdr
->ifdMax
* sizeof (struct mips_pending
*));
2131 /* Pass 0 over external syms: swap them in. */
2132 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2133 make_cleanup (free
, ext_block
);
2135 ext_out
= (char *) ecoff_data (cur_bfd
)->external_ext
;
2136 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2138 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2139 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2141 /* Pass 1 over external syms: Presize and partition the list */
2143 ext_in_end
= ext_in
+ hdr
->iextMax
;
2144 for (; ext_in
< ext_in_end
; ext_in
++)
2145 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2147 /* Pass 1.5 over files: partition out global symbol space */
2149 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2151 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2152 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2153 fdr_to_pst
[f_idx
].n_globals
= 0;
2156 /* Pass 2 over external syms: fill in external symbols */
2158 ext_in_end
= ext_in
+ hdr
->iextMax
;
2159 for (; ext_in
< ext_in_end
; ext_in
++)
2161 enum minimal_symbol_type ms_type
= mst_text
;
2163 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2164 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2166 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2169 name
= ecoff_data (cur_bfd
)->ssext
+ ext_in
->asym
.iss
;
2170 switch (ext_in
->asym
.st
)
2175 ms_type
= mst_file_text
;
2178 if (ext_in
->asym
.sc
== scData
2179 || ext_in
->asym
.sc
== scSData
2180 || ext_in
->asym
.sc
== scRData
)
2186 if (ext_in
->asym
.sc
== scAbs
)
2188 else if (ext_in
->asym
.sc
== scText
)
2190 else if (ext_in
->asym
.sc
== scData
2191 || ext_in
->asym
.sc
== scSData
2192 || ext_in
->asym
.sc
== scRData
)
2198 /* The alpha has the section start addresses in stLocal symbols
2199 whose name starts with a `.'. Skip those but complain for all
2200 other stLocal symbols. */
2205 ms_type
= mst_unknown
;
2206 complain (&unknown_ext_complaint
, name
);
2208 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
);
2211 /* Pass 3 over files, over local syms: fill in static symbols */
2212 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2214 struct partial_symtab
*save_pst
;
2217 cur_fdr
= fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
2221 fdr_to_pst
[f_idx
].pst
= NULL
;
2224 pst
= start_psymtab_common (objfile
, section_offsets
,
2226 fh
->cpd
? fh
->adr
: 0,
2227 objfile
->global_psymbols
.next
,
2228 objfile
->static_psymbols
.next
);
2229 pst
->read_symtab_private
= ((char *)
2230 obstack_alloc (&objfile
->psymbol_obstack
,
2231 sizeof (struct symloc
)));
2232 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2235 FDR_IDX (pst
) = f_idx
;
2236 CUR_BFD (pst
) = cur_bfd
;
2238 /* The way to turn this into a symtab is to call... */
2239 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
2241 /* Set up language for the pst.
2242 The language from the FDR is used if it is unambigious (e.g. cfront
2243 with native cc and g++ will set the language to C).
2244 Otherwise we have to deduce the language from the filename.
2245 Native ecoff has every header file in a separate FDR, so
2246 deduce_language_from_filename will return language_unknown for
2247 a header file, which is not what we want.
2248 But the FDRs for the header files are after the FDR for the source
2249 file, so we can assign the language of the source file to the
2250 following header files. Then we save the language in the private
2251 pst data so that we can reuse it when building symtabs. */
2252 prev_language
= psymtab_language
;
2256 case langCplusplusV2
:
2257 psymtab_language
= language_cplus
;
2260 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2263 if (psymtab_language
== language_unknown
)
2264 psymtab_language
= prev_language
;
2265 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2267 pst
->texthigh
= pst
->textlow
;
2269 /* For stabs-in-ecoff files, the second symbol must be @stab.
2270 This symbol is emitted by mips-tfile to signal that the
2271 current object file uses encapsulated stabs instead of mips
2272 ecoff for local symbols. (It is the second symbol because
2273 the first symbol is the stFile used to signal the start of a
2275 processing_gcc_compilation
= 0;
2278 (*swap_sym_in
) (cur_bfd
,
2279 ((char *) ecoff_data (cur_bfd
)->external_sym
2280 + (fh
->isymBase
+ 1) * external_sym_size
),
2282 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2284 processing_gcc_compilation
= 2;
2287 if (processing_gcc_compilation
!= 0)
2289 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2294 (*swap_sym_in
) (cur_bfd
,
2295 ((char *) ecoff_data (cur_bfd
)->external_sym
2296 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2298 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2299 if (!ECOFF_IS_STAB (&sh
))
2301 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2303 long procaddr
= sh
.value
;
2307 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2308 (ecoff_data (cur_bfd
)->external_aux
2311 (*swap_sym_in
) (cur_bfd
,
2313 ecoff_data (cur_bfd
)->external_sym
)
2314 + ((fh
->isymBase
+ isym
- 1)
2315 * external_sym_size
)),
2319 long high
= procaddr
+ sh
.value
;
2320 if (high
> pst
->texthigh
)
2321 pst
->texthigh
= high
;
2326 #define SET_NAMESTRING() \
2327 namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
2328 #define CUR_SYMBOL_TYPE type_code
2329 #define CUR_SYMBOL_VALUE sh.value
2330 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2332 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2333 #define HANDLE_RBRAC(val) \
2334 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2335 #include "partial-stab.h"
2340 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2343 enum address_class
class;
2345 (*swap_sym_in
) (cur_bfd
,
2346 ((char *) ecoff_data (cur_bfd
)->external_sym
2347 + ((fh
->isymBase
+ cur_sdx
)
2348 * external_sym_size
)),
2351 if (ECOFF_IS_STAB (&sh
))
2357 /* Non absolute static symbols go into the minimal table. */
2358 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2359 || (sh
.index
== indexNil
2360 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2362 /* FIXME, premature? */
2367 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2375 case stStaticProc
: /* Function */
2376 /* I believe this is used only for file-local functions.
2377 The comment in symconst.h ("load time only static procs")
2378 isn't particularly clear on this point. */
2379 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
);
2382 case stProc
: /* Asm labels apparently */
2383 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2384 VAR_NAMESPACE
, LOC_BLOCK
,
2385 objfile
->static_psymbols
, sh
.value
,
2386 psymtab_language
, objfile
);
2387 /* Skip over procedure to next one. */
2388 if (sh
.index
>= hdr
->iauxMax
)
2390 /* Should not happen, but does when cross-compiling
2391 with the MIPS compiler. FIXME -- pull later. */
2392 complain (&index_complaint
, name
);
2393 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2396 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2397 (ecoff_data (cur_bfd
)->external_aux
2400 procaddr
= sh
.value
;
2402 if (new_sdx
<= cur_sdx
)
2404 /* This should not happen either... FIXME. */
2405 complain (&aux_index_complaint
, name
);
2406 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2410 (*swap_sym_in
) (cur_bfd
,
2411 ((char *) ecoff_data (cur_bfd
)->external_sym
2412 + ((fh
->isymBase
+ cur_sdx
- 1)
2413 * external_sym_size
)),
2417 high
= procaddr
+ sh
.value
;
2418 if (high
> pst
->texthigh
)
2419 pst
->texthigh
= high
;
2422 case stStatic
: /* Variable */
2423 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2424 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
);
2426 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
);
2430 case stTypedef
:/* Typedef */
2431 class = LOC_TYPEDEF
;
2434 case stConstant
: /* Constant decl */
2441 case stBlock
: /* { }, str, un, enum*/
2442 if (sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2444 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2445 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2446 objfile
->static_psymbols
,
2448 psymtab_language
, objfile
);
2450 /* Skip over the block */
2452 if (new_sdx
<= cur_sdx
)
2454 /* This happens with the Ultrix kernel. */
2455 complain (&block_index_complaint
, name
);
2456 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2461 case stFile
: /* File headers */
2462 case stLabel
: /* Labels */
2463 case stEnd
: /* Ends of files */
2466 case stLocal
: /* Local variables */
2467 /* Normally these are skipped because we skip over
2468 all blocks we see. However, these can occur
2469 as visible symbols in a .h file that contains code. */
2473 /* Both complaints are valid: one gives symbol name,
2474 the other the offending symbol type. */
2475 complain (&unknown_sym_complaint
, name
);
2476 complain (&unknown_st_complaint
, sh
.st
);
2480 /* Use this gdb symbol */
2481 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2482 VAR_NAMESPACE
, class,
2483 objfile
->static_psymbols
, sh
.value
,
2484 psymtab_language
, objfile
);
2486 cur_sdx
++; /* Go to next file symbol */
2489 /* Now do enter the external symbols. */
2490 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2491 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2492 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2493 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2494 for (; --cur_sdx
>= 0; ext_ptr
++)
2496 enum address_class
class;
2500 if (ext_ptr
->ifd
!= f_idx
)
2502 psh
= &ext_ptr
->asym
;
2504 /* Do not add undefined symbols to the partial symbol table. */
2505 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2511 /* These are generated for static symbols in .o files,
2522 complain (&unknown_ext_complaint
,
2523 ecoff_data (cur_bfd
)->ssext
+ psh
->iss
);
2524 /* Fall through, pretend it's global. */
2529 name
= ecoff_data (cur_bfd
)->ssext
+ psh
->iss
;
2530 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2531 VAR_NAMESPACE
, class,
2532 objfile
->global_psymbols
, (CORE_ADDR
) psh
->value
,
2533 psymtab_language
, objfile
);
2537 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2538 empty and put on the free list. */
2539 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2540 psymtab_include_list
, includes_used
,
2541 -1, save_pst
->texthigh
,
2542 dependency_list
, dependencies_used
);
2543 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2544 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2546 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2547 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2551 /* Now scan the FDRs for dependencies */
2552 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2554 fh
= f_idx
+ ecoff_data (cur_bfd
)->fdr
;
2555 pst
= fdr_to_pst
[f_idx
].pst
;
2557 if (pst
== (struct partial_symtab
*)NULL
)
2560 /* This should catch stabs-in-ecoff. */
2564 /* Skip the first file indirect entry as it is a self dependency
2565 for source files or a reverse .h -> .c dependency for header files. */
2566 pst
->number_of_dependencies
= 0;
2568 ((struct partial_symtab
**)
2569 obstack_alloc (&objfile
->psymbol_obstack
,
2571 * sizeof (struct partial_symtab
*))));
2572 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2576 (*swap_rfd_in
) (cur_bfd
,
2577 ((char *) ecoff_data (cur_bfd
)->external_rfd
2578 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2580 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2582 complain (&bad_file_number_complaint
, rh
);
2586 /* Skip self dependencies of header files. */
2590 /* Do not add to dependeny list if psymtab was empty. */
2591 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2593 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2596 do_cleanups (old_chain
);
2601 mips_next_symbol_text ()
2606 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
2608 ((char *) ecoff_data (cur_bfd
)->external_sym
2609 + ((cur_fdr
->isymBase
+ cur_sdx
)
2610 * ecoff_backend (cur_bfd
)->external_sym_size
)),
2612 return ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2615 /* Ancillary function to psymtab_to_symtab(). Does all the work
2616 for turning the partial symtab PST into a symtab, recurring
2617 first on all dependent psymtabs. The argument FILENAME is
2618 only passed so we can see in debug stack traces what file
2621 This function has a split personality, based on whether the
2622 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2623 The flow of control and even the memory allocation differs. FIXME. */
2626 psymtab_to_symtab_1 (pst
, filename
)
2627 struct partial_symtab
*pst
;
2630 const bfd_size_type external_sym_size
2631 = ecoff_backend (cur_bfd
)->external_sym_size
;
2632 const bfd_size_type external_pdr_size
2633 = ecoff_backend (cur_bfd
)->external_pdr_size
;
2634 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2635 = ecoff_backend (cur_bfd
)->swap_sym_in
;
2636 void (* const swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*))
2637 = ecoff_backend (cur_bfd
)->swap_pdr_in
;
2641 struct linetable
*lines
;
2647 /* Read in all partial symbtabs on which this one is dependent.
2648 NOTE that we do have circular dependencies, sigh. We solved
2649 that by setting pst->readin before this point. */
2651 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2652 if (!pst
->dependencies
[i
]->readin
)
2654 /* Inform about additional files to be read in. */
2657 fputs_filtered (" ", stdout
);
2659 fputs_filtered ("and ", stdout
);
2661 printf_filtered ("%s...",
2662 pst
->dependencies
[i
]->filename
);
2663 wrap_here (""); /* Flush output */
2666 /* We only pass the filename for debug purposes */
2667 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2668 pst
->dependencies
[i
]->filename
);
2671 /* Do nothing if this is a dummy psymtab. */
2673 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2674 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2677 /* Now read the symbols for this symtab */
2679 cur_bfd
= CUR_BFD (pst
);
2680 current_objfile
= pst
->objfile
;
2681 cur_fd
= FDR_IDX (pst
);
2682 fh
= (cur_fd
== -1) ? (FDR
*) NULL
: ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
2685 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2686 processing_gcc_compilation
= 0;
2687 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2691 (*swap_sym_in
) (cur_bfd
,
2692 ((char *) ecoff_data (cur_bfd
)->external_sym
2693 + (fh
->isymBase
+ 1) * external_sym_size
),
2695 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2698 /* We indicate that this is a GCC compilation so that certain
2699 features will be enabled in stabsread/dbxread. */
2700 processing_gcc_compilation
= 2;
2704 if (processing_gcc_compilation
!= 0)
2709 unsigned long first_off
= 0;
2711 /* This symbol table contains stabs-in-ecoff entries. */
2713 /* Parse local symbols first */
2715 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2717 current_objfile
= NULL
;
2720 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2726 (*swap_sym_in
) (cur_bfd
,
2727 ((char *) ecoff_data (cur_bfd
)->external_sym
2728 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2730 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2732 if (ECOFF_IS_STAB (&sh
))
2734 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2735 process_one_symbol (type_code
, 0, valu
, name
,
2736 pst
->section_offsets
, pst
->objfile
);
2737 if (type_code
== N_FUN
)
2739 /* Make up special symbol to contain
2740 procedure specific info */
2741 struct mips_extra_func_info
*e
=
2742 ((struct mips_extra_func_info
*)
2743 obstack_alloc (¤t_objfile
->symbol_obstack
,
2744 sizeof (struct mips_extra_func_info
)));
2745 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2746 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2747 SYMBOL_CLASS (s
) = LOC_CONST
;
2748 SYMBOL_TYPE (s
) = builtin_type_void
;
2749 SYMBOL_VALUE (s
) = (long) e
;
2750 add_symbol_to_list (s
, &local_symbols
);
2753 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2755 /* Handle encoded stab line number. */
2756 record_line (current_subfile
, sh
.index
, valu
);
2758 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2759 /* These are generated by gcc-2.x, do not complain */
2762 complain (&stab_unknown_complaint
, name
);
2764 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2767 /* Sort the symbol table now, we are done adding symbols to it.
2768 We must do this before parse_procedure calls lookup_symbol. */
2769 sort_symtab_syms (st
);
2771 /* This may not be necessary for stabs symtabs. FIXME. */
2774 /* Fill in procedure info next. */
2776 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2777 + fh
->ipdFirst
* external_pdr_size
);
2778 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2779 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2783 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2789 parse_procedure (&pr
, st
, first_off
);
2794 /* This symbol table contains ordinary ecoff entries. */
2796 /* FIXME: doesn't use pst->section_offsets. */
2802 /* How many symbols will we need */
2803 /* FIXME, this does not count enum values. */
2804 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2808 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2812 f_max
+= fh
->csym
+ fh
->cpd
;
2813 maxlines
= 2 * fh
->cline
;
2814 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2816 /* The proper language was already determined when building
2817 the psymtab, use it. */
2818 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2821 psymtab_language
= st
->language
;
2823 lines
= LINETABLE (st
);
2825 /* Get a new lexical context */
2827 push_parse_stack ();
2828 top_stack
->cur_st
= st
;
2829 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2831 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2832 BLOCK_END (top_stack
->cur_block
) = 0;
2833 top_stack
->blocktype
= stFile
;
2834 top_stack
->maxsyms
= 2 * f_max
;
2835 top_stack
->cur_type
= 0;
2836 top_stack
->procadr
= 0;
2837 top_stack
->numargs
= 0;
2844 /* Parse local symbols first */
2845 sym_ptr
= ((char *) ecoff_data (cur_bfd
)->external_sym
2846 + fh
->isymBase
* external_sym_size
);
2847 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2848 while (sym_ptr
< sym_end
)
2853 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2854 c
= parse_symbol (&sh
,
2855 (ecoff_data (cur_bfd
)->external_aux
2857 sym_ptr
, fh
->fBigendian
);
2858 sym_ptr
+= c
* external_sym_size
;
2861 /* Linenumbers. At the end, check if we can save memory.
2862 parse_lines has to look ahead an arbitrary number of PDR
2863 structures, so we swap them all first. */
2867 struct cleanup
*old_chain
;
2873 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2875 old_chain
= make_cleanup (free
, pr_block
);
2877 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2878 + fh
->ipdFirst
* external_pdr_size
);
2879 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2883 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2884 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2886 parse_lines (fh
, pr_block
, lines
, maxlines
);
2887 if (lines
->nitems
< fh
->cline
)
2888 lines
= shrink_linetable (lines
);
2890 /* Fill in procedure info next. */
2892 pdr_in_end
= pdr_in
+ fh
->cpd
;
2893 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2894 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2896 do_cleanups (old_chain
);
2900 LINETABLE (st
) = lines
;
2902 /* .. and our share of externals.
2903 XXX use the global list to speed up things here. how?
2904 FIXME, Maybe quit once we have found the right number of ext's? */
2905 top_stack
->cur_st
= st
;
2906 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2908 top_stack
->blocktype
= stFile
;
2909 top_stack
->maxsyms
= (ecoff_data (cur_bfd
)->symbolic_header
.isymMax
2910 + ecoff_data (cur_bfd
)->symbolic_header
.ipdMax
2911 + ecoff_data (cur_bfd
)->symbolic_header
.iextMax
);
2913 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2914 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2915 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2917 /* If there are undefined symbols, tell the user.
2918 The alpha has an undefined symbol for every symbol that is
2919 from a shared library, so tell the user only if verbose is on. */
2920 if (info_verbose
&& n_undef_symbols
)
2922 printf_filtered ("File %s contains %d unresolved references:",
2923 st
->filename
, n_undef_symbols
);
2924 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2925 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2926 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2931 /* Sort the symbol table now, we are done adding symbols to it.*/
2932 sort_symtab_syms (st
);
2937 /* Now link the psymtab and the symtab. */
2940 current_objfile
= NULL
;
2943 /* Ancillary parsing procedures. */
2945 /* Lookup the type at relative index RN. Return it in TPP
2946 if found and in any event come up with its name PNAME.
2947 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2948 Return value says how many aux symbols we ate. */
2951 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2955 enum type_code type_code
; /* Use to alloc new type if none is found. */
2967 struct mips_pending
*pend
;
2969 *tpp
= (struct type
*)NULL
;
2971 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2973 /* Escape index means 'the next one' */
2974 if (rn
->rfd
== 0xfff)
2977 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2984 /* mips cc uses a rf of -1 for opaque struct definitions.
2985 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2986 resolve them if the struct gets defined in another compilation unit. */
2989 *pname
= "<undefined>";
2990 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2991 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2995 /* mips cc uses an escaped rn->index of 0 for struct return types
2996 of procedures that were compiled without -g. These will always remain
2998 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3000 *pname
= "<undefined>";
3004 /* Find the relative file descriptor and the symbol in it. */
3005 fh
= get_rfd (fd
, rf
);
3006 xref_fd
= fh
- ecoff_data (cur_bfd
)->fdr
;
3008 if (rn
->index
>= fh
->csym
)
3010 /* File indirect entry is corrupt. */
3011 *pname
= "<illegal>";
3012 complain (&bad_rfd_entry_complaint
,
3013 sym_name
, xref_fd
, rn
->index
);
3017 /* If we have processed this symbol then we left a forwarding
3018 pointer to the type in the pending list. If not, we`ll put
3019 it in a list of pending types, to be processed later when
3020 the file will be. In any event, we collect the name for the
3023 esh
= ((char *) ecoff_data (cur_bfd
)->external_sym
3024 + ((fh
->isymBase
+ rn
->index
)
3025 * ecoff_backend (cur_bfd
)->external_sym_size
));
3026 (*ecoff_backend (cur_bfd
)->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3028 /* Make sure that this type of cross reference can be handled. */
3030 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
3031 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3032 && sh
.st
!= stEnum
))
3034 /* File indirect entry is corrupt. */
3035 *pname
= "<illegal>";
3036 complain (&bad_rfd_entry_complaint
,
3037 sym_name
, xref_fd
, rn
->index
);
3041 *pname
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
3043 pend
= is_pending_symbol (fh
, esh
);
3048 /* We have not yet seen this type. */
3050 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
3054 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3056 a) forward declarations of structs/unions/enums which are not
3057 defined in this compilation unit.
3058 For these the type will be void. This is a bad design decision
3059 as cross referencing across compilation units is impossible
3060 due to the missing name.
3061 b) forward declarations of structs/unions/enums which are defined
3062 later in this file or in another file in the same compilation
3063 unit. Simply cross reference those again to get the
3065 The forward references are not entered in the pending list and
3066 in the symbol table. */
3068 ecoff_swap_tir_in (bigend
,
3069 &(ecoff_data (cur_bfd
)->external_aux
3070 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3072 if (tir
.tq0
!= tqNil
)
3073 complain (&illegal_forward_tq0_complaint
, sym_name
);
3077 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3079 *pname
= "<undefined>";
3086 (ecoff_data (cur_bfd
)->external_aux
3087 + fh
->iauxBase
+ sh
.index
+ 1),
3088 tpp
, type_code
, pname
,
3089 fh
->fBigendian
, sym_name
);
3093 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3094 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3100 else if (sh
.st
== stTypedef
)
3102 /* Parse the type for a normal typedef. This might recursively call
3103 cross_ref till we get a non typedef'ed type.
3104 FIXME: This is not correct behaviour, but gdb currently
3105 cannot handle typedefs without type copying. But type copying is
3106 impossible as we might have mutual forward references between
3107 two files and the copied type would not get filled in when
3108 we later parse its definition. */
3109 *tpp
= parse_type (xref_fd
,
3110 ecoff_data (cur_bfd
)->external_aux
+ fh
->iauxBase
,
3114 (ecoff_data (cur_bfd
)->ss
3115 + fh
->issBase
+ sh
.iss
));
3119 /* Cross reference to a struct/union/enum which is defined
3120 in another file in the same compilation unit but that file
3121 has not been parsed yet.
3122 Initialize the type only, it will be filled in when
3123 it's definition is parsed. */
3124 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3126 add_pending (fh
, esh
, *tpp
);
3129 /* We used one auxent normally, two if we got a "next one" rf. */
3134 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3135 keeping the symtab sorted */
3137 static struct symbol
*
3138 mylookup_symbol (name
, block
, namespace, class)
3140 register struct block
*block
;
3141 enum namespace namespace;
3142 enum address_class
class;
3144 register int bot
, top
, inc
;
3145 register struct symbol
*sym
;
3148 top
= BLOCK_NSYMS (block
);
3152 sym
= BLOCK_SYM (block
, bot
);
3153 if (SYMBOL_NAME (sym
)[0] == inc
3154 && SYMBOL_NAMESPACE (sym
) == namespace
3155 && SYMBOL_CLASS (sym
) == class
3156 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3160 block
= BLOCK_SUPERBLOCK (block
);
3162 return mylookup_symbol (name
, block
, namespace, class);
3167 /* Add a new symbol S to a block B.
3168 Infrequently, we will need to reallocate the block to make it bigger.
3169 We only detect this case when adding to top_stack->cur_block, since
3170 that's the only time we know how big the block is. FIXME. */
3177 int nsyms
= BLOCK_NSYMS (b
)++;
3178 struct block
*origb
;
3179 struct parse_stack
*stackp
;
3181 if (b
== top_stack
->cur_block
&&
3182 nsyms
>= top_stack
->maxsyms
)
3184 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3185 /* In this case shrink_block is actually grow_block, since
3186 BLOCK_NSYMS(b) is larger than its current size. */
3188 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3190 /* Now run through the stack replacing pointers to the
3191 original block. shrink_block has already done this
3192 for the blockvector and BLOCK_FUNCTION. */
3193 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3195 if (stackp
->cur_block
== origb
)
3197 stackp
->cur_block
= b
;
3198 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3202 BLOCK_SYM (b
, nsyms
) = s
;
3205 /* Add a new block B to a symtab S */
3212 struct blockvector
*bv
= BLOCKVECTOR (s
);
3214 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3215 (sizeof (struct blockvector
)
3216 + BLOCKVECTOR_NBLOCKS (bv
)
3217 * sizeof (bv
->block
)));
3218 if (bv
!= BLOCKVECTOR (s
))
3219 BLOCKVECTOR (s
) = bv
;
3221 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3224 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3225 MIPS' linenumber encoding might need more than one byte
3226 to describe it, LAST is used to detect these continuation lines.
3228 Combining lines with the same line number seems like a bad idea.
3229 E.g: There could be a line number entry with the same line number after the
3230 prologue and GDB should not ignore it (this is a better way to find
3231 a prologue than mips_skip_prologue).
3232 But due to the compressed line table format there are line number entries
3233 for the same line which are needed to bridge the gap to the next
3234 line number entry. These entries have a bogus address info with them
3235 and we are unable to tell them from intended duplicate line number
3237 This is another reason why -ggdb debugging format is preferable. */
3240 add_line (lt
, lineno
, adr
, last
)
3241 struct linetable
*lt
;
3247 last
= -2; /* make sure we record first line */
3249 if (last
== lineno
) /* skip continuation lines */
3252 lt
->item
[lt
->nitems
].line
= lineno
;
3253 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3257 /* Sorting and reordering procedures */
3259 /* Blocks with a smaller low bound should come first */
3262 compare_blocks (arg1
, arg2
)
3266 register int addr_diff
;
3267 struct block
**b1
= (struct block
**) arg1
;
3268 struct block
**b2
= (struct block
**) arg2
;
3270 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3272 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3276 /* Sort the blocks of a symtab S.
3277 Reorder the blocks in the blockvector by code-address,
3278 as required by some MI search routines */
3284 struct blockvector
*bv
= BLOCKVECTOR (s
);
3286 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3289 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3290 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3291 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3292 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3296 * This is very unfortunate: normally all functions are compiled in
3297 * the order they are found, but if the file is compiled -O3 things
3298 * are very different. It would be nice to find a reliable test
3299 * to detect -O3 images in advance.
3301 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3302 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3303 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3304 sizeof (struct block
*),
3308 register CORE_ADDR high
= 0;
3309 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3311 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3312 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3313 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3314 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3317 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3318 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3320 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3321 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3322 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3323 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3327 /* Constructor/restructor/destructor procedures */
3329 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3330 MAXSYMS and linenumbers MAXLINES we'll put in it */
3332 static struct symtab
*
3333 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3337 struct objfile
*objfile
;
3339 struct symtab
*s
= allocate_symtab (name
, objfile
);
3341 LINETABLE (s
) = new_linetable (maxlines
);
3343 /* All symtabs must have at least two blocks */
3344 BLOCKVECTOR (s
) = new_bvect (2);
3345 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3346 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3347 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3348 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3350 s
->free_code
= free_linetable
;
3355 /* Allocate a new partial_symtab NAME */
3357 static struct partial_symtab
*
3358 new_psymtab (name
, objfile
)
3360 struct objfile
*objfile
;
3362 struct partial_symtab
*psymtab
;
3364 psymtab
= allocate_psymtab (name
, objfile
);
3366 /* Keep a backpointer to the file's symbols */
3368 psymtab
->read_symtab_private
= ((char *)
3369 obstack_alloc (&objfile
->psymbol_obstack
,
3370 sizeof (struct symloc
)));
3371 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3372 CUR_BFD (psymtab
) = cur_bfd
;
3374 /* The way to turn this into a symtab is to call... */
3375 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
3380 /* Allocate a linetable array of the given SIZE. Since the struct
3381 already includes one item, we subtract one when calculating the
3382 proper size to allocate. */
3384 static struct linetable
*
3385 new_linetable (size
)
3388 struct linetable
*l
;
3390 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3391 l
= (struct linetable
*) xmalloc (size
);
3396 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3397 I am not so sure about the 3.4 ones.
3399 Since the struct linetable already includes one item, we subtract one when
3400 calculating the proper size to allocate. */
3402 static struct linetable
*
3403 shrink_linetable (lt
)
3404 struct linetable
*lt
;
3407 return (struct linetable
*) xrealloc ((PTR
) lt
,
3408 (sizeof (struct linetable
)
3410 * sizeof (lt
->item
))));
3413 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3415 static struct blockvector
*
3419 struct blockvector
*bv
;
3422 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3423 bv
= (struct blockvector
*) xzalloc (size
);
3425 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3430 /* Allocate and zero a new block of MAXSYMS symbols */
3432 static struct block
*
3436 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3438 return (struct block
*) xzalloc (size
);
3441 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3442 Shrink_block can also be used by add_symbol to grow a block. */
3444 static struct block
*
3450 struct blockvector
*bv
= BLOCKVECTOR (s
);
3453 /* Just reallocate it and fix references to the old one */
3455 new = (struct block
*) xrealloc ((PTR
) b
,
3456 (sizeof (struct block
)
3457 + ((BLOCK_NSYMS (b
) - 1)
3458 * sizeof (struct symbol
*))));
3460 /* Should chase pointers to old one. Fortunately, that`s just
3461 the block`s function and inferior blocks */
3462 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3463 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3464 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3465 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3466 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3467 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3468 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3472 /* Create a new symbol with printname NAME */
3474 static struct symbol
*
3478 struct symbol
*s
= ((struct symbol
*)
3479 obstack_alloc (¤t_objfile
->symbol_obstack
,
3480 sizeof (struct symbol
)));
3482 memset ((PTR
) s
, 0, sizeof (*s
));
3483 SYMBOL_NAME (s
) = name
;
3484 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3485 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3489 /* Create a new type with printname NAME */
3491 static struct type
*
3497 t
= alloc_type (current_objfile
);
3498 TYPE_NAME (t
) = name
;
3499 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3504 /* Things used for calling functions in the inferior.
3505 These functions are exported to our companion
3506 mips-tdep.c file and are here because they play
3507 with the symbol-table explicitly. */
3509 /* Sigtramp: make sure we have all the necessary information
3510 about the signal trampoline code. Since the official code
3511 from MIPS does not do so, we make up that information ourselves.
3512 If they fix the library (unlikely) this code will neutralize itself. */
3519 struct block
*b
, *b0
= NULL
;
3521 sigtramp_address
= -1;
3523 /* We have to handle the following cases here:
3524 a) The Mips library has a sigtramp label within sigvec.
3525 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3526 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3529 b0
= SYMBOL_BLOCK_VALUE (s
);
3530 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3534 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3535 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3538 /* But maybe this program uses its own version of sigvec */
3542 /* Did we or MIPSco fix the library ? */
3543 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3545 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3546 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3550 sigtramp_address
= SYMBOL_VALUE (s
);
3551 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3553 /* But what symtab does it live in ? */
3554 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3557 * Ok, there goes the fix: turn it into a procedure, with all the
3558 * needed info. Note we make it a nested procedure of sigvec,
3559 * which is the way the (assembly) code is actually written.
3561 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3562 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3563 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3565 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3567 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3569 SYMBOL_BLOCK_VALUE (s
) = b
;
3570 BLOCK_START (b
) = sigtramp_address
;
3571 BLOCK_END (b
) = sigtramp_end
;
3572 BLOCK_FUNCTION (b
) = s
;
3573 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3577 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3579 struct mips_extra_func_info
*e
=
3580 ((struct mips_extra_func_info
*)
3581 xzalloc (sizeof (struct mips_extra_func_info
)));
3583 e
->numargs
= 0; /* the kernel thinks otherwise */
3584 /* align_longword(sigcontext + SIGFRAME) */
3585 e
->pdr
.frameoffset
= 0x150;
3586 e
->pdr
.framereg
= SP_REGNUM
;
3587 /* read_next_frame_reg provides the true pc at the time of signal */
3588 e
->pdr
.pcreg
= PC_REGNUM
;
3589 e
->pdr
.regmask
= -2;
3590 e
->pdr
.regoffset
= -(41 * sizeof (int));
3591 e
->pdr
.fregmask
= -1;
3592 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3593 e
->pdr
.isym
= (long) s
;
3594 e
->pdr
.adr
= sigtramp_address
;
3596 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3597 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3598 SYMBOL_VALUE (s
) = (long) e
;
3599 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3600 SYMBOL_CLASS (s
) = LOC_CONST
;
3601 SYMBOL_TYPE (s
) = builtin_type_void
;
3602 current_objfile
= NULL
;
3605 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3609 /* Fake up identical offsets for all sections. */
3611 struct section_offsets
*
3612 mipscoff_symfile_offsets (objfile
, addr
)
3613 struct objfile
*objfile
;
3616 struct section_offsets
*section_offsets
;
3619 objfile
->num_sections
= SECT_OFF_MAX
;
3620 section_offsets
= ((struct section_offsets
*)
3621 obstack_alloc (&objfile
->psymbol_obstack
,
3622 (sizeof (struct section_offsets
)
3623 + (sizeof (section_offsets
->offsets
)
3624 * (SECT_OFF_MAX
- 1)))));
3626 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3627 ANOFFSET (section_offsets
, i
) = addr
;
3629 return section_offsets
;
3632 /* Initialization */
3634 static struct sym_fns ecoff_sym_fns
=
3636 "ecoff", /* sym_name: name or name prefix of BFD target type */
3637 5, /* sym_namelen: number of significant sym_name chars */
3638 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3639 mipscoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3640 mipscoff_symfile_read
, /* sym_read: read a symbol file into symtab */
3641 mipscoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3642 mipscoff_symfile_offsets
, /* sym_offsets: dummy FIXME til implem sym reloc */
3643 NULL
/* next: pointer to next struct sym_fns */
3648 _initialize_mipsread ()
3650 add_symtab_fns (&ecoff_sym_fns
);
3652 /* Missing basic types */
3654 builtin_type_string
=
3655 init_type (TYPE_CODE_STRING
,
3656 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3658 (struct objfile
*) NULL
);
3659 builtin_type_complex
=
3660 init_type (TYPE_CODE_FLT
,
3661 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3663 (struct objfile
*) NULL
);
3664 builtin_type_double_complex
=
3665 init_type (TYPE_CODE_FLT
,
3666 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3667 0, "double complex",
3668 (struct objfile
*) NULL
);
3669 builtin_type_fixed_dec
=
3670 init_type (TYPE_CODE_INT
,
3671 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3673 (struct objfile
*) NULL
);
3674 builtin_type_float_dec
=
3675 init_type (TYPE_CODE_FLT
,
3676 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3677 0, "floating decimal",
3678 (struct objfile
*) NULL
);