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 array_bitsize_complaint
=
187 {"size of array target type for %s not known, assuming %d bits", 0, 0};
189 struct complaint bad_tag_guess_complaint
=
190 {"guessed tag type of %s incorrectly", 0, 0};
192 struct complaint block_member_complaint
=
193 {"declaration block contains unhandled symbol type %d", 0, 0};
195 struct complaint stEnd_complaint
=
196 {"stEnd with storage class %d not handled", 0, 0};
198 struct complaint unknown_mips_symtype_complaint
=
199 {"unknown symbol type 0x%x", 0, 0};
201 struct complaint stab_unknown_complaint
=
202 {"unknown stabs symbol %s", 0, 0};
204 struct complaint pdr_for_nonsymbol_complaint
=
205 {"PDR for %s, but no symbol", 0, 0};
207 struct complaint pdr_static_symbol_complaint
=
208 {"can't handle PDR for static proc at 0x%lx", 0, 0};
210 struct complaint bad_setjmp_pdr_complaint
=
211 {"fixing bad setjmp PDR from libc", 0, 0};
213 struct complaint bad_fbitfield_complaint
=
214 {"can't handle TIR fBitfield for %s", 0, 0};
216 struct complaint bad_continued_complaint
=
217 {"illegal TIR continued for %s", 0, 0};
219 struct complaint bad_rfd_entry_complaint
=
220 {"bad rfd entry for %s: file %d, index %d", 0, 0};
222 struct complaint unexpected_type_code_complaint
=
223 {"unexpected type code for %s", 0, 0};
225 struct complaint unable_to_cross_ref_complaint
=
226 {"unable to cross ref btTypedef for %s", 0, 0};
228 struct complaint illegal_forward_tq0_complaint
=
229 {"illegal tq0 in forward typedef for %s", 0, 0};
231 struct complaint illegal_forward_bt_complaint
=
232 {"illegal bt %d in forward typedef for %s", 0, 0};
234 struct complaint bad_linetable_guess_complaint
=
235 {"guessed size of linetable for %s incorrectly", 0, 0};
237 /* Macros and extra defs */
239 /* Puns: hard to find whether -g was used and how */
241 #define MIN_GLEVEL GLEVEL_0
242 #define compare_glevel(a,b) \
243 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
244 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
246 /* Things that really are local to this module */
248 /* Remember what we deduced to be the source language of this psymtab. */
250 static enum language psymtab_language
= language_unknown
;
256 /* Pointer to current file decriptor record, and its index */
261 /* Index of current symbol */
265 /* Note how much "debuggable" this image is. We would like
266 to see at least one FDR with full symbols */
271 /* When examining .o files, report on undefined symbols */
273 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
275 /* Pseudo symbol to use when putting stabs into the symbol table. */
277 static char stabs_symbol
[] = STABS_SYMBOL
;
279 /* Extra builtin types */
281 struct type
*builtin_type_complex
;
282 struct type
*builtin_type_double_complex
;
283 struct type
*builtin_type_fixed_dec
;
284 struct type
*builtin_type_float_dec
;
285 struct type
*builtin_type_string
;
287 /* Forward declarations */
290 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
293 read_the_mips_symtab
PARAMS ((bfd
*));
296 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
299 parse_partial_symbols
PARAMS ((struct objfile
*,
300 struct section_offsets
*));
303 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
304 char **, int, char *));
307 fixup_sigtramp
PARAMS ((void));
309 static struct symbol
*
310 new_symbol
PARAMS ((char *));
313 new_type
PARAMS ((char *));
315 static struct block
*
316 new_block
PARAMS ((int));
318 static struct symtab
*
319 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
321 static struct linetable
*
322 new_linetable
PARAMS ((int));
324 static struct blockvector
*
325 new_bvect
PARAMS ((int));
328 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int));
331 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
333 static struct symbol
*
334 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
335 enum address_class
));
337 static struct block
*
338 shrink_block
PARAMS ((struct block
*, struct symtab
*));
341 xzalloc
PARAMS ((unsigned int));
344 sort_blocks
PARAMS ((struct symtab
*));
347 compare_blocks
PARAMS ((const void *, const void *));
349 static struct partial_symtab
*
350 new_psymtab
PARAMS ((char *, struct objfile
*));
353 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
356 add_block
PARAMS ((struct block
*, struct symtab
*));
359 add_symbol
PARAMS ((struct symbol
*, struct block
*));
362 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
364 static struct linetable
*
365 shrink_linetable
PARAMS ((struct linetable
*));
368 mips_next_symbol_text
PARAMS ((void));
370 /* Things we export to other modules */
372 /* Address bounds for the signal trampoline in inferior, if any */
373 /* FIXME: Nothing really seems to use this. Why is it here? */
375 CORE_ADDR sigtramp_address
, sigtramp_end
;
378 mipscoff_new_init (ignore
)
379 struct objfile
*ignore
;
381 sigtramp_address
= 0;
382 stabsread_new_init ();
383 buildsym_new_init ();
387 mipscoff_symfile_init (objfile
)
388 struct objfile
*objfile
;
390 if (objfile
->sym_private
!= NULL
)
392 mfree (objfile
->md
, objfile
->sym_private
);
394 objfile
->sym_private
= (PTR
)
395 xmmalloc (objfile
->md
, sizeof (struct ecoff_symfile_info
));
399 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
400 struct objfile
*objfile
;
401 struct section_offsets
*section_offsets
;
404 struct cleanup
* back_to
;
406 init_minimal_symbol_collection ();
407 back_to
= make_cleanup (discard_minimal_symbols
, 0);
409 /* Now that the executable file is positioned at symbol table,
410 process it and define symbols accordingly. */
412 read_mips_symtab (objfile
, section_offsets
);
414 /* Install any minimal symbols that have been collected as the current
415 minimal symbols for this objfile. */
417 install_minimal_symbols (objfile
);
419 do_cleanups (back_to
);
422 /* Perform any local cleanups required when we are done with a particular
423 objfile. I.E, we are in the process of discarding all symbol information
424 for an objfile, freeing up all memory held for it, and unlinking the
425 objfile struct from the global list of known objfiles. */
428 mipscoff_symfile_finish (objfile
)
429 struct objfile
*objfile
;
431 if (objfile
->sym_private
!= NULL
)
433 mfree (objfile
->md
, objfile
->sym_private
);
439 /* Allocate zeroed memory */
445 PTR p
= xmalloc (size
);
451 /* Exported procedure: Builds a symtab from the PST partial one.
452 Restores the environment in effect when PST was created, delegates
453 most of the work to an ancillary procedure, and sorts
454 and reorders the symtab list at the end */
457 mipscoff_psymtab_to_symtab (pst
)
458 struct partial_symtab
*pst
;
466 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
470 next_symbol_text_func
= mips_next_symbol_text
;
472 psymtab_to_symtab_1 (pst
, pst
->filename
);
474 /* Match with global symbols. This only needs to be done once,
475 after all of the symtabs and dependencies have been read in. */
476 scan_file_globals (pst
->objfile
);
479 printf_filtered ("done.\n");
482 /* Exported procedure: Is PC in the signal trampoline code */
485 in_sigtramp (pc
, ignore
)
487 char *ignore
; /* function name */
489 if (sigtramp_address
== 0)
491 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
494 /* File-level interface functions */
496 /* Read the symtab information from file ABFD into memory. */
499 read_the_mips_symtab (abfd
)
502 if (ecoff_slurp_symbolic_info (abfd
) == false)
503 error ("Error reading symbol table: %s", bfd_errmsg (bfd_error
));
506 /* Find a file descriptor given its index RF relative to a file CF */
516 fdrs
= ecoff_data (cur_bfd
)->fdr
;
518 /* Object files do not have the RFD table, all refs are absolute */
521 (*ecoff_backend (cur_bfd
)->swap_rfd_in
)
523 ((char *) ecoff_data (cur_bfd
)->external_rfd
524 + (f
->rfdBase
+ rf
) * ecoff_backend (cur_bfd
)->external_rfd_size
),
529 /* Return a safer print NAME for a file descriptor */
536 return "<stripped file>";
539 return ecoff_data (cur_bfd
)->ss
+ f
->issBase
+ f
->rss
;
543 /* Read in and parse the symtab of the file OBJFILE. Symbols from
544 different sections are relocated via the SECTION_OFFSETS. */
547 read_mips_symtab (objfile
, section_offsets
)
548 struct objfile
*objfile
;
549 struct section_offsets
*section_offsets
;
551 cur_bfd
= objfile
->obfd
;
553 read_the_mips_symtab (objfile
->obfd
);
555 parse_partial_symbols (objfile
, section_offsets
);
558 /* Check to make sure file was compiled with -g. If not, warn the
559 user of this limitation. */
560 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
562 if (max_gdbinfo
== 0)
563 printf ("\n%s not compiled with -g, debugging support is limited.\n",
565 printf ("You should compile with -g2 or -g3 for best debugging support.\n");
571 /* Local utilities */
573 /* Map of FDR indexes to partial symtabs */
577 struct partial_symtab
*pst
; /* the psymtab proper */
578 long n_globals
; /* exported globals (external symbols) */
579 long globals_offset
; /* cumulative */
583 /* Utility stack, used to nest procedures and blocks properly.
584 It is a doubly linked list, to avoid too many alloc/free.
585 Since we might need it quite a few times it is NOT deallocated
588 static struct parse_stack
590 struct parse_stack
*next
, *prev
;
591 struct symtab
*cur_st
; /* Current symtab. */
592 struct block
*cur_block
; /* Block in it. */
593 int blocktype
; /* What are we parsing. */
594 int maxsyms
; /* Max symbols in this block. */
595 struct type
*cur_type
; /* Type we parse fields for. */
596 int cur_field
; /* Field number in cur_type. */
597 CORE_ADDR procadr
; /* Start addres of this procedure */
598 int numargs
; /* Its argument count */
601 *top_stack
; /* Top stack ptr */
604 /* Enter a new lexical context */
609 struct parse_stack
*new;
611 /* Reuse frames if possible */
612 if (top_stack
&& top_stack
->prev
)
613 new = top_stack
->prev
;
615 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
616 /* Initialize new frame with previous content */
619 register struct parse_stack
*prev
= new->prev
;
622 top_stack
->prev
= new;
624 new->next
= top_stack
;
629 /* Exit a lexical context */
637 top_stack
= top_stack
->next
;
641 /* Cross-references might be to things we haven't looked at
642 yet, e.g. type references. To avoid too many type
643 duplications we keep a quick fixup table, an array
644 of lists of references indexed by file descriptor */
648 struct mips_pending
*next
; /* link */
649 char *s
; /* the unswapped symbol */
650 struct type
*t
; /* its partial type descriptor */
654 /* Check whether we already saw symbol SH in file FH */
656 static struct mips_pending
*
657 is_pending_symbol (fh
, sh
)
661 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
662 register struct mips_pending
*p
;
663 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
665 /* Linear search is ok, list is typically no more than 10 deep */
666 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
672 /* Add a new symbol SH of type T */
675 add_pending (fh
, sh
, t
)
680 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
681 struct mips_pending
*p
= is_pending_symbol (fh
, sh
);
683 /* Make sure we do not make duplicates */
686 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
688 p
= ((struct mips_pending
*)
689 obstack_alloc (¤t_objfile
->psymbol_obstack
,
690 sizeof (struct mips_pending
)));
693 p
->next
= pending_list
[f_idx
];
694 pending_list
[f_idx
] = p
;
699 /* Parsing Routines proper. */
701 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
702 For blocks, procedures and types we open a new lexical context.
703 This is basically just a big switch on the symbol's type. Argument
704 AX is the base pointer of aux symbols for this file (fh->iauxBase).
705 EXT_SH points to the unswapped symbol, which is needed for struct,
706 union, etc., types; it is NULL for an EXTR. BIGEND says whether
707 aux symbols are big-endian or little-endian. Return count of
708 SYMR's handled (normally one). */
711 parse_symbol (sh
, ax
, ext_sh
, bigend
)
717 const bfd_size_type external_sym_size
718 = ecoff_backend (cur_bfd
)->external_sym_size
;
719 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
720 ecoff_backend (cur_bfd
)->swap_sym_in
;
724 struct mips_pending
*pend
;
728 enum address_class
class;
730 long svalue
= sh
->value
;
733 if (ext_sh
== (char *) NULL
)
734 name
= ecoff_data (cur_bfd
)->ssext
+ sh
->iss
;
736 name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
->iss
;
743 case stGlobal
: /* external symbol, goes into global block */
745 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
747 s
= new_symbol (name
);
748 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
751 case stStatic
: /* static data, goes into current block. */
753 b
= top_stack
->cur_block
;
754 s
= new_symbol (name
);
755 if (sh
->sc
== scCommon
)
757 /* It is a FORTRAN common block. At least for SGI Fortran the
758 address is not in the symbol; we need to fix it later in
759 scan_file_globals. */
760 int bucket
= hashname (SYMBOL_NAME (s
));
761 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
762 global_sym_chain
[bucket
] = s
;
765 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
768 case stLocal
: /* local variable, goes into current block */
769 if (sh
->sc
== scRegister
)
771 class = LOC_REGISTER
;
772 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
776 b
= top_stack
->cur_block
;
777 s
= new_symbol (name
);
778 SYMBOL_VALUE (s
) = svalue
;
780 data
: /* Common code for symbols describing data */
781 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
782 SYMBOL_CLASS (s
) = class;
785 /* Type could be missing in a number of cases */
786 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
787 sh
->index
== 0xfffff)
788 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
790 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
791 /* Value of a data symbol is its memory address */
794 case stParam
: /* arg to procedure, goes into current block */
796 top_stack
->numargs
++;
798 /* Special GNU C++ name. */
799 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
800 name
= "this"; /* FIXME, not alloc'd in obstack */
801 s
= new_symbol (name
);
803 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
807 /* Pass by value in register. */
808 SYMBOL_CLASS(s
) = LOC_REGPARM
;
809 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
812 /* Pass by reference on stack. */
813 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
816 /* Pass by reference in register. */
817 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
818 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
821 /* Pass by value on stack. */
822 SYMBOL_CLASS(s
) = LOC_ARG
;
825 SYMBOL_VALUE (s
) = svalue
;
826 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
827 add_symbol (s
, top_stack
->cur_block
);
829 /* FIXME: This has not been tested. See dbxread.c */
830 /* Add the type of this parameter to the function/procedure
831 type of this block. */
832 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
836 case stLabel
: /* label, goes into current block */
837 s
= new_symbol (name
);
838 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
839 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
840 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
841 SYMBOL_TYPE (s
) = builtin_type_int
;
842 add_symbol (s
, top_stack
->cur_block
);
845 case stProc
: /* Procedure, usually goes into global block */
846 case stStaticProc
: /* Static procedure, goes into current block */
847 s
= new_symbol (name
);
848 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
849 SYMBOL_CLASS (s
) = LOC_BLOCK
;
850 /* Type of the return value */
851 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
852 t
= builtin_type_int
;
854 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
855 b
= top_stack
->cur_block
;
856 if (sh
->st
== stProc
)
858 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
859 /* The next test should normally be true,
860 but provides a hook for nested functions
861 (which we don't want to make global). */
862 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
863 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
867 /* Make a type for the procedure itself */
869 /* FIXME: This has not been tested yet! See dbxread.c */
870 /* Generate a template for the type of this function. The
871 types of the arguments will be added as we read the symbol
873 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
875 SYMBOL_TYPE (s
) = lookup_function_type (t
);
878 /* Create and enter a new lexical context */
879 b
= new_block (top_stack
->maxsyms
);
880 SYMBOL_BLOCK_VALUE (s
) = b
;
881 BLOCK_FUNCTION (b
) = s
;
882 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
883 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
884 add_block (b
, top_stack
->cur_st
);
886 /* Not if we only have partial info */
887 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
891 top_stack
->cur_block
= b
;
892 top_stack
->blocktype
= sh
->st
;
893 top_stack
->cur_type
= SYMBOL_TYPE (s
);
894 top_stack
->cur_field
= -1;
895 top_stack
->procadr
= sh
->value
;
896 top_stack
->numargs
= 0;
899 /* Beginning of code for structure, union, and enum definitions.
900 They all share a common set of local variables, defined here. */
902 enum type_code type_code
;
908 case stStruct
: /* Start a block defining a struct type */
909 type_code
= TYPE_CODE_STRUCT
;
910 goto structured_common
;
912 case stUnion
: /* Start a block defining a union type */
913 type_code
= TYPE_CODE_UNION
;
914 goto structured_common
;
916 case stEnum
: /* Start a block defining an enum type */
917 type_code
= TYPE_CODE_ENUM
;
918 goto structured_common
;
920 case stBlock
: /* Either a lexical block, or some type */
921 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
922 goto case_stBlock_code
; /* Lexical block */
924 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
926 /* Common code for handling struct, union, enum, and/or as-yet-
927 unknown-type blocks of info about structured data. `type_code'
928 has been set to the proper TYPE_CODE, if we know it. */
931 top_stack
->blocktype
= stBlock
;
933 /* First count the number of fields and the highest value. */
936 for (ext_tsym
= ext_sh
+ external_sym_size
;
938 ext_tsym
+= external_sym_size
)
942 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
950 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
951 /* If the type of the member is Nil (or Void),
952 without qualifiers, assume the tag is an
954 if (tsym
.index
== indexNil
)
955 type_code
= TYPE_CODE_ENUM
;
958 ecoff_swap_tir_in (bigend
,
959 &ax
[tsym
.index
].a_ti
,
961 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
963 type_code
= TYPE_CODE_ENUM
;
966 if (tsym
.value
> max_value
)
967 max_value
= tsym
.value
;
976 /* This is a no-op; is it trying to tell us something
977 we should be checking? */
978 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
982 /* This is something like a struct within a
983 struct. Skip over the fields of the inner
984 struct. The -1 is because the for loop will
985 increment ext_tsym. */
986 ext_tsym
= ((char *) ecoff_data (cur_bfd
)->external_sym
987 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
988 * external_sym_size
));
994 /* mips cc puts out a typedef for struct x if it is not yet
995 defined when it encounters
996 struct y { struct x *xp; };
1001 complain (&block_member_complaint
, tsym
.st
);
1006 /* In an stBlock, there is no way to distinguish structs,
1007 unions, and enums at this point. This is a bug in the
1008 original design (that has been fixed with the recent
1009 addition of the stStruct, stUnion, and stEnum symbol
1010 types.) The way you can tell is if/when you see a variable
1011 or field of that type. In that case the variable's type
1012 (in the AUX table) says if the type is struct, union, or
1013 enum, and points back to the stBlock here. So you can
1014 patch the tag kind up later - but only if there actually is
1015 a variable or field of that type.
1017 So until we know for sure, we will guess at this point.
1019 If the first member has index==indexNil or a void type,
1020 assume we have an enumeration.
1021 Otherwise, if there is more than one member, and all
1022 the members have offset 0, assume we have a union.
1023 Otherwise, assume we have a struct.
1025 The heuristic could guess wrong in the case of of an
1026 enumeration with no members or a union with one (or zero)
1027 members, or when all except the last field of a struct have
1028 width zero. These are uncommon and/or illegal situations,
1029 and in any case guessing wrong probably doesn't matter
1032 But if we later do find out we were wrong, we fixup the tag
1033 kind. Members of an enumeration must be handled
1034 differently from struct/union fields, and that is harder to
1035 patch up, but luckily we shouldn't need to. (If there are
1036 any enumeration members, we can tell for sure it's an enum
1039 if (type_code
== TYPE_CODE_UNDEF
)
1040 if (nfields
> 1 && max_value
== 0)
1041 type_code
= TYPE_CODE_UNION
;
1043 type_code
= TYPE_CODE_STRUCT
;
1045 /* Create a new type or use the pending type. */
1046 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1047 if (pend
== (struct mips_pending
*) NULL
)
1049 t
= new_type (NULL
);
1050 add_pending (cur_fdr
, ext_sh
, t
);
1055 /* Alpha cc unnamed structs do not get a tag name. */
1057 TYPE_TAG_NAME (t
) = NULL
;
1059 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1062 TYPE_CODE (t
) = type_code
;
1063 TYPE_LENGTH (t
) = sh
->value
;
1064 TYPE_NFIELDS (t
) = nfields
;
1065 TYPE_FIELDS (t
) = f
= ((struct field
*)
1067 nfields
* sizeof (struct field
)));
1069 if (type_code
== TYPE_CODE_ENUM
)
1071 /* This is a non-empty enum. */
1072 for (ext_tsym
= ext_sh
+ external_sym_size
;
1074 ext_tsym
+= external_sym_size
)
1077 struct symbol
*enum_sym
;
1079 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1081 if (tsym
.st
!= stMember
)
1084 f
->bitpos
= tsym
.value
;
1086 f
->name
= (ecoff_data (cur_bfd
)->ss
1091 enum_sym
= ((struct symbol
*)
1092 obstack_alloc (¤t_objfile
->symbol_obstack
,
1093 sizeof (struct symbol
)));
1094 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1095 SYMBOL_NAME (enum_sym
) = f
->name
;
1096 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1097 SYMBOL_TYPE (enum_sym
) = t
;
1098 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1099 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1100 add_symbol (enum_sym
, top_stack
->cur_block
);
1102 /* Skip the stMembers that we've handled. */
1107 /* make this the current type */
1108 top_stack
->cur_type
= t
;
1109 top_stack
->cur_field
= 0;
1111 /* Do not create a symbol for alpha cc unnamed structs. */
1114 s
= new_symbol (name
);
1115 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1116 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1117 SYMBOL_VALUE (s
) = 0;
1118 SYMBOL_TYPE (s
) = t
;
1120 /* gcc puts out an empty struct for an opaque struct definitions. */
1121 if (TYPE_NFIELDS (t
) == 0)
1123 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1124 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1126 add_symbol (s
, top_stack
->cur_block
);
1129 /* End of local variables shared by struct, union, enum, and
1130 block (as yet unknown struct/union/enum) processing. */
1134 /* beginnning of (code) block. Value of symbol
1135 is the displacement from procedure start */
1136 push_parse_stack ();
1137 top_stack
->blocktype
= stBlock
;
1138 b
= new_block (top_stack
->maxsyms
);
1139 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1140 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1141 top_stack
->cur_block
= b
;
1142 add_block (b
, top_stack
->cur_st
);
1145 case stEnd
: /* end (of anything) */
1146 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1148 /* Finished with type */
1149 top_stack
->cur_type
= 0;
1151 else if (sh
->sc
== scText
&&
1152 (top_stack
->blocktype
== stProc
||
1153 top_stack
->blocktype
== stStaticProc
))
1155 /* Finished with procedure */
1156 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1157 struct mips_extra_func_info
*e
;
1161 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1163 /* Make up special symbol to contain procedure specific info */
1164 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1165 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1166 SYMBOL_CLASS (s
) = LOC_CONST
;
1167 SYMBOL_TYPE (s
) = builtin_type_void
;
1168 e
= ((struct mips_extra_func_info
*)
1169 obstack_alloc (¤t_objfile
->symbol_obstack
,
1170 sizeof (struct mips_extra_func_info
)));
1171 SYMBOL_VALUE (s
) = (long) e
;
1172 e
->numargs
= top_stack
->numargs
;
1173 add_symbol (s
, top_stack
->cur_block
);
1175 /* Reallocate symbols, saving memory */
1176 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1178 /* f77 emits proc-level with address bounds==[0,0],
1179 So look for such child blocks, and patch them. */
1180 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1182 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1183 if (BLOCK_SUPERBLOCK (b_bad
) == b
1184 && BLOCK_START (b_bad
) == top_stack
->procadr
1185 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1187 BLOCK_START (b_bad
) = BLOCK_START (b
);
1188 BLOCK_END (b_bad
) = BLOCK_END (b
);
1192 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1194 /* End of (code) block. The value of the symbol is the
1195 displacement from the procedure`s start address of the
1196 end of this block. */
1197 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1198 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1200 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1202 /* End of file. Pop parse stack and ignore. Higher
1203 level code deals with this. */
1207 complain (&stEnd_complaint
, sh
->sc
);
1209 pop_parse_stack (); /* restore previous lexical context */
1212 case stMember
: /* member of struct or union */
1213 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1215 f
->bitpos
= sh
->value
;
1217 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1218 f
->bitsize
= bitsize
;
1221 case stTypedef
: /* type definition */
1222 /* Typedefs for forward declarations and opaque structs from alpha cc
1223 are handled by cross_ref, skip them. */
1227 /* Parse the type or use the pending type. */
1228 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1229 if (pend
== (struct mips_pending
*) NULL
)
1231 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1232 add_pending (cur_fdr
, ext_sh
, t
);
1237 /* mips cc puts out a typedef with the name of the struct for forward
1238 declarations. These should not go into the symbol table and
1239 TYPE_NAME should not be set for them.
1240 They can't be distinguished from an intentional typedef to
1241 the same name however:
1243 struct x { int ix; int jx; };
1247 struct xx {int ixx; int jxx; };
1248 generates a cross referencing stTypedef for x and xx.
1249 The user visible effect of this is that the type of a pointer
1250 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1251 The problem is fixed with alpha cc. */
1253 s
= new_symbol (name
);
1254 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1255 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1256 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1257 SYMBOL_TYPE (s
) = t
;
1258 add_symbol (s
, top_stack
->cur_block
);
1260 /* Incomplete definitions of structs should not get a name. */
1261 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1262 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1263 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1264 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1266 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1267 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1269 /* If we are giving a name to a type such as "pointer to
1270 foo" or "function returning foo", we better not set
1271 the TYPE_NAME. If the program contains "typedef char
1272 *caddr_t;", we don't want all variables of type char
1273 * to print as caddr_t. This is not just a
1274 consequence of GDB's type management; CC and GCC (at
1275 least through version 2.4) both output variables of
1276 either type char * or caddr_t with the type
1277 refering to the stTypedef symbol for caddr_t. If a future
1278 compiler cleans this up it GDB is not ready for it
1279 yet, but if it becomes ready we somehow need to
1280 disable this check (without breaking the PCC/GCC2.4
1285 Fortunately, this check seems not to be necessary
1286 for anything except pointers or functions. */
1289 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1293 case stFile
: /* file name */
1294 push_parse_stack ();
1295 top_stack
->blocktype
= sh
->st
;
1298 /* I`ve never seen these for C */
1300 break; /* register relocation */
1302 break; /* forwarding address */
1304 break; /* constant */
1306 complain (&unknown_mips_symtype_complaint
, sh
->st
);
1313 /* Parse the type information provided in the raw AX entries for
1314 the symbol SH. Return the bitfield size in BS, in case.
1315 We must byte-swap the AX entries before we use them; BIGEND says whether
1316 they are big-endian or little-endian (from fh->fBigendian). */
1318 static struct type
*
1319 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1322 unsigned int aux_index
;
1327 /* Null entries in this map are treated specially */
1328 static struct type
**map_bt
[] =
1330 &builtin_type_void
, /* btNil */
1332 &builtin_type_char
, /* btChar */
1333 &builtin_type_unsigned_char
,/* btUChar */
1334 &builtin_type_short
, /* btShort */
1335 &builtin_type_unsigned_short
, /* btUShort */
1336 &builtin_type_int
, /* btInt */
1337 &builtin_type_unsigned_int
, /* btUInt */
1338 &builtin_type_long
, /* btLong */
1339 &builtin_type_unsigned_long
,/* btULong */
1340 &builtin_type_float
, /* btFloat */
1341 &builtin_type_double
, /* btDouble */
1348 &builtin_type_complex
, /* btComplex */
1349 &builtin_type_double_complex
, /* btDComplex */
1351 &builtin_type_fixed_dec
, /* btFixedDec */
1352 &builtin_type_float_dec
, /* btFloatDec */
1353 &builtin_type_string
, /* btString */
1356 &builtin_type_void
, /* btVoid */
1357 0, /* DEC C++: Pointer to member */
1358 0, /* DEC C++: Virtual function table */
1359 0, /* DEC C++: Class (Record) */
1360 &builtin_type_long
, /* btLong64 */
1361 &builtin_type_unsigned_long
, /* btULong64 */
1362 &builtin_type_long_long
, /* btLongLong64 */
1363 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1364 &builtin_type_unsigned_long
, /* btAdr64 */
1365 &builtin_type_long
, /* btInt64 */
1366 &builtin_type_unsigned_long
, /* btUInt64 */
1370 struct type
*tp
= 0;
1371 enum type_code type_code
= TYPE_CODE_UNDEF
;
1373 /* Handle corrupt aux indices. */
1374 if (aux_index
>= (ecoff_data (cur_bfd
)->fdr
+ fd
)->caux
)
1376 complain (&index_complaint
, sym_name
);
1377 return builtin_type_int
;
1381 /* Use aux as a type information record, map its basic type. */
1382 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1383 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1385 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1386 return builtin_type_int
;
1390 tp
= *map_bt
[t
->bt
];
1395 /* Cannot use builtin types -- build our own */
1399 tp
= lookup_pointer_type (builtin_type_void
);
1402 type_code
= TYPE_CODE_STRUCT
;
1405 type_code
= TYPE_CODE_UNION
;
1408 type_code
= TYPE_CODE_ENUM
;
1411 type_code
= TYPE_CODE_RANGE
;
1414 type_code
= TYPE_CODE_SET
;
1417 /* alpha cc uses this for typedefs. The true type will be
1418 obtained by crossreferencing below. */
1419 type_code
= TYPE_CODE_ERROR
;
1422 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1423 return builtin_type_int
;
1427 /* Move on to next aux */
1432 /* Inhibit core dumps with some cfront generated objects that
1434 if (bs
== (int *)NULL
)
1436 complain (&bad_fbitfield_complaint
, sym_name
);
1437 return builtin_type_int
;
1439 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1443 /* All these types really point to some (common) MIPS type
1444 definition, and only the type-qualifiers fully identify
1445 them. We'll make the same effort at sharing. */
1446 if (t
->bt
== btStruct
||
1450 /* btSet (I think) implies that the name is a tag name, not a typedef
1451 name. This apparently is a MIPS extension for C sets. */
1456 /* Try to cross reference this type, build new type on failure. */
1457 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1458 if (tp
== (struct type
*) NULL
)
1459 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1461 /* Make sure that TYPE_CODE(tp) has an expected type code.
1462 Any type may be returned from cross_ref if file indirect entries
1464 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1465 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1466 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1468 complain (&unexpected_type_code_complaint
, sym_name
);
1473 /* Usually, TYPE_CODE(tp) is already type_code. The main
1474 exception is if we guessed wrong re struct/union/enum.
1475 But for struct vs. union a wrong guess is harmless, so
1476 don't complain(). */
1477 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1478 && type_code
!= TYPE_CODE_ENUM
)
1479 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1480 && type_code
== TYPE_CODE_ENUM
))
1482 complain (&bad_tag_guess_complaint
, sym_name
);
1485 if (TYPE_CODE (tp
) != type_code
)
1487 TYPE_CODE (tp
) = type_code
;
1490 /* Do not set the tag name if it is a compiler generated tag name
1491 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1492 if (name
[0] == '.' || name
[0] == '\0')
1493 TYPE_TAG_NAME (tp
) = NULL
;
1494 else if (TYPE_TAG_NAME (tp
) == NULL
1495 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1496 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1497 ¤t_objfile
->type_obstack
);
1501 /* All these types really point to some (common) MIPS type
1502 definition, and only the type-qualifiers fully identify
1503 them. We'll make the same effort at sharing.
1504 FIXME: btIndirect cannot happen here as it is handled by the
1505 switch t->bt above. And we are not doing any guessing on range types. */
1506 if (t
->bt
== btIndirect
||
1511 /* Try to cross reference this type, build new type on failure. */
1512 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1513 if (tp
== (struct type
*) NULL
)
1514 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1516 /* Make sure that TYPE_CODE(tp) has an expected type code.
1517 Any type may be returned from cross_ref if file indirect entries
1519 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1521 complain (&unexpected_type_code_complaint
, sym_name
);
1525 /* Usually, TYPE_CODE(tp) is already type_code. The main
1526 exception is if we guessed wrong re struct/union/enum. */
1527 if (TYPE_CODE (tp
) != type_code
)
1529 complain (&bad_tag_guess_complaint
, sym_name
);
1530 TYPE_CODE (tp
) = type_code
;
1532 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1533 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1534 ¤t_objfile
->type_obstack
);
1537 if (t
->bt
== btTypedef
)
1541 /* Try to cross reference this type, it should succeed. */
1542 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1543 if (tp
== (struct type
*) NULL
)
1545 complain (&unable_to_cross_ref_complaint
, sym_name
);
1546 tp
= builtin_type_int
;
1550 /* Deal with range types */
1551 if (t
->bt
== btRange
)
1553 TYPE_NFIELDS (tp
) = 2;
1554 TYPE_FIELDS (tp
) = ((struct field
*)
1555 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1556 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1557 ¤t_objfile
->type_obstack
);
1558 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1560 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1561 ¤t_objfile
->type_obstack
);
1562 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1566 /* Parse all the type qualifiers now. If there are more
1567 than 6 the game will continue in the next aux */
1571 #define PARSE_TQ(tq) \
1572 if (t->tq != tqNil) \
1573 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1585 /* mips cc 2.x and gcc never put out continued aux entries. */
1589 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1593 /* Complain for illegal continuations due to corrupt aux entries. */
1595 complain (&bad_continued_complaint
, sym_name
);
1600 /* Make up a complex type from a basic one. Type is passed by
1601 reference in TPP and side-effected as necessary. The type
1602 qualifier TQ says how to handle the aux symbols at AX for
1603 the symbol SX we are currently analyzing. BIGEND says whether
1604 aux symbols are big-endian or little-endian.
1605 Returns the number of aux symbols we parsed. */
1608 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1619 /* Used in array processing */
1630 t
= lookup_pointer_type (*tpp
);
1635 t
= lookup_function_type (*tpp
);
1642 /* Determine and record the domain type (type of index) */
1643 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1649 rf
= AUX_GET_ISYM (bigend
, ax
);
1652 fh
= get_rfd (fd
, rf
);
1654 indx
= parse_type (fd
,
1655 ecoff_data (cur_bfd
)->external_aux
+ fh
->iauxBase
,
1656 id
, (int *) NULL
, bigend
, sym_name
);
1658 /* The bounds type should be an integer type, but might be anything
1659 else due to corrupt aux entries. */
1660 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1662 complain (&array_index_type_complaint
, sym_name
);
1663 indx
= builtin_type_int
;
1666 /* Get the bounds, and create the array type. */
1668 lower
= AUX_GET_DNLOW (bigend
, ax
);
1670 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1672 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1674 range
= create_range_type ((struct type
*) NULL
, indx
,
1677 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1679 /* Check whether supplied array element bit size matches
1680 the known size of the element type. If this complaint
1681 ends up not happening, we can remove this code. It's
1682 here because we aren't sure we understand this *&%&$
1684 id
= TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) << 3; /* bitsize */
1687 /* Most likely an undefined type */
1689 TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) = id
>> 3;
1692 complain (&array_bitsize_complaint
, sym_name
, rf
);
1698 /* Volatile -- currently ignored */
1702 /* Const -- currently ignored */
1706 complain (&unknown_type_qual_complaint
, tq
);
1712 /* Parse a procedure descriptor record PR. Note that the procedure is
1713 parsed _after_ the local symbols, now we just insert the extra
1714 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1715 already been placed in the procedure's main block. Note also that
1716 images that have been partially stripped (ld -x) have been deprived
1717 of local symbols, and we have to cope with them here. FIRST_OFF is
1718 the offset of the first procedure for this FDR; we adjust the
1719 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1720 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1721 in question, or NULL to use top_stack->cur_block. */
1723 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1726 parse_procedure (pr
, search_symtab
, first_off
)
1728 struct symtab
*search_symtab
;
1729 unsigned long first_off
;
1731 struct symbol
*s
, *i
;
1733 struct mips_extra_func_info
*e
;
1736 /* Simple rule to find files linked "-x" */
1737 if (cur_fdr
->rss
== -1)
1741 /* Static procedure at address pr->adr. Sigh. */
1742 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1750 (*ecoff_backend (cur_bfd
)->swap_ext_in
)
1752 ((char *) ecoff_data (cur_bfd
)->external_ext
1753 + pr
->isym
* ecoff_backend (cur_bfd
)->external_ext_size
),
1755 sh_name
= ecoff_data (cur_bfd
)->ssext
+ she
.asym
.iss
;
1763 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
1765 ((char *) ecoff_data (cur_bfd
)->external_sym
1766 + ((cur_fdr
->isymBase
+ pr
->isym
)
1767 * ecoff_backend (cur_bfd
)->external_sym_size
)),
1769 sh_name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1772 if (search_symtab
!= NULL
)
1775 /* This loses both in the case mentioned (want a static, find a global),
1776 but also if we are looking up a non-mangled name which happens to
1777 match the name of a mangled function. */
1778 /* We have to save the cur_fdr across the call to lookup_symbol.
1779 If the pdr is for a static function and if a global function with
1780 the same name exists, lookup_symbol will eventually read in the symtab
1781 for the global function and clobber cur_fdr. */
1782 FDR
*save_cur_fdr
= cur_fdr
;
1783 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1784 cur_fdr
= save_cur_fdr
;
1788 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1794 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1795 VAR_NAMESPACE
, LOC_BLOCK
);
1799 b
= SYMBOL_BLOCK_VALUE (s
);
1803 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1807 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1808 s
= new_symbol (sh_name
);
1809 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1810 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1811 /* Donno its type, hope int is ok */
1812 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1813 add_symbol (s
, top_stack
->cur_block
);
1814 /* Wont have symbols for this one */
1816 SYMBOL_BLOCK_VALUE (s
) = b
;
1817 BLOCK_FUNCTION (b
) = s
;
1818 BLOCK_START (b
) = pr
->adr
;
1819 /* BOUND used to be the end of procedure's text, but the
1820 argument is no longer passed in. */
1821 BLOCK_END (b
) = bound
;
1822 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1823 add_block (b
, top_stack
->cur_st
);
1827 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1831 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1833 e
->pdr
.isym
= (long) s
;
1834 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1836 /* Correct incorrect setjmp procedure descriptor from the library
1837 to make backtrace through setjmp work. */
1838 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1840 complain (&bad_setjmp_pdr_complaint
, 0);
1841 e
->pdr
.pcreg
= RA_REGNUM
;
1842 e
->pdr
.regmask
= 0x80000000;
1843 e
->pdr
.regoffset
= -4;
1846 /* Fake PC_REGNUM for alpha __sigtramp so that read_next_frame_reg
1847 will use the saved user pc from the sigcontext. */
1848 if (STREQ (sh_name
, "__sigtramp"))
1849 e
->pdr
.pcreg
= PC_REGNUM
;
1853 /* Parse the external symbol ES. Just call parse_symbol() after
1854 making sure we know where the aux are for it. For procedures,
1855 parsing of the PDRs has already provided all the needed
1856 information, we only parse them if SKIP_PROCEDURES is false,
1857 and only if this causes no symbol duplication.
1858 BIGEND says whether aux entries are big-endian or little-endian.
1860 This routine clobbers top_stack->cur_block and ->cur_st. */
1863 parse_external (es
, skip_procedures
, bigend
)
1865 int skip_procedures
;
1870 if (es
->ifd
!= ifdNil
)
1873 cur_fdr
= ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
1874 ax
= ecoff_data (cur_bfd
)->external_aux
+ cur_fdr
->iauxBase
;
1878 cur_fdr
= ecoff_data (cur_bfd
)->fdr
;
1882 /* Reading .o files */
1883 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1886 switch (es
->asym
.st
)
1889 /* These are generated for static symbols in .o files,
1910 /* FIXME: Turn this into a complaint? */
1912 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1914 ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1915 fdr_name (cur_fdr
));
1919 switch (es
->asym
.st
)
1922 /* If we have full symbols we do not need more */
1923 if (skip_procedures
)
1925 if (mylookup_symbol (ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1926 top_stack
->cur_block
,
1927 VAR_NAMESPACE
, LOC_BLOCK
))
1932 /* Note that the case of a symbol with indexNil must be handled
1933 anyways by parse_symbol(). */
1934 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1941 /* Parse the line number info for file descriptor FH into
1942 GDB's linetable LT. MIPS' encoding requires a little bit
1943 of magic to get things out. Note also that MIPS' line
1944 numbers can go back and forth, apparently we can live
1945 with that and do not need to reorder our linetables */
1948 parse_lines (fh
, pr
, lt
, maxlines
)
1951 struct linetable
*lt
;
1954 unsigned char *base
;
1956 int delta
, count
, lineno
= 0;
1957 unsigned long first_off
= pr
->adr
;
1959 if (fh
->cbLine
== 0)
1962 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1964 /* Scan by procedure descriptors */
1966 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1970 unsigned char *halt
;
1972 /* No code for this one */
1973 if (pr
->iline
== ilineNil
||
1974 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1977 /* Determine start and end address of compressed line bytes for
1979 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1980 if (j
!= (fh
->cpd
- 1))
1981 halt
= base
+ pr
[1].cbLineOffset
;
1983 halt
= base
+ fh
->cbLine
;
1984 base
+= pr
->cbLineOffset
;
1986 adr
= fh
->adr
+ pr
->adr
- first_off
;
1987 l
= adr
>> 2; /* in words */
1988 for (lineno
= pr
->lnLow
; base
< halt
; )
1990 count
= *base
& 0x0f;
1991 delta
= *base
++ >> 4;
1996 delta
= (base
[0] << 8) | base
[1];
1997 if (delta
>= 0x8000)
2001 lineno
+= delta
; /* first delta is 0 */
2003 /* Complain if the line table overflows. Could happen
2004 with corrupt binaries. */
2005 if (lt
->nitems
>= maxlines
)
2007 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2010 k
= add_line (lt
, lineno
, l
, k
);
2016 /* Master parsing procedure for first-pass reading of file symbols
2017 into a partial_symtab. */
2020 parse_partial_symbols (objfile
, section_offsets
)
2021 struct objfile
*objfile
;
2022 struct section_offsets
*section_offsets
;
2024 const struct ecoff_backend_data
* const backend
= ecoff_backend (cur_bfd
);
2025 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
2026 const bfd_size_type external_rfd_size
= backend
->external_rfd_size
;
2027 const bfd_size_type external_ext_size
= backend
->external_ext_size
;
2028 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2029 = backend
->swap_ext_in
;
2030 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2031 = backend
->swap_sym_in
;
2032 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2033 = backend
->swap_rfd_in
;
2035 HDRR
*hdr
= &ecoff_data (cur_bfd
)->symbolic_header
;
2036 /* Running pointers */
2041 register EXTR
*ext_in
;
2044 struct partial_symtab
*pst
;
2046 int past_first_source_file
= 0;
2048 /* List of current psymtab's include files */
2049 char **psymtab_include_list
;
2050 int includes_allocated
;
2053 struct pst_map
*fdr_to_pst
;
2054 /* Index within current psymtab dependency list */
2055 struct partial_symtab
**dependency_list
;
2056 int dependencies_used
, dependencies_allocated
;
2057 struct cleanup
*old_chain
;
2059 enum language prev_language
;
2061 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2062 sizeof (EXTR
) * hdr
->iextMax
);
2064 includes_allocated
= 30;
2066 psymtab_include_list
= (char **) alloca (includes_allocated
*
2068 next_symbol_text_func
= mips_next_symbol_text
;
2070 dependencies_allocated
= 30;
2071 dependencies_used
= 0;
2073 (struct partial_symtab
**) alloca (dependencies_allocated
*
2074 sizeof (struct partial_symtab
*));
2076 last_source_file
= NULL
;
2081 * Only parse the Local and External symbols, and the Relative FDR.
2082 * Fixup enough of the loader symtab to be able to use it.
2083 * Allocate space only for the file's portions we need to
2088 max_glevel
= MIN_GLEVEL
;
2090 /* Allocate the map FDR -> PST.
2091 Minor hack: -O3 images might claim some global data belongs
2092 to FDR -1. We`ll go along with that */
2093 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2094 old_chain
= make_cleanup (free
, fdr_to_pst
);
2097 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2098 fdr_to_pst
[-1].pst
= pst
;
2102 /* Allocate the global pending list. */
2103 ECOFF_PENDING_LIST (objfile
) =
2104 ((struct mips_pending
**)
2105 obstack_alloc (&objfile
->psymbol_obstack
,
2106 hdr
->ifdMax
* sizeof (struct mips_pending
*)));
2107 memset ((PTR
) ECOFF_PENDING_LIST (objfile
), 0,
2108 hdr
->ifdMax
* sizeof (struct mips_pending
*));
2110 /* Pass 0 over external syms: swap them in. */
2111 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2112 make_cleanup (free
, ext_block
);
2114 ext_out
= (char *) ecoff_data (cur_bfd
)->external_ext
;
2115 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2117 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2118 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2120 /* Pass 1 over external syms: Presize and partition the list */
2122 ext_in_end
= ext_in
+ hdr
->iextMax
;
2123 for (; ext_in
< ext_in_end
; ext_in
++)
2124 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2126 /* Pass 1.5 over files: partition out global symbol space */
2128 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2130 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2131 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2132 fdr_to_pst
[f_idx
].n_globals
= 0;
2135 /* Pass 2 over external syms: fill in external symbols */
2137 ext_in_end
= ext_in
+ hdr
->iextMax
;
2138 for (; ext_in
< ext_in_end
; ext_in
++)
2140 enum minimal_symbol_type ms_type
= mst_text
;
2142 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2143 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2145 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2148 name
= ecoff_data (cur_bfd
)->ssext
+ ext_in
->asym
.iss
;
2149 switch (ext_in
->asym
.st
)
2154 ms_type
= mst_file_text
;
2157 if (ext_in
->asym
.sc
== scData
2158 || ext_in
->asym
.sc
== scSData
2159 || ext_in
->asym
.sc
== scRData
)
2165 if (ext_in
->asym
.sc
== scAbs
)
2167 else if (ext_in
->asym
.sc
== scText
)
2169 else if (ext_in
->asym
.sc
== scData
2170 || ext_in
->asym
.sc
== scSData
2171 || ext_in
->asym
.sc
== scRData
)
2177 /* The alpha has the section start addresses in stLocal symbols
2178 whose name starts with a `.'. Skip those but complain for all
2179 other stLocal symbols. */
2184 ms_type
= mst_unknown
;
2185 complain (&unknown_ext_complaint
, name
);
2187 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
);
2190 /* Pass 3 over files, over local syms: fill in static symbols */
2191 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2193 struct partial_symtab
*save_pst
;
2196 cur_fdr
= fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
2200 fdr_to_pst
[f_idx
].pst
= NULL
;
2203 pst
= start_psymtab_common (objfile
, section_offsets
,
2205 fh
->cpd
? fh
->adr
: 0,
2206 objfile
->global_psymbols
.next
,
2207 objfile
->static_psymbols
.next
);
2208 pst
->read_symtab_private
= ((char *)
2209 obstack_alloc (&objfile
->psymbol_obstack
,
2210 sizeof (struct symloc
)));
2211 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2214 FDR_IDX (pst
) = f_idx
;
2215 CUR_BFD (pst
) = cur_bfd
;
2217 /* The way to turn this into a symtab is to call... */
2218 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
2220 /* Set up language for the pst.
2221 The language from the FDR is used if it is unambigious (e.g. cfront
2222 with native cc and g++ will set the language to C).
2223 Otherwise we have to deduce the language from the filename.
2224 Native ecoff has every header file in a separate FDR, so
2225 deduce_language_from_filename will return language_unknown for
2226 a header file, which is not what we want.
2227 But the FDRs for the header files are after the FDR for the source
2228 file, so we can assign the language of the source file to the
2229 following header files. Then we save the language in the private
2230 pst data so that we can reuse it when building symtabs. */
2231 prev_language
= psymtab_language
;
2235 case langCplusplusV2
:
2236 psymtab_language
= language_cplus
;
2239 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2242 if (psymtab_language
== language_unknown
)
2243 psymtab_language
= prev_language
;
2244 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2246 pst
->texthigh
= pst
->textlow
;
2248 /* For stabs-in-ecoff files, the second symbol must be @stab.
2249 This symbol is emitted by mips-tfile to signal that the
2250 current object file uses encapsulated stabs instead of mips
2251 ecoff for local symbols. (It is the second symbol because
2252 the first symbol is the stFile used to signal the start of a
2254 processing_gcc_compilation
= 0;
2257 (*swap_sym_in
) (cur_bfd
,
2258 ((char *) ecoff_data (cur_bfd
)->external_sym
2259 + (fh
->isymBase
+ 1) * external_sym_size
),
2261 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2263 processing_gcc_compilation
= 2;
2266 if (processing_gcc_compilation
!= 0)
2268 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2273 (*swap_sym_in
) (cur_bfd
,
2274 ((char *) ecoff_data (cur_bfd
)->external_sym
2275 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2277 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2278 if (!ECOFF_IS_STAB (&sh
))
2280 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2282 long procaddr
= sh
.value
;
2286 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2287 (ecoff_data (cur_bfd
)->external_aux
2290 (*swap_sym_in
) (cur_bfd
,
2292 ecoff_data (cur_bfd
)->external_sym
)
2293 + ((fh
->isymBase
+ isym
- 1)
2294 * external_sym_size
)),
2298 long high
= procaddr
+ sh
.value
;
2299 if (high
> pst
->texthigh
)
2300 pst
->texthigh
= high
;
2305 #define SET_NAMESTRING() \
2306 namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
2307 #define CUR_SYMBOL_TYPE type_code
2308 #define CUR_SYMBOL_VALUE sh.value
2309 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2311 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2312 #define HANDLE_RBRAC(val) \
2313 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2314 #include "partial-stab.h"
2319 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2322 enum address_class
class;
2324 (*swap_sym_in
) (cur_bfd
,
2325 ((char *) ecoff_data (cur_bfd
)->external_sym
2326 + ((fh
->isymBase
+ cur_sdx
)
2327 * external_sym_size
)),
2330 if (ECOFF_IS_STAB (&sh
))
2336 /* Non absolute static symbols go into the minimal table. */
2337 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2338 || (sh
.index
== indexNil
2339 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2341 /* FIXME, premature? */
2346 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2354 case stStaticProc
: /* Function */
2355 /* I believe this is used only for file-local functions.
2356 The comment in symconst.h ("load time only static procs")
2357 isn't particularly clear on this point. */
2358 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
);
2361 case stProc
: /* Asm labels apparently */
2362 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2363 VAR_NAMESPACE
, LOC_BLOCK
,
2364 objfile
->static_psymbols
, sh
.value
,
2365 psymtab_language
, objfile
);
2366 /* Skip over procedure to next one. */
2367 if (sh
.index
>= hdr
->iauxMax
)
2369 /* Should not happen, but does when cross-compiling
2370 with the MIPS compiler. FIXME -- pull later. */
2371 complain (&index_complaint
, name
);
2372 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2375 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2376 (ecoff_data (cur_bfd
)->external_aux
2379 procaddr
= sh
.value
;
2381 if (new_sdx
<= cur_sdx
)
2383 /* This should not happen either... FIXME. */
2384 complain (&aux_index_complaint
, name
);
2385 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2389 (*swap_sym_in
) (cur_bfd
,
2390 ((char *) ecoff_data (cur_bfd
)->external_sym
2391 + ((fh
->isymBase
+ cur_sdx
- 1)
2392 * external_sym_size
)),
2396 high
= procaddr
+ sh
.value
;
2397 if (high
> pst
->texthigh
)
2398 pst
->texthigh
= high
;
2401 case stStatic
: /* Variable */
2402 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2403 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
);
2405 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
);
2409 case stTypedef
:/* Typedef */
2410 class = LOC_TYPEDEF
;
2413 case stConstant
: /* Constant decl */
2420 case stBlock
: /* { }, str, un, enum*/
2421 if (sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2423 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2424 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2425 objfile
->static_psymbols
,
2427 psymtab_language
, objfile
);
2429 /* Skip over the block */
2431 if (new_sdx
<= cur_sdx
)
2433 /* This happens with the Ultrix kernel. */
2434 complain (&block_index_complaint
, name
);
2435 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2440 case stFile
: /* File headers */
2441 case stLabel
: /* Labels */
2442 case stEnd
: /* Ends of files */
2445 case stLocal
: /* Local variables */
2446 /* Normally these are skipped because we skip over
2447 all blocks we see. However, these can occur
2448 as visible symbols in a .h file that contains code. */
2452 /* Both complaints are valid: one gives symbol name,
2453 the other the offending symbol type. */
2454 complain (&unknown_sym_complaint
, name
);
2455 complain (&unknown_st_complaint
, sh
.st
);
2459 /* Use this gdb symbol */
2460 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2461 VAR_NAMESPACE
, class,
2462 objfile
->static_psymbols
, sh
.value
,
2463 psymtab_language
, objfile
);
2465 cur_sdx
++; /* Go to next file symbol */
2468 /* Now do enter the external symbols. */
2469 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2470 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2471 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2472 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2473 for (; --cur_sdx
>= 0; ext_ptr
++)
2475 enum address_class
class;
2479 if (ext_ptr
->ifd
!= f_idx
)
2481 psh
= &ext_ptr
->asym
;
2483 /* Do not add undefined symbols to the partial symbol table. */
2484 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2490 /* These are generated for static symbols in .o files,
2501 complain (&unknown_ext_complaint
,
2502 ecoff_data (cur_bfd
)->ssext
+ psh
->iss
);
2503 /* Fall through, pretend it's global. */
2508 name
= ecoff_data (cur_bfd
)->ssext
+ psh
->iss
;
2509 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2510 VAR_NAMESPACE
, class,
2511 objfile
->global_psymbols
, (CORE_ADDR
) psh
->value
,
2512 psymtab_language
, objfile
);
2516 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2517 empty and put on the free list. */
2518 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2519 psymtab_include_list
, includes_used
,
2520 -1, save_pst
->texthigh
,
2521 dependency_list
, dependencies_used
);
2522 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2523 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2525 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2526 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2530 /* Now scan the FDRs for dependencies */
2531 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2533 fh
= f_idx
+ ecoff_data (cur_bfd
)->fdr
;
2534 pst
= fdr_to_pst
[f_idx
].pst
;
2536 if (pst
== (struct partial_symtab
*)NULL
)
2539 /* This should catch stabs-in-ecoff. */
2543 /* Skip the first file indirect entry as it is a self dependency
2544 for source files or a reverse .h -> .c dependency for header files. */
2545 pst
->number_of_dependencies
= 0;
2547 ((struct partial_symtab
**)
2548 obstack_alloc (&objfile
->psymbol_obstack
,
2550 * sizeof (struct partial_symtab
*))));
2551 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2555 (*swap_rfd_in
) (cur_bfd
,
2556 ((char *) ecoff_data (cur_bfd
)->external_rfd
2557 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2559 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2561 complain (&bad_file_number_complaint
, rh
);
2565 /* Skip self dependencies of header files. */
2569 /* Do not add to dependeny list if psymtab was empty. */
2570 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2572 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2575 do_cleanups (old_chain
);
2580 mips_next_symbol_text ()
2585 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
2587 ((char *) ecoff_data (cur_bfd
)->external_sym
2588 + ((cur_fdr
->isymBase
+ cur_sdx
)
2589 * ecoff_backend (cur_bfd
)->external_sym_size
)),
2591 return ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2594 /* Ancillary function to psymtab_to_symtab(). Does all the work
2595 for turning the partial symtab PST into a symtab, recurring
2596 first on all dependent psymtabs. The argument FILENAME is
2597 only passed so we can see in debug stack traces what file
2600 This function has a split personality, based on whether the
2601 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2602 The flow of control and even the memory allocation differs. FIXME. */
2605 psymtab_to_symtab_1 (pst
, filename
)
2606 struct partial_symtab
*pst
;
2609 const bfd_size_type external_sym_size
2610 = ecoff_backend (cur_bfd
)->external_sym_size
;
2611 const bfd_size_type external_pdr_size
2612 = ecoff_backend (cur_bfd
)->external_pdr_size
;
2613 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2614 = ecoff_backend (cur_bfd
)->swap_sym_in
;
2615 void (* const swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*))
2616 = ecoff_backend (cur_bfd
)->swap_pdr_in
;
2620 struct linetable
*lines
;
2626 /* Read in all partial symbtabs on which this one is dependent.
2627 NOTE that we do have circular dependencies, sigh. We solved
2628 that by setting pst->readin before this point. */
2630 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2631 if (!pst
->dependencies
[i
]->readin
)
2633 /* Inform about additional files to be read in. */
2636 fputs_filtered (" ", stdout
);
2638 fputs_filtered ("and ", stdout
);
2640 printf_filtered ("%s...",
2641 pst
->dependencies
[i
]->filename
);
2642 wrap_here (""); /* Flush output */
2645 /* We only pass the filename for debug purposes */
2646 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2647 pst
->dependencies
[i
]->filename
);
2650 /* Do nothing if this is a dummy psymtab. */
2652 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2653 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2656 /* Now read the symbols for this symtab */
2658 cur_bfd
= CUR_BFD (pst
);
2659 current_objfile
= pst
->objfile
;
2660 cur_fd
= FDR_IDX (pst
);
2661 fh
= (cur_fd
== -1) ? (FDR
*) NULL
: ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
2664 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2665 processing_gcc_compilation
= 0;
2666 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2670 (*swap_sym_in
) (cur_bfd
,
2671 ((char *) ecoff_data (cur_bfd
)->external_sym
2672 + (fh
->isymBase
+ 1) * external_sym_size
),
2674 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2677 /* We indicate that this is a GCC compilation so that certain
2678 features will be enabled in stabsread/dbxread. */
2679 processing_gcc_compilation
= 2;
2683 if (processing_gcc_compilation
!= 0)
2688 unsigned long first_off
= 0;
2690 /* This symbol table contains stabs-in-ecoff entries. */
2692 /* Parse local symbols first */
2694 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2696 current_objfile
= NULL
;
2699 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2705 (*swap_sym_in
) (cur_bfd
,
2706 ((char *) ecoff_data (cur_bfd
)->external_sym
2707 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2709 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2711 if (ECOFF_IS_STAB (&sh
))
2713 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2714 process_one_symbol (type_code
, 0, valu
, name
,
2715 pst
->section_offsets
, pst
->objfile
);
2716 if (type_code
== N_FUN
)
2718 /* Make up special symbol to contain
2719 procedure specific info */
2720 struct mips_extra_func_info
*e
=
2721 ((struct mips_extra_func_info
*)
2722 obstack_alloc (¤t_objfile
->symbol_obstack
,
2723 sizeof (struct mips_extra_func_info
)));
2724 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2725 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2726 SYMBOL_CLASS (s
) = LOC_CONST
;
2727 SYMBOL_TYPE (s
) = builtin_type_void
;
2728 SYMBOL_VALUE (s
) = (long) e
;
2729 add_symbol_to_list (s
, &local_symbols
);
2732 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2734 /* Handle encoded stab line number. */
2735 record_line (current_subfile
, sh
.index
, valu
);
2737 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2738 /* These are generated by gcc-2.x, do not complain */
2741 complain (&stab_unknown_complaint
, name
);
2743 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2746 /* Sort the symbol table now, we are done adding symbols to it.
2747 We must do this before parse_procedure calls lookup_symbol. */
2748 sort_symtab_syms (st
);
2750 /* This may not be necessary for stabs symtabs. FIXME. */
2753 /* Fill in procedure info next. */
2755 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2756 + fh
->ipdFirst
* external_pdr_size
);
2757 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2758 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2762 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2768 parse_procedure (&pr
, st
, first_off
);
2773 /* This symbol table contains ordinary ecoff entries. */
2775 /* FIXME: doesn't use pst->section_offsets. */
2781 /* How many symbols will we need */
2782 /* FIXME, this does not count enum values. */
2783 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2787 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2791 f_max
+= fh
->csym
+ fh
->cpd
;
2792 maxlines
= 2 * fh
->cline
;
2793 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2795 /* The proper language was already determined when building
2796 the psymtab, use it. */
2797 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2800 psymtab_language
= st
->language
;
2802 lines
= LINETABLE (st
);
2804 /* Get a new lexical context */
2806 push_parse_stack ();
2807 top_stack
->cur_st
= st
;
2808 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2810 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2811 BLOCK_END (top_stack
->cur_block
) = 0;
2812 top_stack
->blocktype
= stFile
;
2813 top_stack
->maxsyms
= 2 * f_max
;
2814 top_stack
->cur_type
= 0;
2815 top_stack
->procadr
= 0;
2816 top_stack
->numargs
= 0;
2823 /* Parse local symbols first */
2824 sym_ptr
= ((char *) ecoff_data (cur_bfd
)->external_sym
2825 + fh
->isymBase
* external_sym_size
);
2826 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2827 while (sym_ptr
< sym_end
)
2832 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2833 c
= parse_symbol (&sh
,
2834 (ecoff_data (cur_bfd
)->external_aux
2836 sym_ptr
, fh
->fBigendian
);
2837 sym_ptr
+= c
* external_sym_size
;
2840 /* Linenumbers. At the end, check if we can save memory.
2841 parse_lines has to look ahead an arbitrary number of PDR
2842 structures, so we swap them all first. */
2846 struct cleanup
*old_chain
;
2852 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2854 old_chain
= make_cleanup (free
, pr_block
);
2856 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2857 + fh
->ipdFirst
* external_pdr_size
);
2858 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2862 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2863 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2865 parse_lines (fh
, pr_block
, lines
, maxlines
);
2866 if (lines
->nitems
< fh
->cline
)
2867 lines
= shrink_linetable (lines
);
2869 /* Fill in procedure info next. */
2871 pdr_in_end
= pdr_in
+ fh
->cpd
;
2872 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2873 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2875 do_cleanups (old_chain
);
2879 LINETABLE (st
) = lines
;
2881 /* .. and our share of externals.
2882 XXX use the global list to speed up things here. how?
2883 FIXME, Maybe quit once we have found the right number of ext's? */
2884 top_stack
->cur_st
= st
;
2885 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2887 top_stack
->blocktype
= stFile
;
2888 top_stack
->maxsyms
= (ecoff_data (cur_bfd
)->symbolic_header
.isymMax
2889 + ecoff_data (cur_bfd
)->symbolic_header
.ipdMax
2890 + ecoff_data (cur_bfd
)->symbolic_header
.iextMax
);
2892 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2893 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2894 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2896 /* If there are undefined symbols, tell the user.
2897 The alpha has an undefined symbol for every symbol that is
2898 from a shared library, so tell the user only if verbose is on. */
2899 if (info_verbose
&& n_undef_symbols
)
2901 printf_filtered ("File %s contains %d unresolved references:",
2902 st
->filename
, n_undef_symbols
);
2903 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2904 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2905 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2910 /* Sort the symbol table now, we are done adding symbols to it.*/
2911 sort_symtab_syms (st
);
2916 /* Now link the psymtab and the symtab. */
2919 current_objfile
= NULL
;
2922 /* Ancillary parsing procedures. */
2924 /* Lookup the type at relative index RN. Return it in TPP
2925 if found and in any event come up with its name PNAME.
2926 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2927 Return value says how many aux symbols we ate. */
2930 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2934 enum type_code type_code
; /* Use to alloc new type if none is found. */
2946 struct mips_pending
*pend
;
2948 *tpp
= (struct type
*)NULL
;
2950 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2952 /* Escape index means 'the next one' */
2953 if (rn
->rfd
== 0xfff)
2956 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2963 /* mips cc uses a rf of -1 for opaque struct definitions.
2964 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2965 resolve them if the struct gets defined in another compilation unit. */
2968 *pname
= "<undefined>";
2969 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2970 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2974 /* mips cc uses an escaped rn->index of 0 for struct return types
2975 of procedures that were compiled without -g. These will always remain
2977 if (rn
->rfd
== 0xfff && rn
->index
== 0)
2979 *pname
= "<undefined>";
2983 /* Find the relative file descriptor and the symbol in it. */
2984 fh
= get_rfd (fd
, rf
);
2985 xref_fd
= fh
- ecoff_data (cur_bfd
)->fdr
;
2987 if (rn
->index
>= fh
->csym
)
2989 /* File indirect entry is corrupt. */
2990 *pname
= "<illegal>";
2991 complain (&bad_rfd_entry_complaint
,
2992 sym_name
, xref_fd
, rn
->index
);
2996 /* If we have processed this symbol then we left a forwarding
2997 pointer to the type in the pending list. If not, we`ll put
2998 it in a list of pending types, to be processed later when
2999 the file will be. In any event, we collect the name for the
3002 esh
= ((char *) ecoff_data (cur_bfd
)->external_sym
3003 + ((fh
->isymBase
+ rn
->index
)
3004 * ecoff_backend (cur_bfd
)->external_sym_size
));
3005 (*ecoff_backend (cur_bfd
)->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3007 /* Make sure that this type of cross reference can be handled. */
3009 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
3010 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3011 && sh
.st
!= stEnum
))
3013 /* File indirect entry is corrupt. */
3014 *pname
= "<illegal>";
3015 complain (&bad_rfd_entry_complaint
,
3016 sym_name
, xref_fd
, rn
->index
);
3020 *pname
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
3022 pend
= is_pending_symbol (fh
, esh
);
3027 /* We have not yet seen this type. */
3029 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
3033 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3035 a) forward declarations of structs/unions/enums which are not
3036 defined in this compilation unit.
3037 For these the type will be void. This is a bad design decision
3038 as cross referencing across compilation units is impossible
3039 due to the missing name.
3040 b) forward declarations of structs/unions/enums which are defined
3041 later in this file or in another file in the same compilation
3042 unit. Simply cross reference those again to get the
3044 The forward references are not entered in the pending list and
3045 in the symbol table. */
3047 ecoff_swap_tir_in (bigend
,
3048 &(ecoff_data (cur_bfd
)->external_aux
3049 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3051 if (tir
.tq0
!= tqNil
)
3052 complain (&illegal_forward_tq0_complaint
, sym_name
);
3056 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3058 *pname
= "<undefined>";
3065 (ecoff_data (cur_bfd
)->external_aux
3066 + fh
->iauxBase
+ sh
.index
+ 1),
3067 tpp
, type_code
, pname
,
3068 fh
->fBigendian
, sym_name
);
3072 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3073 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3079 else if (sh
.st
== stTypedef
)
3081 /* Parse the type for a normal typedef. This might recursively call
3082 cross_ref till we get a non typedef'ed type.
3083 FIXME: This is not correct behaviour, but gdb currently
3084 cannot handle typedefs without type copying. But type copying is
3085 impossible as we might have mutual forward references between
3086 two files and the copied type would not get filled in when
3087 we later parse its definition. */
3088 *tpp
= parse_type (xref_fd
,
3089 ecoff_data (cur_bfd
)->external_aux
+ fh
->iauxBase
,
3093 (ecoff_data (cur_bfd
)->ss
3094 + fh
->issBase
+ sh
.iss
));
3098 /* Cross reference to a struct/union/enum which is defined
3099 in another file in the same compilation unit but that file
3100 has not been parsed yet.
3101 Initialize the type only, it will be filled in when
3102 it's definition is parsed. */
3103 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3105 add_pending (fh
, esh
, *tpp
);
3108 /* We used one auxent normally, two if we got a "next one" rf. */
3113 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3114 keeping the symtab sorted */
3116 static struct symbol
*
3117 mylookup_symbol (name
, block
, namespace, class)
3119 register struct block
*block
;
3120 enum namespace namespace;
3121 enum address_class
class;
3123 register int bot
, top
, inc
;
3124 register struct symbol
*sym
;
3127 top
= BLOCK_NSYMS (block
);
3131 sym
= BLOCK_SYM (block
, bot
);
3132 if (SYMBOL_NAME (sym
)[0] == inc
3133 && SYMBOL_NAMESPACE (sym
) == namespace
3134 && SYMBOL_CLASS (sym
) == class
3135 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3139 block
= BLOCK_SUPERBLOCK (block
);
3141 return mylookup_symbol (name
, block
, namespace, class);
3146 /* Add a new symbol S to a block B.
3147 Infrequently, we will need to reallocate the block to make it bigger.
3148 We only detect this case when adding to top_stack->cur_block, since
3149 that's the only time we know how big the block is. FIXME. */
3156 int nsyms
= BLOCK_NSYMS (b
)++;
3157 struct block
*origb
;
3158 struct parse_stack
*stackp
;
3160 if (b
== top_stack
->cur_block
&&
3161 nsyms
>= top_stack
->maxsyms
)
3163 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3164 /* In this case shrink_block is actually grow_block, since
3165 BLOCK_NSYMS(b) is larger than its current size. */
3167 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3169 /* Now run through the stack replacing pointers to the
3170 original block. shrink_block has already done this
3171 for the blockvector and BLOCK_FUNCTION. */
3172 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3174 if (stackp
->cur_block
== origb
)
3176 stackp
->cur_block
= b
;
3177 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3181 BLOCK_SYM (b
, nsyms
) = s
;
3184 /* Add a new block B to a symtab S */
3191 struct blockvector
*bv
= BLOCKVECTOR (s
);
3193 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3194 (sizeof (struct blockvector
)
3195 + BLOCKVECTOR_NBLOCKS (bv
)
3196 * sizeof (bv
->block
)));
3197 if (bv
!= BLOCKVECTOR (s
))
3198 BLOCKVECTOR (s
) = bv
;
3200 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3203 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3204 MIPS' linenumber encoding might need more than one byte
3205 to describe it, LAST is used to detect these continuation lines.
3207 Combining lines with the same line number seems like a bad idea.
3208 E.g: There could be a line number entry with the same line number after the
3209 prologue and GDB should not ignore it (this is a better way to find
3210 a prologue than mips_skip_prologue).
3211 But due to the compressed line table format there are line number entries
3212 for the same line which are needed to bridge the gap to the next
3213 line number entry. These entries have a bogus address info with them
3214 and we are unable to tell them from intended duplicate line number
3216 This is another reason why -ggdb debugging format is preferable. */
3219 add_line (lt
, lineno
, adr
, last
)
3220 struct linetable
*lt
;
3226 last
= -2; /* make sure we record first line */
3228 if (last
== lineno
) /* skip continuation lines */
3231 lt
->item
[lt
->nitems
].line
= lineno
;
3232 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3236 /* Sorting and reordering procedures */
3238 /* Blocks with a smaller low bound should come first */
3241 compare_blocks (arg1
, arg2
)
3245 register int addr_diff
;
3246 struct block
**b1
= (struct block
**) arg1
;
3247 struct block
**b2
= (struct block
**) arg2
;
3249 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3251 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3255 /* Sort the blocks of a symtab S.
3256 Reorder the blocks in the blockvector by code-address,
3257 as required by some MI search routines */
3263 struct blockvector
*bv
= BLOCKVECTOR (s
);
3265 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3268 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3269 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3270 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3271 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3275 * This is very unfortunate: normally all functions are compiled in
3276 * the order they are found, but if the file is compiled -O3 things
3277 * are very different. It would be nice to find a reliable test
3278 * to detect -O3 images in advance.
3280 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3281 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3282 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3283 sizeof (struct block
*),
3287 register CORE_ADDR high
= 0;
3288 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3290 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3291 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3292 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3293 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3296 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3297 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3299 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3300 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3301 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3302 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3306 /* Constructor/restructor/destructor procedures */
3308 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3309 MAXSYMS and linenumbers MAXLINES we'll put in it */
3311 static struct symtab
*
3312 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3316 struct objfile
*objfile
;
3318 struct symtab
*s
= allocate_symtab (name
, objfile
);
3320 LINETABLE (s
) = new_linetable (maxlines
);
3322 /* All symtabs must have at least two blocks */
3323 BLOCKVECTOR (s
) = new_bvect (2);
3324 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3325 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3326 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3327 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3329 s
->free_code
= free_linetable
;
3334 /* Allocate a new partial_symtab NAME */
3336 static struct partial_symtab
*
3337 new_psymtab (name
, objfile
)
3339 struct objfile
*objfile
;
3341 struct partial_symtab
*psymtab
;
3343 psymtab
= allocate_psymtab (name
, objfile
);
3345 /* Keep a backpointer to the file's symbols */
3347 psymtab
->read_symtab_private
= ((char *)
3348 obstack_alloc (&objfile
->psymbol_obstack
,
3349 sizeof (struct symloc
)));
3350 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3351 CUR_BFD (psymtab
) = cur_bfd
;
3353 /* The way to turn this into a symtab is to call... */
3354 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
3359 /* Allocate a linetable array of the given SIZE. Since the struct
3360 already includes one item, we subtract one when calculating the
3361 proper size to allocate. */
3363 static struct linetable
*
3364 new_linetable (size
)
3367 struct linetable
*l
;
3369 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3370 l
= (struct linetable
*) xmalloc (size
);
3375 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3376 I am not so sure about the 3.4 ones.
3378 Since the struct linetable already includes one item, we subtract one when
3379 calculating the proper size to allocate. */
3381 static struct linetable
*
3382 shrink_linetable (lt
)
3383 struct linetable
*lt
;
3386 return (struct linetable
*) xrealloc ((PTR
) lt
,
3387 (sizeof (struct linetable
)
3389 * sizeof (lt
->item
))));
3392 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3394 static struct blockvector
*
3398 struct blockvector
*bv
;
3401 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3402 bv
= (struct blockvector
*) xzalloc (size
);
3404 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3409 /* Allocate and zero a new block of MAXSYMS symbols */
3411 static struct block
*
3415 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3417 return (struct block
*) xzalloc (size
);
3420 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3421 Shrink_block can also be used by add_symbol to grow a block. */
3423 static struct block
*
3429 struct blockvector
*bv
= BLOCKVECTOR (s
);
3432 /* Just reallocate it and fix references to the old one */
3434 new = (struct block
*) xrealloc ((PTR
) b
,
3435 (sizeof (struct block
)
3436 + ((BLOCK_NSYMS (b
) - 1)
3437 * sizeof (struct symbol
*))));
3439 /* Should chase pointers to old one. Fortunately, that`s just
3440 the block`s function and inferior blocks */
3441 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3442 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3443 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3444 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3445 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3446 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3447 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3451 /* Create a new symbol with printname NAME */
3453 static struct symbol
*
3457 struct symbol
*s
= ((struct symbol
*)
3458 obstack_alloc (¤t_objfile
->symbol_obstack
,
3459 sizeof (struct symbol
)));
3461 memset ((PTR
) s
, 0, sizeof (*s
));
3462 SYMBOL_NAME (s
) = name
;
3463 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3464 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3468 /* Create a new type with printname NAME */
3470 static struct type
*
3476 t
= alloc_type (current_objfile
);
3477 TYPE_NAME (t
) = name
;
3478 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3483 /* Things used for calling functions in the inferior.
3484 These functions are exported to our companion
3485 mips-tdep.c file and are here because they play
3486 with the symbol-table explicitly. */
3488 /* Sigtramp: make sure we have all the necessary information
3489 about the signal trampoline code. Since the official code
3490 from MIPS does not do so, we make up that information ourselves.
3491 If they fix the library (unlikely) this code will neutralize itself. */
3498 struct block
*b
, *b0
= NULL
;
3500 sigtramp_address
= -1;
3502 /* We have to handle the following cases here:
3503 a) The Mips library has a sigtramp label within sigvec.
3504 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3505 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3508 b0
= SYMBOL_BLOCK_VALUE (s
);
3509 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3513 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3514 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3517 /* But maybe this program uses its own version of sigvec */
3521 /* Did we or MIPSco fix the library ? */
3522 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3524 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3525 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3529 sigtramp_address
= SYMBOL_VALUE (s
);
3530 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3532 /* But what symtab does it live in ? */
3533 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3536 * Ok, there goes the fix: turn it into a procedure, with all the
3537 * needed info. Note we make it a nested procedure of sigvec,
3538 * which is the way the (assembly) code is actually written.
3540 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3541 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3542 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3544 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3546 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3548 SYMBOL_BLOCK_VALUE (s
) = b
;
3549 BLOCK_START (b
) = sigtramp_address
;
3550 BLOCK_END (b
) = sigtramp_end
;
3551 BLOCK_FUNCTION (b
) = s
;
3552 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3556 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3558 struct mips_extra_func_info
*e
=
3559 ((struct mips_extra_func_info
*)
3560 xzalloc (sizeof (struct mips_extra_func_info
)));
3562 e
->numargs
= 0; /* the kernel thinks otherwise */
3563 /* align_longword(sigcontext + SIGFRAME) */
3564 e
->pdr
.frameoffset
= 0x150;
3565 e
->pdr
.framereg
= SP_REGNUM
;
3566 /* read_next_frame_reg provides the true pc at the time of signal */
3567 e
->pdr
.pcreg
= PC_REGNUM
;
3568 e
->pdr
.regmask
= -2;
3569 e
->pdr
.regoffset
= -(41 * sizeof (int));
3570 e
->pdr
.fregmask
= -1;
3571 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3572 e
->pdr
.isym
= (long) s
;
3573 e
->pdr
.adr
= sigtramp_address
;
3575 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3576 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3577 SYMBOL_VALUE (s
) = (long) e
;
3578 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3579 SYMBOL_CLASS (s
) = LOC_CONST
;
3580 SYMBOL_TYPE (s
) = builtin_type_void
;
3581 current_objfile
= NULL
;
3584 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3588 /* Fake up identical offsets for all sections. */
3590 struct section_offsets
*
3591 mipscoff_symfile_offsets (objfile
, addr
)
3592 struct objfile
*objfile
;
3595 struct section_offsets
*section_offsets
;
3598 section_offsets
= ((struct section_offsets
*)
3599 obstack_alloc (&objfile
->psymbol_obstack
,
3600 (sizeof (struct section_offsets
)
3601 + (sizeof (section_offsets
->offsets
)
3602 * (SECT_OFF_MAX
- 1)))));
3604 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3605 ANOFFSET (section_offsets
, i
) = addr
;
3607 return section_offsets
;
3610 /* Initialization */
3612 static struct sym_fns ecoff_sym_fns
=
3614 "ecoff", /* sym_name: name or name prefix of BFD target type */
3615 5, /* sym_namelen: number of significant sym_name chars */
3616 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3617 mipscoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3618 mipscoff_symfile_read
, /* sym_read: read a symbol file into symtab */
3619 mipscoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3620 mipscoff_symfile_offsets
, /* sym_offsets: dummy FIXME til implem sym reloc */
3621 NULL
/* next: pointer to next struct sym_fns */
3626 _initialize_mipsread ()
3628 add_symtab_fns (&ecoff_sym_fns
);
3630 /* Missing basic types */
3632 builtin_type_string
=
3633 init_type (TYPE_CODE_STRING
,
3634 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3636 (struct objfile
*) NULL
);
3637 builtin_type_complex
=
3638 init_type (TYPE_CODE_FLT
,
3639 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3641 (struct objfile
*) NULL
);
3642 builtin_type_double_complex
=
3643 init_type (TYPE_CODE_FLT
,
3644 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3645 0, "double complex",
3646 (struct objfile
*) NULL
);
3647 builtin_type_fixed_dec
=
3648 init_type (TYPE_CODE_INT
,
3649 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3651 (struct objfile
*) NULL
);
3652 builtin_type_float_dec
=
3653 init_type (TYPE_CODE_FLT
,
3654 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3655 0, "floating decimal",
3656 (struct objfile
*) NULL
);