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_bitsize_complaint
=
184 {"size of array target type not known, assuming %d bits", 0, 0};
186 struct complaint bad_tag_guess_complaint
=
187 {"guessed tag type of %s incorrectly", 0, 0};
189 struct complaint block_member_complaint
=
190 {"declaration block contains unhandled symbol type %d", 0, 0};
192 struct complaint stEnd_complaint
=
193 {"stEnd with storage class %d not handled", 0, 0};
195 struct complaint unknown_mips_symtype_complaint
=
196 {"unknown symbol type 0x%x", 0, 0};
198 struct complaint stab_unknown_complaint
=
199 {"unknown stabs symbol %s", 0, 0};
201 struct complaint pdr_for_nonsymbol_complaint
=
202 {"PDR for %s, but no symbol", 0, 0};
204 struct complaint pdr_static_symbol_complaint
=
205 {"can't handle PDR for static proc at 0x%x", 0, 0};
207 struct complaint bad_setjmp_pdr_complaint
=
208 {"fixing bad setjmp PDR from libc", 0, 0};
210 struct complaint bad_fbitfield_complaint
=
211 {"can't handle TIR fBitfield for %s", 0, 0};
213 struct complaint bad_rfd_entry_complaint
=
214 {"bad rfd entry for %s: file %d, index %d", 0, 0};
216 struct complaint unexpected_type_code_complaint
=
217 {"unexpected type code for %s", 0, 0};
219 struct complaint unable_to_cross_ref_complaint
=
220 {"unable to cross ref btTypedef for %s", 0, 0};
222 struct complaint illegal_forward_tq0_complaint
=
223 {"illegal tq0 in forward typedef for %s", 0, 0};
225 struct complaint illegal_forward_bt_complaint
=
226 {"illegal bt %d in forward typedef for %s", 0, 0};
228 /* Macros and extra defs */
230 /* Puns: hard to find whether -g was used and how */
232 #define MIN_GLEVEL GLEVEL_0
233 #define compare_glevel(a,b) \
234 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
235 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
237 /* Things that really are local to this module */
239 /* Remember what we deduced to be the source language of this psymtab. */
241 static enum language psymtab_language
= language_unknown
;
247 /* Pointer to current file decriptor record, and its index */
252 /* Index of current symbol */
256 /* Note how much "debuggable" this image is. We would like
257 to see at least one FDR with full symbols */
262 /* When examining .o files, report on undefined symbols */
264 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
266 /* Pseudo symbol to use when putting stabs into the symbol table. */
268 static char stabs_symbol
[] = STABS_SYMBOL
;
270 /* Extra builtin types */
272 struct type
*builtin_type_complex
;
273 struct type
*builtin_type_double_complex
;
274 struct type
*builtin_type_fixed_dec
;
275 struct type
*builtin_type_float_dec
;
276 struct type
*builtin_type_string
;
278 /* Forward declarations */
281 read_mips_symtab
PARAMS ((struct objfile
*, struct section_offsets
*));
284 read_the_mips_symtab
PARAMS ((bfd
*));
287 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int));
290 parse_partial_symbols
PARAMS ((struct objfile
*,
291 struct section_offsets
*));
294 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
295 char **, int, char *));
298 fixup_sigtramp
PARAMS ((void));
300 static struct symbol
*
301 new_symbol
PARAMS ((char *));
304 new_type
PARAMS ((char *));
306 static struct block
*
307 new_block
PARAMS ((int));
309 static struct symtab
*
310 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
312 static struct linetable
*
313 new_linetable
PARAMS ((int));
315 static struct blockvector
*
316 new_bvect
PARAMS ((int));
319 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int));
322 parse_type
PARAMS ((int, union aux_ext
*, int *, int, char *));
324 static struct symbol
*
325 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
326 enum address_class
));
328 static struct block
*
329 shrink_block
PARAMS ((struct block
*, struct symtab
*));
332 xzalloc
PARAMS ((unsigned int));
335 sort_blocks
PARAMS ((struct symtab
*));
338 compare_blocks
PARAMS ((const void *, const void *));
340 static struct partial_symtab
*
341 new_psymtab
PARAMS ((char *, struct objfile
*));
344 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
347 add_block
PARAMS ((struct block
*, struct symtab
*));
350 add_symbol
PARAMS ((struct symbol
*, struct block
*));
353 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
355 static struct linetable
*
356 shrink_linetable
PARAMS ((struct linetable
*));
359 mips_next_symbol_text
PARAMS ((void));
361 /* Things we export to other modules */
363 /* Address bounds for the signal trampoline in inferior, if any */
364 /* FIXME: Nothing really seems to use this. Why is it here? */
366 CORE_ADDR sigtramp_address
, sigtramp_end
;
369 mipscoff_new_init (ignore
)
370 struct objfile
*ignore
;
372 sigtramp_address
= 0;
373 stabsread_new_init ();
374 buildsym_new_init ();
378 mipscoff_symfile_init (objfile
)
379 struct objfile
*objfile
;
381 if (objfile
->sym_private
!= NULL
)
383 mfree (objfile
->md
, objfile
->sym_private
);
385 objfile
->sym_private
= (PTR
)
386 xmmalloc (objfile
->md
, sizeof (struct ecoff_symfile_info
));
390 mipscoff_symfile_read (objfile
, section_offsets
, mainline
)
391 struct objfile
*objfile
;
392 struct section_offsets
*section_offsets
;
395 struct cleanup
* back_to
;
397 init_minimal_symbol_collection ();
398 back_to
= make_cleanup (discard_minimal_symbols
, 0);
400 /* Now that the executable file is positioned at symbol table,
401 process it and define symbols accordingly. */
403 read_mips_symtab (objfile
, section_offsets
);
405 /* Install any minimal symbols that have been collected as the current
406 minimal symbols for this objfile. */
408 install_minimal_symbols (objfile
);
410 do_cleanups (back_to
);
413 /* Perform any local cleanups required when we are done with a particular
414 objfile. I.E, we are in the process of discarding all symbol information
415 for an objfile, freeing up all memory held for it, and unlinking the
416 objfile struct from the global list of known objfiles. */
419 mipscoff_symfile_finish (objfile
)
420 struct objfile
*objfile
;
422 if (objfile
->sym_private
!= NULL
)
424 mfree (objfile
->md
, objfile
->sym_private
);
430 /* Allocate zeroed memory */
436 PTR p
= xmalloc (size
);
442 /* Exported procedure: Builds a symtab from the PST partial one.
443 Restores the environment in effect when PST was created, delegates
444 most of the work to an ancillary procedure, and sorts
445 and reorders the symtab list at the end */
448 mipscoff_psymtab_to_symtab (pst
)
449 struct partial_symtab
*pst
;
457 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
461 next_symbol_text_func
= mips_next_symbol_text
;
463 psymtab_to_symtab_1 (pst
, pst
->filename
);
465 /* Match with global symbols. This only needs to be done once,
466 after all of the symtabs and dependencies have been read in. */
467 scan_file_globals (pst
->objfile
);
470 printf_filtered ("done.\n");
473 /* Exported procedure: Is PC in the signal trampoline code */
476 in_sigtramp (pc
, ignore
)
478 char *ignore
; /* function name */
480 if (sigtramp_address
== 0)
482 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
485 /* File-level interface functions */
487 /* Read the symtab information from file ABFD into memory. */
490 read_the_mips_symtab (abfd
)
493 if (ecoff_slurp_symbolic_info (abfd
) == false)
494 error ("Error reading symbol table: %s", bfd_errmsg (bfd_error
));
497 /* Find a file descriptor given its index RF relative to a file CF */
507 fdrs
= ecoff_data (cur_bfd
)->fdr
;
509 /* Object files do not have the RFD table, all refs are absolute */
512 (*ecoff_backend (cur_bfd
)->swap_rfd_in
)
514 ((char *) ecoff_data (cur_bfd
)->external_rfd
515 + (f
->rfdBase
+ rf
) * ecoff_backend (cur_bfd
)->external_rfd_size
),
520 /* Return a safer print NAME for a file descriptor */
527 return "<stripped file>";
530 return ecoff_data (cur_bfd
)->ss
+ f
->issBase
+ f
->rss
;
534 /* Read in and parse the symtab of the file OBJFILE. Symbols from
535 different sections are relocated via the SECTION_OFFSETS. */
538 read_mips_symtab (objfile
, section_offsets
)
539 struct objfile
*objfile
;
540 struct section_offsets
*section_offsets
;
542 cur_bfd
= objfile
->obfd
;
544 read_the_mips_symtab (objfile
->obfd
);
546 parse_partial_symbols (objfile
, section_offsets
);
549 /* Check to make sure file was compiled with -g. If not, warn the
550 user of this limitation. */
551 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
553 if (max_gdbinfo
== 0)
554 printf ("\n%s not compiled with -g, debugging support is limited.\n",
556 printf ("You should compile with -g2 or -g3 for best debugging support.\n");
562 /* Local utilities */
564 /* Map of FDR indexes to partial symtabs */
568 struct partial_symtab
*pst
; /* the psymtab proper */
569 long n_globals
; /* exported globals (external symbols) */
570 long globals_offset
; /* cumulative */
574 /* Utility stack, used to nest procedures and blocks properly.
575 It is a doubly linked list, to avoid too many alloc/free.
576 Since we might need it quite a few times it is NOT deallocated
579 static struct parse_stack
581 struct parse_stack
*next
, *prev
;
582 struct symtab
*cur_st
; /* Current symtab. */
583 struct block
*cur_block
; /* Block in it. */
584 int blocktype
; /* What are we parsing. */
585 int maxsyms
; /* Max symbols in this block. */
586 struct type
*cur_type
; /* Type we parse fields for. */
587 int cur_field
; /* Field number in cur_type. */
588 CORE_ADDR procadr
; /* Start addres of this procedure */
589 int numargs
; /* Its argument count */
592 *top_stack
; /* Top stack ptr */
595 /* Enter a new lexical context */
600 struct parse_stack
*new;
602 /* Reuse frames if possible */
603 if (top_stack
&& top_stack
->prev
)
604 new = top_stack
->prev
;
606 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
607 /* Initialize new frame with previous content */
610 register struct parse_stack
*prev
= new->prev
;
613 top_stack
->prev
= new;
615 new->next
= top_stack
;
620 /* Exit a lexical context */
628 top_stack
= top_stack
->next
;
632 /* Cross-references might be to things we haven't looked at
633 yet, e.g. type references. To avoid too many type
634 duplications we keep a quick fixup table, an array
635 of lists of references indexed by file descriptor */
639 struct mips_pending
*next
; /* link */
640 char *s
; /* the unswapped symbol */
641 struct type
*t
; /* its partial type descriptor */
645 /* Check whether we already saw symbol SH in file FH */
647 static struct mips_pending
*
648 is_pending_symbol (fh
, sh
)
652 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
653 register struct mips_pending
*p
;
654 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
656 /* Linear search is ok, list is typically no more than 10 deep */
657 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
663 /* Add a new symbol SH of type T */
666 add_pending (fh
, sh
, t
)
671 int f_idx
= fh
- ecoff_data (cur_bfd
)->fdr
;
672 struct mips_pending
*p
= is_pending_symbol (fh
, sh
);
674 /* Make sure we do not make duplicates */
677 struct mips_pending
**pending_list
= ECOFF_PENDING_LIST (current_objfile
);
679 p
= ((struct mips_pending
*)
680 obstack_alloc (¤t_objfile
->psymbol_obstack
,
681 sizeof (struct mips_pending
)));
684 p
->next
= pending_list
[f_idx
];
685 pending_list
[f_idx
] = p
;
690 /* Parsing Routines proper. */
692 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
693 For blocks, procedures and types we open a new lexical context.
694 This is basically just a big switch on the symbol's type. Argument
695 AX is the base pointer of aux symbols for this file (fh->iauxBase).
696 EXT_SH points to the unswapped symbol, which is needed for struct,
697 union, etc., types; it is NULL for an EXTR. BIGEND says whether
698 aux symbols are big-endian or little-endian. Return count of
699 SYMR's handled (normally one). */
702 parse_symbol (sh
, ax
, ext_sh
, bigend
)
708 const bfd_size_type external_sym_size
709 = ecoff_backend (cur_bfd
)->external_sym_size
;
710 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
711 ecoff_backend (cur_bfd
)->swap_sym_in
;
715 struct mips_pending
*pend
;
719 enum address_class
class;
721 long svalue
= sh
->value
;
723 if (ext_sh
== (char *) NULL
)
724 name
= ecoff_data (cur_bfd
)->ssext
+ sh
->iss
;
726 name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
->iss
;
733 case stGlobal
: /* external symbol, goes into global block */
735 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
737 s
= new_symbol (name
);
738 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
741 case stStatic
: /* static data, goes into current block. */
743 b
= top_stack
->cur_block
;
744 s
= new_symbol (name
);
745 if (sh
->sc
== scCommon
)
747 /* It is a FORTRAN common block. At least for SGI Fortran the
748 address is not in the symbol; we need to fix it later in
749 scan_file_globals. */
750 int bucket
= hashname (SYMBOL_NAME (s
));
751 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
752 global_sym_chain
[bucket
] = s
;
755 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
758 case stLocal
: /* local variable, goes into current block */
759 if (sh
->sc
== scRegister
)
761 class = LOC_REGISTER
;
762 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
766 b
= top_stack
->cur_block
;
767 s
= new_symbol (name
);
768 SYMBOL_VALUE (s
) = svalue
;
770 data
: /* Common code for symbols describing data */
771 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
772 SYMBOL_CLASS (s
) = class;
775 /* Type could be missing in a number of cases */
776 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
777 sh
->index
== 0xfffff)
778 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
780 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
+ sh
->index
, 0, bigend
, name
);
781 /* Value of a data symbol is its memory address */
784 case stParam
: /* arg to procedure, goes into current block */
786 top_stack
->numargs
++;
788 /* Special GNU C++ name. */
789 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
790 name
= "this"; /* FIXME, not alloc'd in obstack */
791 s
= new_symbol (name
);
793 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
797 /* Pass by value in register. */
798 SYMBOL_CLASS(s
) = LOC_REGPARM
;
799 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
802 /* Pass by reference on stack. */
803 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
806 /* Pass by reference in register. */
807 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
808 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
811 /* Pass by value on stack. */
812 SYMBOL_CLASS(s
) = LOC_ARG
;
815 SYMBOL_VALUE (s
) = svalue
;
816 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
+ sh
->index
, 0, bigend
, name
);
817 add_symbol (s
, top_stack
->cur_block
);
819 /* FIXME: This has not been tested. See dbxread.c */
820 /* Add the type of this parameter to the function/procedure
821 type of this block. */
822 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
826 case stLabel
: /* label, goes into current block */
827 s
= new_symbol (name
);
828 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
829 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
830 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
831 SYMBOL_TYPE (s
) = builtin_type_int
;
832 add_symbol (s
, top_stack
->cur_block
);
835 case stProc
: /* Procedure, usually goes into global block */
836 case stStaticProc
: /* Static procedure, goes into current block */
837 s
= new_symbol (name
);
838 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
839 SYMBOL_CLASS (s
) = LOC_BLOCK
;
840 /* Type of the return value */
841 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
842 t
= builtin_type_int
;
844 t
= parse_type (cur_fd
, ax
+ sh
->index
+ 1, 0, bigend
, name
);
845 b
= top_stack
->cur_block
;
846 if (sh
->st
== stProc
)
848 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
849 /* The next test should normally be true,
850 but provides a hook for nested functions
851 (which we don't want to make global). */
852 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
853 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
857 /* Make a type for the procedure itself */
859 /* FIXME: This has not been tested yet! See dbxread.c */
860 /* Generate a template for the type of this function. The
861 types of the arguments will be added as we read the symbol
863 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
865 SYMBOL_TYPE (s
) = lookup_function_type (t
);
868 /* Create and enter a new lexical context */
869 b
= new_block (top_stack
->maxsyms
);
870 SYMBOL_BLOCK_VALUE (s
) = b
;
871 BLOCK_FUNCTION (b
) = s
;
872 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
873 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
874 add_block (b
, top_stack
->cur_st
);
876 /* Not if we only have partial info */
877 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
881 top_stack
->cur_block
= b
;
882 top_stack
->blocktype
= sh
->st
;
883 top_stack
->cur_type
= SYMBOL_TYPE (s
);
884 top_stack
->cur_field
= -1;
885 top_stack
->procadr
= sh
->value
;
886 top_stack
->numargs
= 0;
889 /* Beginning of code for structure, union, and enum definitions.
890 They all share a common set of local variables, defined here. */
892 enum type_code type_code
;
898 case stStruct
: /* Start a block defining a struct type */
899 type_code
= TYPE_CODE_STRUCT
;
900 goto structured_common
;
902 case stUnion
: /* Start a block defining a union type */
903 type_code
= TYPE_CODE_UNION
;
904 goto structured_common
;
906 case stEnum
: /* Start a block defining an enum type */
907 type_code
= TYPE_CODE_ENUM
;
908 goto structured_common
;
910 case stBlock
: /* Either a lexical block, or some type */
911 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
912 goto case_stBlock_code
; /* Lexical block */
914 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
916 /* Common code for handling struct, union, enum, and/or as-yet-
917 unknown-type blocks of info about structured data. `type_code'
918 has been set to the proper TYPE_CODE, if we know it. */
921 top_stack
->blocktype
= stBlock
;
923 /* First count the number of fields and the highest value. */
926 for (ext_tsym
= ext_sh
+ external_sym_size
;
928 ext_tsym
+= external_sym_size
)
932 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
940 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
941 /* If the type of the member is Nil (or Void),
942 without qualifiers, assume the tag is an
944 if (tsym
.index
== indexNil
)
945 type_code
= TYPE_CODE_ENUM
;
948 ecoff_swap_tir_in (bigend
,
949 &ax
[tsym
.index
].a_ti
,
951 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
953 type_code
= TYPE_CODE_ENUM
;
956 if (tsym
.value
> max_value
)
957 max_value
= tsym
.value
;
966 /* This is a no-op; is it trying to tell us something
967 we should be checking? */
968 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
972 /* This is something like a struct within a
973 struct. Skip over the fields of the inner
974 struct. The -1 is because the for loop will
975 increment ext_tsym. */
976 ext_tsym
= ((char *) ecoff_data (cur_bfd
)->external_sym
977 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
978 * external_sym_size
));
984 /* mips cc puts out a typedef for struct x if it is not yet
985 defined when it encounters
986 struct y { struct x *xp; };
991 complain (&block_member_complaint
, tsym
.st
);
996 /* In an stBlock, there is no way to distinguish structs,
997 unions, and enums at this point. This is a bug in the
998 original design (that has been fixed with the recent
999 addition of the stStruct, stUnion, and stEnum symbol
1000 types.) The way you can tell is if/when you see a variable
1001 or field of that type. In that case the variable's type
1002 (in the AUX table) says if the type is struct, union, or
1003 enum, and points back to the stBlock here. So you can
1004 patch the tag kind up later - but only if there actually is
1005 a variable or field of that type.
1007 So until we know for sure, we will guess at this point.
1009 If the first member has index==indexNil or a void type,
1010 assume we have an enumeration.
1011 Otherwise, if there is more than one member, and all
1012 the members have offset 0, assume we have a union.
1013 Otherwise, assume we have a struct.
1015 The heuristic could guess wrong in the case of of an
1016 enumeration with no members or a union with one (or zero)
1017 members, or when all except the last field of a struct have
1018 width zero. These are uncommon and/or illegal situations,
1019 and in any case guessing wrong probably doesn't matter
1022 But if we later do find out we were wrong, we fixup the tag
1023 kind. Members of an enumeration must be handled
1024 differently from struct/union fields, and that is harder to
1025 patch up, but luckily we shouldn't need to. (If there are
1026 any enumeration members, we can tell for sure it's an enum
1029 if (type_code
== TYPE_CODE_UNDEF
)
1030 if (nfields
> 1 && max_value
== 0)
1031 type_code
= TYPE_CODE_UNION
;
1033 type_code
= TYPE_CODE_STRUCT
;
1035 /* Create a new type or use the pending type. */
1036 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1037 if (pend
== (struct mips_pending
*) NULL
)
1039 t
= new_type (NULL
);
1040 add_pending (cur_fdr
, ext_sh
, t
);
1045 /* Alpha cc unnamed structs do not get a tag name. */
1047 TYPE_TAG_NAME (t
) = NULL
;
1049 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1052 TYPE_CODE (t
) = type_code
;
1053 TYPE_LENGTH (t
) = sh
->value
;
1054 TYPE_NFIELDS (t
) = nfields
;
1055 TYPE_FIELDS (t
) = f
= ((struct field
*)
1057 nfields
* sizeof (struct field
)));
1059 if (type_code
== TYPE_CODE_ENUM
)
1061 /* This is a non-empty enum. */
1062 for (ext_tsym
= ext_sh
+ external_sym_size
;
1064 ext_tsym
+= external_sym_size
)
1067 struct symbol
*enum_sym
;
1069 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1071 if (tsym
.st
!= stMember
)
1074 f
->bitpos
= tsym
.value
;
1076 f
->name
= (ecoff_data (cur_bfd
)->ss
1081 enum_sym
= ((struct symbol
*)
1082 obstack_alloc (¤t_objfile
->symbol_obstack
,
1083 sizeof (struct symbol
)));
1084 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1085 SYMBOL_NAME (enum_sym
) = f
->name
;
1086 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1087 SYMBOL_TYPE (enum_sym
) = t
;
1088 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1089 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1090 add_symbol (enum_sym
, top_stack
->cur_block
);
1092 /* Skip the stMembers that we've handled. */
1097 /* make this the current type */
1098 top_stack
->cur_type
= t
;
1099 top_stack
->cur_field
= 0;
1101 /* Do not create a symbol for alpha cc unnamed structs. */
1104 s
= new_symbol (name
);
1105 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1106 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1107 SYMBOL_VALUE (s
) = 0;
1108 SYMBOL_TYPE (s
) = t
;
1110 /* gcc puts out an empty struct for an opaque struct definitions. */
1111 if (TYPE_NFIELDS (t
) == 0)
1113 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1114 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1116 add_symbol (s
, top_stack
->cur_block
);
1119 /* End of local variables shared by struct, union, enum, and
1120 block (as yet unknown struct/union/enum) processing. */
1124 /* beginnning of (code) block. Value of symbol
1125 is the displacement from procedure start */
1126 push_parse_stack ();
1127 top_stack
->blocktype
= stBlock
;
1128 b
= new_block (top_stack
->maxsyms
);
1129 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1130 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1131 top_stack
->cur_block
= b
;
1132 add_block (b
, top_stack
->cur_st
);
1135 case stEnd
: /* end (of anything) */
1136 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1138 /* Finished with type */
1139 top_stack
->cur_type
= 0;
1141 else if (sh
->sc
== scText
&&
1142 (top_stack
->blocktype
== stProc
||
1143 top_stack
->blocktype
== stStaticProc
))
1145 /* Finished with procedure */
1146 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1147 struct mips_extra_func_info
*e
;
1151 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1153 /* Make up special symbol to contain procedure specific info */
1154 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1155 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1156 SYMBOL_CLASS (s
) = LOC_CONST
;
1157 SYMBOL_TYPE (s
) = builtin_type_void
;
1158 e
= ((struct mips_extra_func_info
*)
1159 obstack_alloc (¤t_objfile
->symbol_obstack
,
1160 sizeof (struct mips_extra_func_info
)));
1161 SYMBOL_VALUE (s
) = (long) e
;
1162 e
->numargs
= top_stack
->numargs
;
1163 add_symbol (s
, top_stack
->cur_block
);
1165 /* Reallocate symbols, saving memory */
1166 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1168 /* f77 emits proc-level with address bounds==[0,0],
1169 So look for such child blocks, and patch them. */
1170 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1172 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1173 if (BLOCK_SUPERBLOCK (b_bad
) == b
1174 && BLOCK_START (b_bad
) == top_stack
->procadr
1175 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1177 BLOCK_START (b_bad
) = BLOCK_START (b
);
1178 BLOCK_END (b_bad
) = BLOCK_END (b
);
1182 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1184 /* End of (code) block. The value of the symbol is the
1185 displacement from the procedure`s start address of the
1186 end of this block. */
1187 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1188 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1190 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1192 /* End of file. Pop parse stack and ignore. Higher
1193 level code deals with this. */
1197 complain (&stEnd_complaint
, sh
->sc
);
1199 pop_parse_stack (); /* restore previous lexical context */
1202 case stMember
: /* member of struct or union */
1203 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1205 f
->bitpos
= sh
->value
;
1207 f
->type
= parse_type (cur_fd
, ax
+ sh
->index
, &f
->bitsize
, bigend
, name
);
1210 case stTypedef
: /* type definition */
1211 /* Typedefs for forward declarations and opaque structs from alpha cc
1212 are handled by cross_ref, skip them. */
1216 /* Parse the type or use the pending type. */
1217 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1218 if (pend
== (struct mips_pending
*) NULL
)
1220 t
= parse_type (cur_fd
, ax
+ sh
->index
, (int *)NULL
, bigend
, name
);
1221 add_pending (cur_fdr
, ext_sh
, t
);
1226 /* mips cc puts out a typedef with the name of the struct for forward
1227 declarations. These should not go into the symbol table and
1228 TYPE_NAME should not be set for them.
1229 They can't be distinguished from an intentional typedef to
1230 the same name however:
1232 struct x { int ix; int jx; };
1236 struct xx {int ixx; int jxx; };
1237 generates a cross referencing stTypedef for x and xx.
1238 The user visible effect of this is that the type of a pointer
1239 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1240 The problem is fixed with alpha cc. */
1242 s
= new_symbol (name
);
1243 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1244 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1245 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1246 SYMBOL_TYPE (s
) = t
;
1247 add_symbol (s
, top_stack
->cur_block
);
1249 /* Incomplete definitions of structs should not get a name. */
1250 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1251 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1252 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1253 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1255 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1256 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1258 /* If we are giving a name to a type such as "pointer to
1259 foo" or "function returning foo", we better not set
1260 the TYPE_NAME. If the program contains "typedef char
1261 *caddr_t;", we don't want all variables of type char
1262 * to print as caddr_t. This is not just a
1263 consequence of GDB's type management; CC and GCC (at
1264 least through version 2.4) both output variables of
1265 either type char * or caddr_t with the type
1266 refering to the stTypedef symbol for caddr_t. If a future
1267 compiler cleans this up it GDB is not ready for it
1268 yet, but if it becomes ready we somehow need to
1269 disable this check (without breaking the PCC/GCC2.4
1274 Fortunately, this check seems not to be necessary
1275 for anything except pointers or functions. */
1278 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1282 case stFile
: /* file name */
1283 push_parse_stack ();
1284 top_stack
->blocktype
= sh
->st
;
1287 /* I`ve never seen these for C */
1289 break; /* register relocation */
1291 break; /* forwarding address */
1293 break; /* constant */
1295 complain (&unknown_mips_symtype_complaint
, sh
->st
);
1302 /* Parse the type information provided in the raw AX entries for
1303 the symbol SH. Return the bitfield size in BS, in case.
1304 We must byte-swap the AX entries before we use them; BIGEND says whether
1305 they are big-endian or little-endian (from fh->fBigendian). */
1307 static struct type
*
1308 parse_type (fd
, ax
, bs
, bigend
, sym_name
)
1315 /* Null entries in this map are treated specially */
1316 static struct type
**map_bt
[] =
1318 &builtin_type_void
, /* btNil */
1320 &builtin_type_char
, /* btChar */
1321 &builtin_type_unsigned_char
,/* btUChar */
1322 &builtin_type_short
, /* btShort */
1323 &builtin_type_unsigned_short
, /* btUShort */
1324 &builtin_type_int
, /* btInt */
1325 &builtin_type_unsigned_int
, /* btUInt */
1326 &builtin_type_long
, /* btLong */
1327 &builtin_type_unsigned_long
,/* btULong */
1328 &builtin_type_float
, /* btFloat */
1329 &builtin_type_double
, /* btDouble */
1336 &builtin_type_complex
, /* btComplex */
1337 &builtin_type_double_complex
, /* btDComplex */
1339 &builtin_type_fixed_dec
, /* btFixedDec */
1340 &builtin_type_float_dec
, /* btFloatDec */
1341 &builtin_type_string
, /* btString */
1344 &builtin_type_void
, /* btVoid */
1345 0, /* DEC C++: Pointer to member */
1346 0, /* DEC C++: Virtual function table */
1347 0, /* DEC C++: Class (Record) */
1348 &builtin_type_long
, /* btLong64 */
1349 &builtin_type_unsigned_long
, /* btULong64 */
1350 &builtin_type_long_long
, /* btLongLong64 */
1351 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1352 &builtin_type_unsigned_long
, /* btAdr64 */
1353 &builtin_type_long
, /* btInt64 */
1354 &builtin_type_unsigned_long
, /* btUInt64 */
1358 struct type
*tp
= 0;
1360 enum type_code type_code
= TYPE_CODE_UNDEF
;
1362 /* Use aux as a type information record, map its basic type. */
1364 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1365 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1367 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1368 return builtin_type_int
;
1372 tp
= *map_bt
[t
->bt
];
1377 /* Cannot use builtin types -- build our own */
1381 tp
= lookup_pointer_type (builtin_type_void
);
1384 type_code
= TYPE_CODE_STRUCT
;
1387 type_code
= TYPE_CODE_UNION
;
1390 type_code
= TYPE_CODE_ENUM
;
1393 type_code
= TYPE_CODE_RANGE
;
1396 type_code
= TYPE_CODE_SET
;
1399 /* alpha cc uses this for typedefs. The true type will be
1400 obtained by crossreferencing below. */
1401 type_code
= TYPE_CODE_ERROR
;
1404 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1405 return builtin_type_int
;
1409 /* Skip over any further type qualifiers (FIXME). */
1412 /* This is the way it would work if the compiler worked */
1417 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t1
);
1419 while (t1
->continued
);
1422 /* Move on to next aux */
1427 /* Inhibit core dumps with some cfront generated objects that
1429 if (bs
== (int *)NULL
)
1431 complain (&bad_fbitfield_complaint
, sym_name
);
1432 return builtin_type_int
;
1434 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1438 /* All these types really point to some (common) MIPS type
1439 definition, and only the type-qualifiers fully identify
1440 them. We'll make the same effort at sharing. */
1441 if (t
->bt
== btStruct
||
1445 /* btSet (I think) implies that the name is a tag name, not a typedef
1446 name. This apparently is a MIPS extension for C sets. */
1451 /* Try to cross reference this type, build new type on failure. */
1452 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1453 if (tp
== (struct type
*) NULL
)
1454 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1456 /* Make sure that TYPE_CODE(tp) has an expected type code.
1457 Any type may be returned from cross_ref if file indirect entries
1459 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1460 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1461 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1463 complain (&unexpected_type_code_complaint
, sym_name
);
1468 /* Usually, TYPE_CODE(tp) is already type_code. The main
1469 exception is if we guessed wrong re struct/union/enum. */
1470 if (TYPE_CODE (tp
) != type_code
)
1472 complain (&bad_tag_guess_complaint
, sym_name
);
1473 TYPE_CODE (tp
) = type_code
;
1475 /* Do not set the tag name if it is a compiler generated tag name
1476 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1477 if (name
[0] == '.' || name
[0] == '\0')
1478 TYPE_TAG_NAME (tp
) = NULL
;
1479 else if (TYPE_TAG_NAME (tp
) == NULL
1480 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1481 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1482 ¤t_objfile
->type_obstack
);
1486 /* All these types really point to some (common) MIPS type
1487 definition, and only the type-qualifiers fully identify
1488 them. We'll make the same effort at sharing.
1489 FIXME: btIndirect cannot happen here as it is handled by the
1490 switch t->bt above. And we are not doing any guessing on range types. */
1491 if (t
->bt
== btIndirect
||
1496 /* Try to cross reference this type, build new type on failure. */
1497 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1498 if (tp
== (struct type
*) NULL
)
1499 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1501 /* Make sure that TYPE_CODE(tp) has an expected type code.
1502 Any type may be returned from cross_ref if file indirect entries
1504 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1506 complain (&unexpected_type_code_complaint
, sym_name
);
1510 /* Usually, TYPE_CODE(tp) is already type_code. The main
1511 exception is if we guessed wrong re struct/union/enum. */
1512 if (TYPE_CODE (tp
) != type_code
)
1514 complain (&bad_tag_guess_complaint
, sym_name
);
1515 TYPE_CODE (tp
) = type_code
;
1517 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1518 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1519 ¤t_objfile
->type_obstack
);
1522 if (t
->bt
== btTypedef
)
1526 /* Try to cross reference this type, it should succeed. */
1527 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1528 if (tp
== (struct type
*) NULL
)
1530 complain (&unable_to_cross_ref_complaint
, sym_name
);
1531 tp
= builtin_type_int
;
1535 /* Deal with range types */
1536 if (t
->bt
== btRange
)
1538 TYPE_NFIELDS (tp
) = 2;
1539 TYPE_FIELDS (tp
) = ((struct field
*)
1540 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1541 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1542 ¤t_objfile
->type_obstack
);
1543 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1545 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1546 ¤t_objfile
->type_obstack
);
1547 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1551 /* Parse all the type qualifiers now. If there are more
1552 than 6 the game will continue in the next aux */
1554 #define PARSE_TQ(tq) \
1555 if (t->tq != tqNil) ax += upgrade_type(fd, &tp, t->tq, ax, bigend);
1557 again
:PARSE_TQ (tq0
);
1568 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1574 /* Make up a complex type from a basic one. Type is passed by
1575 reference in TPP and side-effected as necessary. The type
1576 qualifier TQ says how to handle the aux symbols at AX for
1577 the symbol SX we are currently analyzing. BIGEND says whether
1578 aux symbols are big-endian or little-endian.
1579 Returns the number of aux symbols we parsed. */
1582 upgrade_type (fd
, tpp
, tq
, ax
, bigend
)
1592 /* Used in array processing */
1603 t
= lookup_pointer_type (*tpp
);
1608 t
= lookup_function_type (*tpp
);
1615 /* Determine and record the domain type (type of index) */
1616 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1622 rf
= AUX_GET_ISYM (bigend
, ax
);
1625 fh
= get_rfd (fd
, rf
);
1627 indx
= parse_type (fd
,
1628 (ecoff_data (cur_bfd
)->external_aux
1631 (int *) NULL
, bigend
, "<array index>");
1633 /* Get the bounds, and create the array type. */
1635 lower
= AUX_GET_DNLOW (bigend
, ax
);
1637 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1639 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1641 range
= create_range_type ((struct type
*) NULL
, indx
,
1644 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1646 /* Check whether supplied array element bit size matches
1647 the known size of the element type. If this complaint
1648 ends up not happening, we can remove this code. It's
1649 here because we aren't sure we understand this *&%&$
1651 id
= TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) << 3; /* bitsize */
1654 /* Most likely an undefined type */
1656 TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) = id
>> 3;
1659 complain (&array_bitsize_complaint
, rf
);
1665 /* Volatile -- currently ignored */
1669 /* Const -- currently ignored */
1673 complain (&unknown_type_qual_complaint
, tq
);
1679 /* Parse a procedure descriptor record PR. Note that the procedure is
1680 parsed _after_ the local symbols, now we just insert the extra
1681 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1682 already been placed in the procedure's main block. Note also that
1683 images that have been partially stripped (ld -x) have been deprived
1684 of local symbols, and we have to cope with them here. FIRST_OFF is
1685 the offset of the first procedure for this FDR; we adjust the
1686 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1687 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1688 in question, or NULL to use top_stack->cur_block. */
1690 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1693 parse_procedure (pr
, search_symtab
, first_off
)
1695 struct symtab
*search_symtab
;
1696 unsigned long first_off
;
1698 struct symbol
*s
, *i
;
1700 struct mips_extra_func_info
*e
;
1703 /* Simple rule to find files linked "-x" */
1704 if (cur_fdr
->rss
== -1)
1708 /* Static procedure at address pr->adr. Sigh. */
1709 complain (&pdr_static_symbol_complaint
, pr
->adr
);
1717 (*ecoff_backend (cur_bfd
)->swap_ext_in
)
1719 ((char *) ecoff_data (cur_bfd
)->external_ext
1720 + pr
->isym
* ecoff_backend (cur_bfd
)->external_ext_size
),
1722 sh_name
= ecoff_data (cur_bfd
)->ssext
+ she
.asym
.iss
;
1730 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
1732 ((char *) ecoff_data (cur_bfd
)->external_sym
1733 + ((cur_fdr
->isymBase
+ pr
->isym
)
1734 * ecoff_backend (cur_bfd
)->external_sym_size
)),
1736 sh_name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1739 if (search_symtab
!= NULL
)
1742 /* This loses both in the case mentioned (want a static, find a global),
1743 but also if we are looking up a non-mangled name which happens to
1744 match the name of a mangled function. */
1745 /* We have to save the cur_fdr across the call to lookup_symbol.
1746 If the pdr is for a static function and if a global function with
1747 the same name exists, lookup_symbol will eventually read in the symtab
1748 for the global function and clobber cur_fdr. */
1749 FDR
*save_cur_fdr
= cur_fdr
;
1750 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1751 cur_fdr
= save_cur_fdr
;
1755 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1761 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1762 VAR_NAMESPACE
, LOC_BLOCK
);
1766 b
= SYMBOL_BLOCK_VALUE (s
);
1770 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1774 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1775 s
= new_symbol (sh_name
);
1776 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1777 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1778 /* Donno its type, hope int is ok */
1779 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1780 add_symbol (s
, top_stack
->cur_block
);
1781 /* Wont have symbols for this one */
1783 SYMBOL_BLOCK_VALUE (s
) = b
;
1784 BLOCK_FUNCTION (b
) = s
;
1785 BLOCK_START (b
) = pr
->adr
;
1786 /* BOUND used to be the end of procedure's text, but the
1787 argument is no longer passed in. */
1788 BLOCK_END (b
) = bound
;
1789 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1790 add_block (b
, top_stack
->cur_st
);
1794 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1798 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1800 e
->pdr
.isym
= (long) s
;
1801 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1803 /* Correct incorrect setjmp procedure descriptor from the library
1804 to make backtrace through setjmp work. */
1805 if (e
->pdr
.pcreg
== 0 && strcmp (sh_name
, "setjmp") == 0)
1807 complain (&bad_setjmp_pdr_complaint
, 0);
1808 e
->pdr
.pcreg
= RA_REGNUM
;
1809 e
->pdr
.regmask
= 0x80000000;
1810 e
->pdr
.regoffset
= -4;
1815 /* Parse the external symbol ES. Just call parse_symbol() after
1816 making sure we know where the aux are for it. For procedures,
1817 parsing of the PDRs has already provided all the needed
1818 information, we only parse them if SKIP_PROCEDURES is false,
1819 and only if this causes no symbol duplication.
1820 BIGEND says whether aux entries are big-endian or little-endian.
1822 This routine clobbers top_stack->cur_block and ->cur_st. */
1825 parse_external (es
, skip_procedures
, bigend
)
1827 int skip_procedures
;
1832 if (es
->ifd
!= ifdNil
)
1835 cur_fdr
= ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
1836 ax
= ecoff_data (cur_bfd
)->external_aux
+ cur_fdr
->iauxBase
;
1840 cur_fdr
= ecoff_data (cur_bfd
)->fdr
;
1844 /* Reading .o files */
1845 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1848 switch (es
->asym
.st
)
1868 /* FIXME: Turn this into a complaint? */
1870 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1872 ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1873 fdr_name (cur_fdr
));
1877 switch (es
->asym
.st
)
1880 /* If we have full symbols we do not need more */
1881 if (skip_procedures
)
1883 if (mylookup_symbol (ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1884 top_stack
->cur_block
,
1885 VAR_NAMESPACE
, LOC_BLOCK
))
1890 /* Note that the case of a symbol with indexNil must be handled
1891 anyways by parse_symbol(). */
1892 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1899 /* Parse the line number info for file descriptor FH into
1900 GDB's linetable LT. MIPS' encoding requires a little bit
1901 of magic to get things out. Note also that MIPS' line
1902 numbers can go back and forth, apparently we can live
1903 with that and do not need to reorder our linetables */
1906 parse_lines (fh
, pr
, lt
)
1909 struct linetable
*lt
;
1911 unsigned char *base
;
1913 int delta
, count
, lineno
= 0;
1914 unsigned long first_off
= pr
->adr
;
1916 if (fh
->cbLine
== 0)
1919 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1921 /* Scan by procedure descriptors */
1923 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1928 /* No code for this one */
1929 if (pr
->iline
== ilineNil
||
1930 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1933 /* Aurgh! To know where to stop expanding we must look-ahead. */
1934 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1935 if (pr
[l
].iline
!= -1)
1937 if (l
== (fh
->cpd
- j
))
1942 /* When procedures are moved around the linenumbers are
1943 attributed to the next procedure up. */
1944 if (pr
->iline
>= halt
)
1947 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
+ pr
->cbLineOffset
;
1948 adr
= fh
->adr
+ pr
->adr
- first_off
;
1949 l
= adr
>> 2; /* in words */
1950 halt
+= (adr
>> 2) - pr
->iline
;
1951 for (lineno
= pr
->lnLow
; l
< halt
;)
1953 count
= *base
& 0x0f;
1954 delta
= *base
++ >> 4;
1959 delta
= (base
[0] << 8) | base
[1];
1960 if (delta
>= 0x8000)
1964 lineno
+= delta
; /* first delta is 0 */
1965 k
= add_line (lt
, lineno
, l
, k
);
1971 /* Master parsing procedure for first-pass reading of file symbols
1972 into a partial_symtab. */
1975 parse_partial_symbols (objfile
, section_offsets
)
1976 struct objfile
*objfile
;
1977 struct section_offsets
*section_offsets
;
1979 const struct ecoff_backend_data
* const backend
= ecoff_backend (cur_bfd
);
1980 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
1981 const bfd_size_type external_rfd_size
= backend
->external_rfd_size
;
1982 const bfd_size_type external_ext_size
= backend
->external_ext_size
;
1983 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
1984 = backend
->swap_ext_in
;
1985 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
1986 = backend
->swap_sym_in
;
1987 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
1988 = backend
->swap_rfd_in
;
1990 HDRR
*hdr
= &ecoff_data (cur_bfd
)->symbolic_header
;
1991 /* Running pointers */
1996 register EXTR
*ext_in
;
1999 struct partial_symtab
*pst
;
2001 int past_first_source_file
= 0;
2003 /* List of current psymtab's include files */
2004 char **psymtab_include_list
;
2005 int includes_allocated
;
2008 struct pst_map
*fdr_to_pst
;
2009 /* Index within current psymtab dependency list */
2010 struct partial_symtab
**dependency_list
;
2011 int dependencies_used
, dependencies_allocated
;
2012 struct cleanup
*old_chain
;
2014 enum language prev_language
;
2016 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2017 sizeof (EXTR
) * hdr
->iextMax
);
2019 includes_allocated
= 30;
2021 psymtab_include_list
= (char **) alloca (includes_allocated
*
2023 next_symbol_text_func
= mips_next_symbol_text
;
2025 dependencies_allocated
= 30;
2026 dependencies_used
= 0;
2028 (struct partial_symtab
**) alloca (dependencies_allocated
*
2029 sizeof (struct partial_symtab
*));
2031 last_source_file
= NULL
;
2036 * Only parse the Local and External symbols, and the Relative FDR.
2037 * Fixup enough of the loader symtab to be able to use it.
2038 * Allocate space only for the file's portions we need to
2043 max_glevel
= MIN_GLEVEL
;
2045 /* Allocate the map FDR -> PST.
2046 Minor hack: -O3 images might claim some global data belongs
2047 to FDR -1. We`ll go along with that */
2048 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2049 old_chain
= make_cleanup (free
, fdr_to_pst
);
2052 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2053 fdr_to_pst
[-1].pst
= pst
;
2057 /* Allocate the global pending list. */
2058 ECOFF_PENDING_LIST (objfile
) =
2059 ((struct mips_pending
**)
2060 obstack_alloc (&objfile
->psymbol_obstack
,
2061 hdr
->ifdMax
* sizeof (struct mips_pending
*)));
2062 memset ((PTR
) ECOFF_PENDING_LIST (objfile
), 0,
2063 hdr
->ifdMax
* sizeof (struct mips_pending
*));
2065 /* Pass 0 over external syms: swap them in. */
2066 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2067 make_cleanup (free
, ext_block
);
2069 ext_out
= (char *) ecoff_data (cur_bfd
)->external_ext
;
2070 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2072 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2073 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2075 /* Pass 1 over external syms: Presize and partition the list */
2077 ext_in_end
= ext_in
+ hdr
->iextMax
;
2078 for (; ext_in
< ext_in_end
; ext_in
++)
2079 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2081 /* Pass 1.5 over files: partition out global symbol space */
2083 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2085 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2086 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2087 fdr_to_pst
[f_idx
].n_globals
= 0;
2090 /* Pass 2 over external syms: fill in external symbols */
2092 ext_in_end
= ext_in
+ hdr
->iextMax
;
2093 for (; ext_in
< ext_in_end
; ext_in
++)
2095 enum minimal_symbol_type ms_type
= mst_text
;
2097 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2098 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2100 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2103 name
= ecoff_data (cur_bfd
)->ssext
+ ext_in
->asym
.iss
;
2104 switch (ext_in
->asym
.st
)
2109 ms_type
= mst_file_text
;
2112 if (ext_in
->asym
.sc
== scData
2113 || ext_in
->asym
.sc
== scSData
2114 || ext_in
->asym
.sc
== scRData
)
2120 if (ext_in
->asym
.sc
== scAbs
)
2122 else if (ext_in
->asym
.sc
== scText
)
2124 else if (ext_in
->asym
.sc
== scData
2125 || ext_in
->asym
.sc
== scSData
2126 || ext_in
->asym
.sc
== scRData
)
2132 ms_type
= mst_unknown
;
2133 complain (&unknown_ext_complaint
, name
);
2135 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
);
2138 /* Pass 3 over files, over local syms: fill in static symbols */
2139 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2141 struct partial_symtab
*save_pst
;
2144 cur_fdr
= fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
2148 fdr_to_pst
[f_idx
].pst
= NULL
;
2151 pst
= start_psymtab_common (objfile
, section_offsets
,
2153 fh
->cpd
? fh
->adr
: 0,
2154 objfile
->global_psymbols
.next
,
2155 objfile
->static_psymbols
.next
);
2156 pst
->read_symtab_private
= ((char *)
2157 obstack_alloc (&objfile
->psymbol_obstack
,
2158 sizeof (struct symloc
)));
2159 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2162 FDR_IDX (pst
) = f_idx
;
2163 CUR_BFD (pst
) = cur_bfd
;
2165 /* The way to turn this into a symtab is to call... */
2166 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
2168 /* Set up language for the pst.
2169 The language from the FDR is used if it is unambigious (e.g. cfront
2170 with native cc and g++ will set the language to C).
2171 Otherwise we have to deduce the language from the filename.
2172 Native ecoff has every header file in a separate FDR, so
2173 deduce_language_from_filename will return language_unknown for
2174 a header file, which is not what we want.
2175 But the FDRs for the header files are after the FDR for the source
2176 file, so we can assign the language of the source file to the
2177 following header files. Then we save the language in the private
2178 pst data so that we can reuse it when building symtabs. */
2179 prev_language
= psymtab_language
;
2183 case langCplusplusV2
:
2184 psymtab_language
= language_cplus
;
2187 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2190 if (psymtab_language
== language_unknown
)
2191 psymtab_language
= prev_language
;
2192 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2194 pst
->texthigh
= pst
->textlow
;
2196 /* For stabs-in-ecoff files, the second symbol must be @stab.
2197 This symbol is emitted by mips-tfile to signal that the
2198 current object file uses encapsulated stabs instead of mips
2199 ecoff for local symbols. (It is the second symbol because
2200 the first symbol is the stFile used to signal the start of a
2202 processing_gcc_compilation
= 0;
2205 (*swap_sym_in
) (cur_bfd
,
2206 ((char *) ecoff_data (cur_bfd
)->external_sym
2207 + (fh
->isymBase
+ 1) * external_sym_size
),
2209 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2211 processing_gcc_compilation
= 2;
2214 if (processing_gcc_compilation
!= 0)
2216 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2221 (*swap_sym_in
) (cur_bfd
,
2222 ((char *) ecoff_data (cur_bfd
)->external_sym
2223 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2225 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2226 if (!ECOFF_IS_STAB (&sh
))
2228 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2230 long procaddr
= sh
.value
;
2234 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2235 (ecoff_data (cur_bfd
)->external_aux
2238 (*swap_sym_in
) (cur_bfd
,
2240 ecoff_data (cur_bfd
)->external_sym
)
2241 + ((fh
->isymBase
+ isym
- 1)
2242 * external_sym_size
)),
2246 long high
= procaddr
+ sh
.value
;
2247 if (high
> pst
->texthigh
)
2248 pst
->texthigh
= high
;
2253 #define SET_NAMESTRING() \
2254 namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
2255 #define CUR_SYMBOL_TYPE type_code
2256 #define CUR_SYMBOL_VALUE sh.value
2257 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2259 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2260 #define HANDLE_RBRAC(val) \
2261 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2262 #include "partial-stab.h"
2267 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2270 enum address_class
class;
2272 (*swap_sym_in
) (cur_bfd
,
2273 ((char *) ecoff_data (cur_bfd
)->external_sym
2274 + ((fh
->isymBase
+ cur_sdx
)
2275 * external_sym_size
)),
2278 if (ECOFF_IS_STAB (&sh
))
2284 /* Non absolute static symbols go into the minimal table. */
2285 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2286 || (sh
.index
== indexNil
2287 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2289 /* FIXME, premature? */
2294 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2302 case stStaticProc
: /* Function */
2303 /* I believe this is used only for file-local functions.
2304 The comment in symconst.h ("load time only static procs")
2305 isn't particularly clear on this point. */
2306 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
);
2309 case stProc
: /* Asm labels apparently */
2310 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2311 VAR_NAMESPACE
, LOC_BLOCK
,
2312 objfile
->static_psymbols
, sh
.value
,
2313 psymtab_language
, objfile
);
2314 /* Skip over procedure to next one. */
2315 if (sh
.index
>= hdr
->iauxMax
)
2317 /* Should not happen, but does when cross-compiling
2318 with the MIPS compiler. FIXME -- pull later. */
2319 complain (&index_complaint
, name
);
2320 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2323 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2324 (ecoff_data (cur_bfd
)->external_aux
2327 procaddr
= sh
.value
;
2329 if (new_sdx
<= cur_sdx
)
2331 /* This should not happen either... FIXME. */
2332 complain (&aux_index_complaint
, name
);
2333 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2337 (*swap_sym_in
) (cur_bfd
,
2338 ((char *) ecoff_data (cur_bfd
)->external_sym
2339 + ((fh
->isymBase
+ cur_sdx
- 1)
2340 * external_sym_size
)),
2344 high
= procaddr
+ sh
.value
;
2345 if (high
> pst
->texthigh
)
2346 pst
->texthigh
= high
;
2349 case stStatic
: /* Variable */
2350 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2351 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
);
2353 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
);
2357 case stTypedef
:/* Typedef */
2358 class = LOC_TYPEDEF
;
2361 case stConstant
: /* Constant decl */
2368 case stBlock
: /* { }, str, un, enum*/
2369 if (sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2371 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2372 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2373 objfile
->static_psymbols
,
2375 psymtab_language
, objfile
);
2377 /* Skip over the block */
2379 if (new_sdx
<= cur_sdx
)
2381 /* This happens with the Ultrix kernel. */
2382 complain (&block_index_complaint
, name
);
2383 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2388 case stFile
: /* File headers */
2389 case stLabel
: /* Labels */
2390 case stEnd
: /* Ends of files */
2393 case stLocal
: /* Local variables */
2394 /* Normally these are skipped because we skip over
2395 all blocks we see. However, these can occur
2396 as visible symbols in a .h file that contains code. */
2400 /* Both complaints are valid: one gives symbol name,
2401 the other the offending symbol type. */
2402 complain (&unknown_sym_complaint
, name
);
2403 complain (&unknown_st_complaint
, sh
.st
);
2407 /* Use this gdb symbol */
2408 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2409 VAR_NAMESPACE
, class,
2410 objfile
->static_psymbols
, sh
.value
,
2411 psymtab_language
, objfile
);
2413 cur_sdx
++; /* Go to next file symbol */
2416 /* Now do enter the external symbols. */
2417 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2418 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2419 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2420 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2421 for (; --cur_sdx
>= 0; ext_ptr
++)
2423 enum address_class
class;
2427 if (ext_ptr
->ifd
!= f_idx
)
2429 psh
= &ext_ptr
->asym
;
2440 complain (&unknown_ext_complaint
,
2441 ecoff_data (cur_bfd
)->ssext
+ psh
->iss
);
2442 /* Fall through, pretend it's global. */
2447 name
= ecoff_data (cur_bfd
)->ssext
+ psh
->iss
;
2448 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2449 VAR_NAMESPACE
, class,
2450 objfile
->global_psymbols
, (CORE_ADDR
) psh
->value
,
2451 psymtab_language
, objfile
);
2455 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2456 empty and put on the free list. */
2457 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2458 psymtab_include_list
, includes_used
,
2459 -1, save_pst
->texthigh
,
2460 dependency_list
, dependencies_used
);
2461 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2462 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2464 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2465 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2469 /* Now scan the FDRs for dependencies */
2470 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2472 fh
= f_idx
+ ecoff_data (cur_bfd
)->fdr
;
2473 pst
= fdr_to_pst
[f_idx
].pst
;
2475 if (pst
== (struct partial_symtab
*)NULL
)
2478 /* This should catch stabs-in-ecoff. */
2482 /* Skip the first file indirect entry as it is a self dependency
2483 for source files or a reverse .h -> .c dependency for header files. */
2484 pst
->number_of_dependencies
= 0;
2486 ((struct partial_symtab
**)
2487 obstack_alloc (&objfile
->psymbol_obstack
,
2489 * sizeof (struct partial_symtab
*))));
2490 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2494 (*swap_rfd_in
) (cur_bfd
,
2495 ((char *) ecoff_data (cur_bfd
)->external_rfd
2496 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2498 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2500 complain (&bad_file_number_complaint
, rh
);
2504 /* Skip self dependencies of header files. */
2508 /* Do not add to dependeny list if psymtab was empty. */
2509 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2511 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2514 do_cleanups (old_chain
);
2519 mips_next_symbol_text ()
2524 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
2526 ((char *) ecoff_data (cur_bfd
)->external_sym
2527 + ((cur_fdr
->isymBase
+ cur_sdx
)
2528 * ecoff_backend (cur_bfd
)->external_sym_size
)),
2530 return ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2533 /* Ancillary function to psymtab_to_symtab(). Does all the work
2534 for turning the partial symtab PST into a symtab, recurring
2535 first on all dependent psymtabs. The argument FILENAME is
2536 only passed so we can see in debug stack traces what file
2539 This function has a split personality, based on whether the
2540 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2541 The flow of control and even the memory allocation differs. FIXME. */
2544 psymtab_to_symtab_1 (pst
, filename
)
2545 struct partial_symtab
*pst
;
2548 const bfd_size_type external_sym_size
2549 = ecoff_backend (cur_bfd
)->external_sym_size
;
2550 const bfd_size_type external_pdr_size
2551 = ecoff_backend (cur_bfd
)->external_pdr_size
;
2552 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2553 = ecoff_backend (cur_bfd
)->swap_sym_in
;
2554 void (* const swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*))
2555 = ecoff_backend (cur_bfd
)->swap_pdr_in
;
2559 struct linetable
*lines
;
2565 /* Read in all partial symbtabs on which this one is dependent.
2566 NOTE that we do have circular dependencies, sigh. We solved
2567 that by setting pst->readin before this point. */
2569 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2570 if (!pst
->dependencies
[i
]->readin
)
2572 /* Inform about additional files to be read in. */
2575 fputs_filtered (" ", stdout
);
2577 fputs_filtered ("and ", stdout
);
2579 printf_filtered ("%s...",
2580 pst
->dependencies
[i
]->filename
);
2581 wrap_here (""); /* Flush output */
2584 /* We only pass the filename for debug purposes */
2585 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2586 pst
->dependencies
[i
]->filename
);
2589 /* Do nothing if this is a dummy psymtab. */
2591 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2592 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2595 /* Now read the symbols for this symtab */
2597 cur_bfd
= CUR_BFD (pst
);
2598 current_objfile
= pst
->objfile
;
2599 cur_fd
= FDR_IDX (pst
);
2600 fh
= (cur_fd
== -1) ? (FDR
*) NULL
: ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
2603 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2604 processing_gcc_compilation
= 0;
2605 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2609 (*swap_sym_in
) (cur_bfd
,
2610 ((char *) ecoff_data (cur_bfd
)->external_sym
2611 + (fh
->isymBase
+ 1) * external_sym_size
),
2613 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2616 /* We indicate that this is a GCC compilation so that certain
2617 features will be enabled in stabsread/dbxread. */
2618 processing_gcc_compilation
= 2;
2622 if (processing_gcc_compilation
!= 0)
2627 unsigned long first_off
= 0;
2629 /* This symbol table contains stabs-in-ecoff entries. */
2631 /* Parse local symbols first */
2633 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2635 current_objfile
= NULL
;
2638 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2644 (*swap_sym_in
) (cur_bfd
,
2645 ((char *) ecoff_data (cur_bfd
)->external_sym
2646 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2648 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2650 if (ECOFF_IS_STAB (&sh
))
2652 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2653 process_one_symbol (type_code
, 0, valu
, name
,
2654 pst
->section_offsets
, pst
->objfile
);
2655 if (type_code
== N_FUN
)
2657 /* Make up special symbol to contain
2658 procedure specific info */
2659 struct mips_extra_func_info
*e
=
2660 ((struct mips_extra_func_info
*)
2661 obstack_alloc (¤t_objfile
->symbol_obstack
,
2662 sizeof (struct mips_extra_func_info
)));
2663 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2664 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2665 SYMBOL_CLASS (s
) = LOC_CONST
;
2666 SYMBOL_TYPE (s
) = builtin_type_void
;
2667 SYMBOL_VALUE (s
) = (long) e
;
2668 add_symbol_to_list (s
, &local_symbols
);
2671 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2673 /* Handle encoded stab line number. */
2674 record_line (current_subfile
, sh
.index
, valu
);
2676 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2677 /* These are generated by gcc-2.x, do not complain */
2680 complain (&stab_unknown_complaint
, name
);
2682 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2685 /* Sort the symbol table now, we are done adding symbols to it.
2686 We must do this before parse_procedure calls lookup_symbol. */
2687 sort_symtab_syms (st
);
2689 /* This may not be necessary for stabs symtabs. FIXME. */
2692 /* Fill in procedure info next. */
2694 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2695 + fh
->ipdFirst
* external_pdr_size
);
2696 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2697 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2701 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2707 parse_procedure (&pr
, st
, first_off
);
2712 /* This symbol table contains ordinary ecoff entries. */
2714 /* FIXME: doesn't use pst->section_offsets. */
2720 /* How many symbols will we need */
2721 /* FIXME, this does not count enum values. */
2722 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2726 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2730 f_max
+= fh
->csym
+ fh
->cpd
;
2731 maxlines
= 2 * fh
->cline
;
2732 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2734 /* The proper language was already determined when building
2735 the psymtab, use it. */
2736 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2739 psymtab_language
= st
->language
;
2741 lines
= LINETABLE (st
);
2743 /* Get a new lexical context */
2745 push_parse_stack ();
2746 top_stack
->cur_st
= st
;
2747 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2749 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2750 BLOCK_END (top_stack
->cur_block
) = 0;
2751 top_stack
->blocktype
= stFile
;
2752 top_stack
->maxsyms
= 2 * f_max
;
2753 top_stack
->cur_type
= 0;
2754 top_stack
->procadr
= 0;
2755 top_stack
->numargs
= 0;
2762 /* Parse local symbols first */
2763 sym_ptr
= ((char *) ecoff_data (cur_bfd
)->external_sym
2764 + fh
->isymBase
* external_sym_size
);
2765 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2766 while (sym_ptr
< sym_end
)
2771 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2772 c
= parse_symbol (&sh
,
2773 (ecoff_data (cur_bfd
)->external_aux
2775 sym_ptr
, fh
->fBigendian
);
2776 sym_ptr
+= c
* external_sym_size
;
2779 /* Linenumbers. At the end, check if we can save memory.
2780 parse_lines has to look ahead an arbitrary number of PDR
2781 structures, so we swap them all first. */
2785 struct cleanup
*old_chain
;
2791 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2793 old_chain
= make_cleanup (free
, pr_block
);
2795 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2796 + fh
->ipdFirst
* external_pdr_size
);
2797 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2801 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2802 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2804 parse_lines (fh
, pr_block
, lines
);
2805 if (lines
->nitems
< fh
->cline
)
2806 lines
= shrink_linetable (lines
);
2808 /* Fill in procedure info next. */
2810 pdr_in_end
= pdr_in
+ fh
->cpd
;
2811 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2812 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2814 do_cleanups (old_chain
);
2818 LINETABLE (st
) = lines
;
2820 /* .. and our share of externals.
2821 XXX use the global list to speed up things here. how?
2822 FIXME, Maybe quit once we have found the right number of ext's? */
2823 top_stack
->cur_st
= st
;
2824 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2826 top_stack
->blocktype
= stFile
;
2827 top_stack
->maxsyms
= (ecoff_data (cur_bfd
)->symbolic_header
.isymMax
2828 + ecoff_data (cur_bfd
)->symbolic_header
.ipdMax
2829 + ecoff_data (cur_bfd
)->symbolic_header
.iextMax
);
2831 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2832 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2833 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2835 /* If there are undefined, tell the user */
2836 if (n_undef_symbols
)
2838 printf_filtered ("File %s contains %d unresolved references:",
2839 st
->filename
, n_undef_symbols
);
2840 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2841 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2842 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2847 /* Sort the symbol table now, we are done adding symbols to it.*/
2848 sort_symtab_syms (st
);
2853 /* Now link the psymtab and the symtab. */
2856 current_objfile
= NULL
;
2859 /* Ancillary parsing procedures. */
2861 /* Lookup the type at relative index RN. Return it in TPP
2862 if found and in any event come up with its name PNAME.
2863 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2864 Return value says how many aux symbols we ate. */
2867 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2871 enum type_code type_code
; /* Use to alloc new type if none is found. */
2883 struct mips_pending
*pend
;
2885 *tpp
= (struct type
*)NULL
;
2887 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2889 /* Escape index means 'the next one' */
2890 if (rn
->rfd
== 0xfff)
2893 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2900 /* mips cc uses a rf of -1 for opaque struct definitions.
2901 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2902 resolve them if the struct gets defined in another compilation unit. */
2905 *pname
= "<undefined>";
2906 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2907 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2911 /* mips cc uses an escaped rn->index of 0 for struct return types
2912 of procedures that were compiled without -g. These will always remain
2914 if (rn
->rfd
== 0xfff && rn
->index
== 0)
2916 *pname
= "<undefined>";
2920 /* Find the relative file descriptor and the symbol in it. */
2921 fh
= get_rfd (fd
, rf
);
2922 xref_fd
= fh
- ecoff_data (cur_bfd
)->fdr
;
2924 if (rn
->index
>= fh
->csym
)
2926 /* File indirect entry is corrupt. */
2927 *pname
= "<illegal>";
2928 complain (&bad_rfd_entry_complaint
,
2929 sym_name
, xref_fd
, rn
->index
);
2933 /* If we have processed this symbol then we left a forwarding
2934 pointer to the type in the pending list. If not, we`ll put
2935 it in a list of pending types, to be processed later when
2936 the file will be. In any event, we collect the name for the
2939 esh
= ((char *) ecoff_data (cur_bfd
)->external_sym
2940 + ((fh
->isymBase
+ rn
->index
)
2941 * ecoff_backend (cur_bfd
)->external_sym_size
));
2942 (*ecoff_backend (cur_bfd
)->swap_sym_in
) (cur_bfd
, esh
, &sh
);
2944 /* Make sure that this type of cross reference can be handled. */
2946 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
2947 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
2948 && sh
.st
!= stEnum
))
2950 /* File indirect entry is corrupt. */
2951 *pname
= "<illegal>";
2952 complain (&bad_rfd_entry_complaint
,
2953 sym_name
, xref_fd
, rn
->index
);
2957 *pname
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2959 pend
= is_pending_symbol (fh
, esh
);
2964 /* We have not yet seen this type. */
2966 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
2970 /* alpha cc puts out a stTypedef with a sh.iss of zero for
2972 a) forward declarations of structs/unions/enums which are not
2973 defined in this compilation unit.
2974 For these the type will be void. This is a bad design decision
2975 as cross referencing across compilation units is impossible
2976 due to the missing name.
2977 b) forward declarations of structs/unions/enums which are defined
2978 later in this file or in another file in the same compilation
2979 unit. Simply cross reference those again to get the
2981 The forward references are not entered in the pending list and
2982 in the symbol table. */
2984 ecoff_swap_tir_in (bigend
,
2985 &(ecoff_data (cur_bfd
)->external_aux
2986 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2988 if (tir
.tq0
!= tqNil
)
2989 complain (&illegal_forward_tq0_complaint
, sym_name
);
2993 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
2995 *pname
= "<undefined>";
3002 (ecoff_data (cur_bfd
)->external_aux
3003 + fh
->iauxBase
+ sh
.index
+ 1),
3004 tpp
, type_code
, pname
,
3005 fh
->fBigendian
, sym_name
);
3009 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3010 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3016 else if (sh
.st
== stTypedef
)
3018 /* Parse the type for a normal typedef. This might recursively call
3019 cross_ref till we get a non typedef'ed type.
3020 FIXME: This is not correct behaviour, but gdb currently
3021 cannot handle typedefs without type copying. But type copying is
3022 impossible as we might have mutual forward references between
3023 two files and the copied type would not get filled in when
3024 we later parse its definition. */
3025 *tpp
= parse_type (xref_fd
,
3026 (ecoff_data (cur_bfd
)->external_aux
3027 + fh
->iauxBase
+ sh
.index
),
3030 (ecoff_data (cur_bfd
)->ss
3031 + fh
->issBase
+ sh
.iss
));
3035 /* Cross reference to a struct/union/enum which is defined
3036 in another file in the same compilation unit but that file
3037 has not been parsed yet.
3038 Initialize the type only, it will be filled in when
3039 it's definition is parsed. */
3040 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3042 add_pending (fh
, esh
, *tpp
);
3045 /* We used one auxent normally, two if we got a "next one" rf. */
3050 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3051 keeping the symtab sorted */
3053 static struct symbol
*
3054 mylookup_symbol (name
, block
, namespace, class)
3056 register struct block
*block
;
3057 enum namespace namespace;
3058 enum address_class
class;
3060 register int bot
, top
, inc
;
3061 register struct symbol
*sym
;
3064 top
= BLOCK_NSYMS (block
);
3068 sym
= BLOCK_SYM (block
, bot
);
3069 if (SYMBOL_NAME (sym
)[0] == inc
3070 && SYMBOL_NAMESPACE (sym
) == namespace
3071 && SYMBOL_CLASS (sym
) == class
3072 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3076 block
= BLOCK_SUPERBLOCK (block
);
3078 return mylookup_symbol (name
, block
, namespace, class);
3083 /* Add a new symbol S to a block B.
3084 Infrequently, we will need to reallocate the block to make it bigger.
3085 We only detect this case when adding to top_stack->cur_block, since
3086 that's the only time we know how big the block is. FIXME. */
3093 int nsyms
= BLOCK_NSYMS (b
)++;
3094 struct block
*origb
;
3095 struct parse_stack
*stackp
;
3097 if (b
== top_stack
->cur_block
&&
3098 nsyms
>= top_stack
->maxsyms
)
3100 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3101 /* In this case shrink_block is actually grow_block, since
3102 BLOCK_NSYMS(b) is larger than its current size. */
3104 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3106 /* Now run through the stack replacing pointers to the
3107 original block. shrink_block has already done this
3108 for the blockvector and BLOCK_FUNCTION. */
3109 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3111 if (stackp
->cur_block
== origb
)
3113 stackp
->cur_block
= b
;
3114 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3118 BLOCK_SYM (b
, nsyms
) = s
;
3121 /* Add a new block B to a symtab S */
3128 struct blockvector
*bv
= BLOCKVECTOR (s
);
3130 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3131 (sizeof (struct blockvector
)
3132 + BLOCKVECTOR_NBLOCKS (bv
)
3133 * sizeof (bv
->block
)));
3134 if (bv
!= BLOCKVECTOR (s
))
3135 BLOCKVECTOR (s
) = bv
;
3137 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3140 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3141 MIPS' linenumber encoding might need more than one byte
3142 to describe it, LAST is used to detect these continuation lines.
3144 Combining lines with the same line number seems like a bad idea.
3145 E.g: There could be a line number entry with the same line number after the
3146 prologue and GDB should not ignore it (this is a better way to find
3147 a prologue than mips_skip_prologue).
3148 But due to the compressed line table format there are line number entries
3149 for the same line which are needed to bridge the gap to the next
3150 line number entry. These entries have a bogus address info with them
3151 and we are unable to tell them from intended duplicate line number
3153 This is another reason why -ggdb debugging format is preferable. */
3156 add_line (lt
, lineno
, adr
, last
)
3157 struct linetable
*lt
;
3163 last
= -2; /* make sure we record first line */
3165 if (last
== lineno
) /* skip continuation lines */
3168 lt
->item
[lt
->nitems
].line
= lineno
;
3169 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3173 /* Sorting and reordering procedures */
3175 /* Blocks with a smaller low bound should come first */
3178 compare_blocks (arg1
, arg2
)
3179 const void *arg1
, *arg2
;
3181 register int addr_diff
;
3182 struct block
**b1
= (struct block
**) arg1
;
3183 struct block
**b2
= (struct block
**) arg2
;
3185 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3187 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3191 /* Sort the blocks of a symtab S.
3192 Reorder the blocks in the blockvector by code-address,
3193 as required by some MI search routines */
3199 struct blockvector
*bv
= BLOCKVECTOR (s
);
3201 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3204 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3205 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3206 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3207 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3211 * This is very unfortunate: normally all functions are compiled in
3212 * the order they are found, but if the file is compiled -O3 things
3213 * are very different. It would be nice to find a reliable test
3214 * to detect -O3 images in advance.
3216 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3217 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3218 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3219 sizeof (struct block
*),
3223 register CORE_ADDR high
= 0;
3224 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3226 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3227 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3228 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3229 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3232 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3233 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3235 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3236 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3237 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3238 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3242 /* Constructor/restructor/destructor procedures */
3244 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3245 MAXSYMS and linenumbers MAXLINES we'll put in it */
3247 static struct symtab
*
3248 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3252 struct objfile
*objfile
;
3254 struct symtab
*s
= allocate_symtab (name
, objfile
);
3256 LINETABLE (s
) = new_linetable (maxlines
);
3258 /* All symtabs must have at least two blocks */
3259 BLOCKVECTOR (s
) = new_bvect (2);
3260 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3261 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3262 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3263 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3265 s
->free_code
= free_linetable
;
3270 /* Allocate a new partial_symtab NAME */
3272 static struct partial_symtab
*
3273 new_psymtab (name
, objfile
)
3275 struct objfile
*objfile
;
3277 struct partial_symtab
*psymtab
;
3279 psymtab
= allocate_psymtab (name
, objfile
);
3281 /* Keep a backpointer to the file's symbols */
3283 psymtab
->read_symtab_private
= ((char *)
3284 obstack_alloc (&objfile
->psymbol_obstack
,
3285 sizeof (struct symloc
)));
3286 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3287 CUR_BFD (psymtab
) = cur_bfd
;
3289 /* The way to turn this into a symtab is to call... */
3290 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
3295 /* Allocate a linetable array of the given SIZE. Since the struct
3296 already includes one item, we subtract one when calculating the
3297 proper size to allocate. */
3299 static struct linetable
*
3300 new_linetable (size
)
3303 struct linetable
*l
;
3305 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3306 l
= (struct linetable
*) xmalloc (size
);
3311 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3312 I am not so sure about the 3.4 ones.
3314 Since the struct linetable already includes one item, we subtract one when
3315 calculating the proper size to allocate. */
3317 static struct linetable
*
3318 shrink_linetable (lt
)
3319 struct linetable
*lt
;
3322 return (struct linetable
*) xrealloc ((PTR
) lt
,
3323 (sizeof (struct linetable
)
3325 * sizeof (lt
->item
))));
3328 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3330 static struct blockvector
*
3334 struct blockvector
*bv
;
3337 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3338 bv
= (struct blockvector
*) xzalloc (size
);
3340 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3345 /* Allocate and zero a new block of MAXSYMS symbols */
3347 static struct block
*
3351 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3353 return (struct block
*) xzalloc (size
);
3356 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3357 Shrink_block can also be used by add_symbol to grow a block. */
3359 static struct block
*
3365 struct blockvector
*bv
= BLOCKVECTOR (s
);
3368 /* Just reallocate it and fix references to the old one */
3370 new = (struct block
*) xrealloc ((PTR
) b
,
3371 (sizeof (struct block
)
3372 + ((BLOCK_NSYMS (b
) - 1)
3373 * sizeof (struct symbol
*))));
3375 /* Should chase pointers to old one. Fortunately, that`s just
3376 the block`s function and inferior blocks */
3377 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3378 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3379 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3380 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3381 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3382 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3383 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3387 /* Create a new symbol with printname NAME */
3389 static struct symbol
*
3393 struct symbol
*s
= ((struct symbol
*)
3394 obstack_alloc (¤t_objfile
->symbol_obstack
,
3395 sizeof (struct symbol
)));
3397 memset ((PTR
) s
, 0, sizeof (*s
));
3398 SYMBOL_NAME (s
) = name
;
3399 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3400 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3404 /* Create a new type with printname NAME */
3406 static struct type
*
3412 t
= alloc_type (current_objfile
);
3413 TYPE_NAME (t
) = name
;
3414 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3419 /* Things used for calling functions in the inferior.
3420 These functions are exported to our companion
3421 mips-tdep.c file and are here because they play
3422 with the symbol-table explicitly. */
3424 /* Sigtramp: make sure we have all the necessary information
3425 about the signal trampoline code. Since the official code
3426 from MIPS does not do so, we make up that information ourselves.
3427 If they fix the library (unlikely) this code will neutralize itself. */
3434 struct block
*b
, *b0
= NULL
;
3436 sigtramp_address
= -1;
3438 /* We have to handle the following cases here:
3439 a) The Mips library has a sigtramp label within sigvec.
3440 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3441 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3444 b0
= SYMBOL_BLOCK_VALUE (s
);
3445 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3449 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3450 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3453 /* But maybe this program uses its own version of sigvec */
3457 /* Did we or MIPSco fix the library ? */
3458 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3460 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3461 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3465 sigtramp_address
= SYMBOL_VALUE (s
);
3466 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3468 /* But what symtab does it live in ? */
3469 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3472 * Ok, there goes the fix: turn it into a procedure, with all the
3473 * needed info. Note we make it a nested procedure of sigvec,
3474 * which is the way the (assembly) code is actually written.
3476 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3477 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3478 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3480 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3482 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3484 SYMBOL_BLOCK_VALUE (s
) = b
;
3485 BLOCK_START (b
) = sigtramp_address
;
3486 BLOCK_END (b
) = sigtramp_end
;
3487 BLOCK_FUNCTION (b
) = s
;
3488 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3492 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3494 struct mips_extra_func_info
*e
=
3495 ((struct mips_extra_func_info
*)
3496 xzalloc (sizeof (struct mips_extra_func_info
)));
3498 e
->numargs
= 0; /* the kernel thinks otherwise */
3499 /* align_longword(sigcontext + SIGFRAME) */
3500 e
->pdr
.frameoffset
= 0x150;
3501 e
->pdr
.framereg
= SP_REGNUM
;
3502 /* read_next_frame_reg provides the true pc at the time of signal */
3503 e
->pdr
.pcreg
= PC_REGNUM
;
3504 e
->pdr
.regmask
= -2;
3505 e
->pdr
.regoffset
= -(41 * sizeof (int));
3506 e
->pdr
.fregmask
= -1;
3507 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3508 e
->pdr
.isym
= (long) s
;
3509 e
->pdr
.adr
= sigtramp_address
;
3511 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3512 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3513 SYMBOL_VALUE (s
) = (long) e
;
3514 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3515 SYMBOL_CLASS (s
) = LOC_CONST
;
3516 SYMBOL_TYPE (s
) = builtin_type_void
;
3517 current_objfile
= NULL
;
3520 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3524 /* Fake up identical offsets for all sections. */
3526 struct section_offsets
*
3527 mipscoff_symfile_offsets (objfile
, addr
)
3528 struct objfile
*objfile
;
3531 struct section_offsets
*section_offsets
;
3534 section_offsets
= ((struct section_offsets
*)
3535 obstack_alloc (&objfile
->psymbol_obstack
,
3536 (sizeof (struct section_offsets
)
3537 + (sizeof (section_offsets
->offsets
)
3538 * (SECT_OFF_MAX
- 1)))));
3540 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3541 ANOFFSET (section_offsets
, i
) = addr
;
3543 return section_offsets
;
3546 /* Initialization */
3548 static struct sym_fns ecoff_sym_fns
=
3550 "ecoff", /* sym_name: name or name prefix of BFD target type */
3551 5, /* sym_namelen: number of significant sym_name chars */
3552 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3553 mipscoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3554 mipscoff_symfile_read
, /* sym_read: read a symbol file into symtab */
3555 mipscoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3556 mipscoff_symfile_offsets
, /* sym_offsets: dummy FIXME til implem sym reloc */
3557 NULL
/* next: pointer to next struct sym_fns */
3562 _initialize_mipsread ()
3564 add_symtab_fns (&ecoff_sym_fns
);
3566 /* Missing basic types */
3568 builtin_type_string
=
3569 init_type (TYPE_CODE_STRING
,
3570 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3572 (struct objfile
*) NULL
);
3573 builtin_type_complex
=
3574 init_type (TYPE_CODE_FLT
,
3575 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3577 (struct objfile
*) NULL
);
3578 builtin_type_double_complex
=
3579 init_type (TYPE_CODE_FLT
,
3580 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3581 0, "double complex",
3582 (struct objfile
*) NULL
);
3583 builtin_type_fixed_dec
=
3584 init_type (TYPE_CODE_INT
,
3585 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3587 (struct objfile
*) NULL
);
3588 builtin_type_float_dec
=
3589 init_type (TYPE_CODE_FLT
,
3590 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3591 0, "floating decimal",
3592 (struct objfile
*) NULL
);