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 But for struct vs. union a wrong guess is harmless, so
1471 don't complain(). */
1472 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1473 && type_code
!= TYPE_CODE_ENUM
)
1474 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1475 && type_code
== TYPE_CODE_ENUM
))
1477 complain (&bad_tag_guess_complaint
, sym_name
);
1480 if (TYPE_CODE (tp
) != type_code
)
1482 TYPE_CODE (tp
) = type_code
;
1485 /* Do not set the tag name if it is a compiler generated tag name
1486 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1487 if (name
[0] == '.' || name
[0] == '\0')
1488 TYPE_TAG_NAME (tp
) = NULL
;
1489 else if (TYPE_TAG_NAME (tp
) == NULL
1490 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1491 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1492 ¤t_objfile
->type_obstack
);
1496 /* All these types really point to some (common) MIPS type
1497 definition, and only the type-qualifiers fully identify
1498 them. We'll make the same effort at sharing.
1499 FIXME: btIndirect cannot happen here as it is handled by the
1500 switch t->bt above. And we are not doing any guessing on range types. */
1501 if (t
->bt
== btIndirect
||
1506 /* Try to cross reference this type, build new type on failure. */
1507 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1508 if (tp
== (struct type
*) NULL
)
1509 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1511 /* Make sure that TYPE_CODE(tp) has an expected type code.
1512 Any type may be returned from cross_ref if file indirect entries
1514 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1516 complain (&unexpected_type_code_complaint
, sym_name
);
1520 /* Usually, TYPE_CODE(tp) is already type_code. The main
1521 exception is if we guessed wrong re struct/union/enum. */
1522 if (TYPE_CODE (tp
) != type_code
)
1524 complain (&bad_tag_guess_complaint
, sym_name
);
1525 TYPE_CODE (tp
) = type_code
;
1527 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1528 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1529 ¤t_objfile
->type_obstack
);
1532 if (t
->bt
== btTypedef
)
1536 /* Try to cross reference this type, it should succeed. */
1537 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1538 if (tp
== (struct type
*) NULL
)
1540 complain (&unable_to_cross_ref_complaint
, sym_name
);
1541 tp
= builtin_type_int
;
1545 /* Deal with range types */
1546 if (t
->bt
== btRange
)
1548 TYPE_NFIELDS (tp
) = 2;
1549 TYPE_FIELDS (tp
) = ((struct field
*)
1550 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1551 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1552 ¤t_objfile
->type_obstack
);
1553 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1555 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1556 ¤t_objfile
->type_obstack
);
1557 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1561 /* Parse all the type qualifiers now. If there are more
1562 than 6 the game will continue in the next aux */
1564 #define PARSE_TQ(tq) \
1565 if (t->tq != tqNil) ax += upgrade_type(fd, &tp, t->tq, ax, bigend);
1567 again
:PARSE_TQ (tq0
);
1578 ecoff_swap_tir_in (bigend
, &tax
->a_ti
, t
);
1584 /* Make up a complex type from a basic one. Type is passed by
1585 reference in TPP and side-effected as necessary. The type
1586 qualifier TQ says how to handle the aux symbols at AX for
1587 the symbol SX we are currently analyzing. BIGEND says whether
1588 aux symbols are big-endian or little-endian.
1589 Returns the number of aux symbols we parsed. */
1592 upgrade_type (fd
, tpp
, tq
, ax
, bigend
)
1602 /* Used in array processing */
1613 t
= lookup_pointer_type (*tpp
);
1618 t
= lookup_function_type (*tpp
);
1625 /* Determine and record the domain type (type of index) */
1626 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1632 rf
= AUX_GET_ISYM (bigend
, ax
);
1635 fh
= get_rfd (fd
, rf
);
1637 indx
= parse_type (fd
,
1638 (ecoff_data (cur_bfd
)->external_aux
1641 (int *) NULL
, bigend
, "<array index>");
1643 /* Get the bounds, and create the array type. */
1645 lower
= AUX_GET_DNLOW (bigend
, ax
);
1647 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1649 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1651 range
= create_range_type ((struct type
*) NULL
, indx
,
1654 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1656 /* Check whether supplied array element bit size matches
1657 the known size of the element type. If this complaint
1658 ends up not happening, we can remove this code. It's
1659 here because we aren't sure we understand this *&%&$
1661 id
= TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) << 3; /* bitsize */
1664 /* Most likely an undefined type */
1666 TYPE_LENGTH (TYPE_TARGET_TYPE (t
)) = id
>> 3;
1669 complain (&array_bitsize_complaint
, rf
);
1675 /* Volatile -- currently ignored */
1679 /* Const -- currently ignored */
1683 complain (&unknown_type_qual_complaint
, tq
);
1689 /* Parse a procedure descriptor record PR. Note that the procedure is
1690 parsed _after_ the local symbols, now we just insert the extra
1691 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1692 already been placed in the procedure's main block. Note also that
1693 images that have been partially stripped (ld -x) have been deprived
1694 of local symbols, and we have to cope with them here. FIRST_OFF is
1695 the offset of the first procedure for this FDR; we adjust the
1696 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1697 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1698 in question, or NULL to use top_stack->cur_block. */
1700 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1703 parse_procedure (pr
, search_symtab
, first_off
)
1705 struct symtab
*search_symtab
;
1706 unsigned long first_off
;
1708 struct symbol
*s
, *i
;
1710 struct mips_extra_func_info
*e
;
1713 /* Simple rule to find files linked "-x" */
1714 if (cur_fdr
->rss
== -1)
1718 /* Static procedure at address pr->adr. Sigh. */
1719 complain (&pdr_static_symbol_complaint
, pr
->adr
);
1727 (*ecoff_backend (cur_bfd
)->swap_ext_in
)
1729 ((char *) ecoff_data (cur_bfd
)->external_ext
1730 + pr
->isym
* ecoff_backend (cur_bfd
)->external_ext_size
),
1732 sh_name
= ecoff_data (cur_bfd
)->ssext
+ she
.asym
.iss
;
1740 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
1742 ((char *) ecoff_data (cur_bfd
)->external_sym
1743 + ((cur_fdr
->isymBase
+ pr
->isym
)
1744 * ecoff_backend (cur_bfd
)->external_sym_size
)),
1746 sh_name
= ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1749 if (search_symtab
!= NULL
)
1752 /* This loses both in the case mentioned (want a static, find a global),
1753 but also if we are looking up a non-mangled name which happens to
1754 match the name of a mangled function. */
1755 /* We have to save the cur_fdr across the call to lookup_symbol.
1756 If the pdr is for a static function and if a global function with
1757 the same name exists, lookup_symbol will eventually read in the symtab
1758 for the global function and clobber cur_fdr. */
1759 FDR
*save_cur_fdr
= cur_fdr
;
1760 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1761 cur_fdr
= save_cur_fdr
;
1765 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1771 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1772 VAR_NAMESPACE
, LOC_BLOCK
);
1776 b
= SYMBOL_BLOCK_VALUE (s
);
1780 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1784 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1785 s
= new_symbol (sh_name
);
1786 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1787 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1788 /* Donno its type, hope int is ok */
1789 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1790 add_symbol (s
, top_stack
->cur_block
);
1791 /* Wont have symbols for this one */
1793 SYMBOL_BLOCK_VALUE (s
) = b
;
1794 BLOCK_FUNCTION (b
) = s
;
1795 BLOCK_START (b
) = pr
->adr
;
1796 /* BOUND used to be the end of procedure's text, but the
1797 argument is no longer passed in. */
1798 BLOCK_END (b
) = bound
;
1799 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1800 add_block (b
, top_stack
->cur_st
);
1804 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1808 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1810 e
->pdr
.isym
= (long) s
;
1811 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1813 /* Correct incorrect setjmp procedure descriptor from the library
1814 to make backtrace through setjmp work. */
1815 if (e
->pdr
.pcreg
== 0 && strcmp (sh_name
, "setjmp") == 0)
1817 complain (&bad_setjmp_pdr_complaint
, 0);
1818 e
->pdr
.pcreg
= RA_REGNUM
;
1819 e
->pdr
.regmask
= 0x80000000;
1820 e
->pdr
.regoffset
= -4;
1825 /* Parse the external symbol ES. Just call parse_symbol() after
1826 making sure we know where the aux are for it. For procedures,
1827 parsing of the PDRs has already provided all the needed
1828 information, we only parse them if SKIP_PROCEDURES is false,
1829 and only if this causes no symbol duplication.
1830 BIGEND says whether aux entries are big-endian or little-endian.
1832 This routine clobbers top_stack->cur_block and ->cur_st. */
1835 parse_external (es
, skip_procedures
, bigend
)
1837 int skip_procedures
;
1842 if (es
->ifd
!= ifdNil
)
1845 cur_fdr
= ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
1846 ax
= ecoff_data (cur_bfd
)->external_aux
+ cur_fdr
->iauxBase
;
1850 cur_fdr
= ecoff_data (cur_bfd
)->fdr
;
1854 /* Reading .o files */
1855 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1858 switch (es
->asym
.st
)
1878 /* FIXME: Turn this into a complaint? */
1880 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1882 ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1883 fdr_name (cur_fdr
));
1887 switch (es
->asym
.st
)
1890 /* If we have full symbols we do not need more */
1891 if (skip_procedures
)
1893 if (mylookup_symbol (ecoff_data (cur_bfd
)->ssext
+ es
->asym
.iss
,
1894 top_stack
->cur_block
,
1895 VAR_NAMESPACE
, LOC_BLOCK
))
1900 /* Note that the case of a symbol with indexNil must be handled
1901 anyways by parse_symbol(). */
1902 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1909 /* Parse the line number info for file descriptor FH into
1910 GDB's linetable LT. MIPS' encoding requires a little bit
1911 of magic to get things out. Note also that MIPS' line
1912 numbers can go back and forth, apparently we can live
1913 with that and do not need to reorder our linetables */
1916 parse_lines (fh
, pr
, lt
)
1919 struct linetable
*lt
;
1921 unsigned char *base
;
1923 int delta
, count
, lineno
= 0;
1924 unsigned long first_off
= pr
->adr
;
1926 if (fh
->cbLine
== 0)
1929 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
;
1931 /* Scan by procedure descriptors */
1933 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1938 /* No code for this one */
1939 if (pr
->iline
== ilineNil
||
1940 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1943 /* Aurgh! To know where to stop expanding we must look-ahead. */
1944 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1945 if (pr
[l
].iline
!= -1)
1947 if (l
== (fh
->cpd
- j
))
1952 /* When procedures are moved around the linenumbers are
1953 attributed to the next procedure up. */
1954 if (pr
->iline
>= halt
)
1957 base
= ecoff_data (cur_bfd
)->line
+ fh
->cbLineOffset
+ pr
->cbLineOffset
;
1958 adr
= fh
->adr
+ pr
->adr
- first_off
;
1959 l
= adr
>> 2; /* in words */
1960 halt
+= (adr
>> 2) - pr
->iline
;
1961 for (lineno
= pr
->lnLow
; l
< halt
;)
1963 count
= *base
& 0x0f;
1964 delta
= *base
++ >> 4;
1969 delta
= (base
[0] << 8) | base
[1];
1970 if (delta
>= 0x8000)
1974 lineno
+= delta
; /* first delta is 0 */
1975 k
= add_line (lt
, lineno
, l
, k
);
1981 /* Master parsing procedure for first-pass reading of file symbols
1982 into a partial_symtab. */
1985 parse_partial_symbols (objfile
, section_offsets
)
1986 struct objfile
*objfile
;
1987 struct section_offsets
*section_offsets
;
1989 const struct ecoff_backend_data
* const backend
= ecoff_backend (cur_bfd
);
1990 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
1991 const bfd_size_type external_rfd_size
= backend
->external_rfd_size
;
1992 const bfd_size_type external_ext_size
= backend
->external_ext_size
;
1993 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
1994 = backend
->swap_ext_in
;
1995 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
1996 = backend
->swap_sym_in
;
1997 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
1998 = backend
->swap_rfd_in
;
2000 HDRR
*hdr
= &ecoff_data (cur_bfd
)->symbolic_header
;
2001 /* Running pointers */
2006 register EXTR
*ext_in
;
2009 struct partial_symtab
*pst
;
2011 int past_first_source_file
= 0;
2013 /* List of current psymtab's include files */
2014 char **psymtab_include_list
;
2015 int includes_allocated
;
2018 struct pst_map
*fdr_to_pst
;
2019 /* Index within current psymtab dependency list */
2020 struct partial_symtab
**dependency_list
;
2021 int dependencies_used
, dependencies_allocated
;
2022 struct cleanup
*old_chain
;
2024 enum language prev_language
;
2026 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2027 sizeof (EXTR
) * hdr
->iextMax
);
2029 includes_allocated
= 30;
2031 psymtab_include_list
= (char **) alloca (includes_allocated
*
2033 next_symbol_text_func
= mips_next_symbol_text
;
2035 dependencies_allocated
= 30;
2036 dependencies_used
= 0;
2038 (struct partial_symtab
**) alloca (dependencies_allocated
*
2039 sizeof (struct partial_symtab
*));
2041 last_source_file
= NULL
;
2046 * Only parse the Local and External symbols, and the Relative FDR.
2047 * Fixup enough of the loader symtab to be able to use it.
2048 * Allocate space only for the file's portions we need to
2053 max_glevel
= MIN_GLEVEL
;
2055 /* Allocate the map FDR -> PST.
2056 Minor hack: -O3 images might claim some global data belongs
2057 to FDR -1. We`ll go along with that */
2058 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2059 old_chain
= make_cleanup (free
, fdr_to_pst
);
2062 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2063 fdr_to_pst
[-1].pst
= pst
;
2067 /* Allocate the global pending list. */
2068 ECOFF_PENDING_LIST (objfile
) =
2069 ((struct mips_pending
**)
2070 obstack_alloc (&objfile
->psymbol_obstack
,
2071 hdr
->ifdMax
* sizeof (struct mips_pending
*)));
2072 memset ((PTR
) ECOFF_PENDING_LIST (objfile
), 0,
2073 hdr
->ifdMax
* sizeof (struct mips_pending
*));
2075 /* Pass 0 over external syms: swap them in. */
2076 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2077 make_cleanup (free
, ext_block
);
2079 ext_out
= (char *) ecoff_data (cur_bfd
)->external_ext
;
2080 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2082 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2083 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2085 /* Pass 1 over external syms: Presize and partition the list */
2087 ext_in_end
= ext_in
+ hdr
->iextMax
;
2088 for (; ext_in
< ext_in_end
; ext_in
++)
2089 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2091 /* Pass 1.5 over files: partition out global symbol space */
2093 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2095 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2096 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2097 fdr_to_pst
[f_idx
].n_globals
= 0;
2100 /* Pass 2 over external syms: fill in external symbols */
2102 ext_in_end
= ext_in
+ hdr
->iextMax
;
2103 for (; ext_in
< ext_in_end
; ext_in
++)
2105 enum minimal_symbol_type ms_type
= mst_text
;
2107 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2108 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2110 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2113 name
= ecoff_data (cur_bfd
)->ssext
+ ext_in
->asym
.iss
;
2114 switch (ext_in
->asym
.st
)
2119 ms_type
= mst_file_text
;
2122 if (ext_in
->asym
.sc
== scData
2123 || ext_in
->asym
.sc
== scSData
2124 || ext_in
->asym
.sc
== scRData
)
2130 if (ext_in
->asym
.sc
== scAbs
)
2132 else if (ext_in
->asym
.sc
== scText
)
2134 else if (ext_in
->asym
.sc
== scData
2135 || ext_in
->asym
.sc
== scSData
2136 || ext_in
->asym
.sc
== scRData
)
2142 ms_type
= mst_unknown
;
2143 complain (&unknown_ext_complaint
, name
);
2145 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
);
2148 /* Pass 3 over files, over local syms: fill in static symbols */
2149 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2151 struct partial_symtab
*save_pst
;
2154 cur_fdr
= fh
= ecoff_data (cur_bfd
)->fdr
+ f_idx
;
2158 fdr_to_pst
[f_idx
].pst
= NULL
;
2161 pst
= start_psymtab_common (objfile
, section_offsets
,
2163 fh
->cpd
? fh
->adr
: 0,
2164 objfile
->global_psymbols
.next
,
2165 objfile
->static_psymbols
.next
);
2166 pst
->read_symtab_private
= ((char *)
2167 obstack_alloc (&objfile
->psymbol_obstack
,
2168 sizeof (struct symloc
)));
2169 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2172 FDR_IDX (pst
) = f_idx
;
2173 CUR_BFD (pst
) = cur_bfd
;
2175 /* The way to turn this into a symtab is to call... */
2176 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
2178 /* Set up language for the pst.
2179 The language from the FDR is used if it is unambigious (e.g. cfront
2180 with native cc and g++ will set the language to C).
2181 Otherwise we have to deduce the language from the filename.
2182 Native ecoff has every header file in a separate FDR, so
2183 deduce_language_from_filename will return language_unknown for
2184 a header file, which is not what we want.
2185 But the FDRs for the header files are after the FDR for the source
2186 file, so we can assign the language of the source file to the
2187 following header files. Then we save the language in the private
2188 pst data so that we can reuse it when building symtabs. */
2189 prev_language
= psymtab_language
;
2193 case langCplusplusV2
:
2194 psymtab_language
= language_cplus
;
2197 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2200 if (psymtab_language
== language_unknown
)
2201 psymtab_language
= prev_language
;
2202 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2204 pst
->texthigh
= pst
->textlow
;
2206 /* For stabs-in-ecoff files, the second symbol must be @stab.
2207 This symbol is emitted by mips-tfile to signal that the
2208 current object file uses encapsulated stabs instead of mips
2209 ecoff for local symbols. (It is the second symbol because
2210 the first symbol is the stFile used to signal the start of a
2212 processing_gcc_compilation
= 0;
2215 (*swap_sym_in
) (cur_bfd
,
2216 ((char *) ecoff_data (cur_bfd
)->external_sym
2217 + (fh
->isymBase
+ 1) * external_sym_size
),
2219 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2221 processing_gcc_compilation
= 2;
2224 if (processing_gcc_compilation
!= 0)
2226 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2231 (*swap_sym_in
) (cur_bfd
,
2232 ((char *) ecoff_data (cur_bfd
)->external_sym
2233 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2235 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2236 if (!ECOFF_IS_STAB (&sh
))
2238 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2240 long procaddr
= sh
.value
;
2244 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2245 (ecoff_data (cur_bfd
)->external_aux
2248 (*swap_sym_in
) (cur_bfd
,
2250 ecoff_data (cur_bfd
)->external_sym
)
2251 + ((fh
->isymBase
+ isym
- 1)
2252 * external_sym_size
)),
2256 long high
= procaddr
+ sh
.value
;
2257 if (high
> pst
->texthigh
)
2258 pst
->texthigh
= high
;
2263 #define SET_NAMESTRING() \
2264 namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
2265 #define CUR_SYMBOL_TYPE type_code
2266 #define CUR_SYMBOL_VALUE sh.value
2267 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2269 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2270 #define HANDLE_RBRAC(val) \
2271 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2272 #include "partial-stab.h"
2277 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2280 enum address_class
class;
2282 (*swap_sym_in
) (cur_bfd
,
2283 ((char *) ecoff_data (cur_bfd
)->external_sym
2284 + ((fh
->isymBase
+ cur_sdx
)
2285 * external_sym_size
)),
2288 if (ECOFF_IS_STAB (&sh
))
2294 /* Non absolute static symbols go into the minimal table. */
2295 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2296 || (sh
.index
== indexNil
2297 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2299 /* FIXME, premature? */
2304 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2312 case stStaticProc
: /* Function */
2313 /* I believe this is used only for file-local functions.
2314 The comment in symconst.h ("load time only static procs")
2315 isn't particularly clear on this point. */
2316 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
);
2319 case stProc
: /* Asm labels apparently */
2320 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2321 VAR_NAMESPACE
, LOC_BLOCK
,
2322 objfile
->static_psymbols
, sh
.value
,
2323 psymtab_language
, objfile
);
2324 /* Skip over procedure to next one. */
2325 if (sh
.index
>= hdr
->iauxMax
)
2327 /* Should not happen, but does when cross-compiling
2328 with the MIPS compiler. FIXME -- pull later. */
2329 complain (&index_complaint
, name
);
2330 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2333 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2334 (ecoff_data (cur_bfd
)->external_aux
2337 procaddr
= sh
.value
;
2339 if (new_sdx
<= cur_sdx
)
2341 /* This should not happen either... FIXME. */
2342 complain (&aux_index_complaint
, name
);
2343 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2347 (*swap_sym_in
) (cur_bfd
,
2348 ((char *) ecoff_data (cur_bfd
)->external_sym
2349 + ((fh
->isymBase
+ cur_sdx
- 1)
2350 * external_sym_size
)),
2354 high
= procaddr
+ sh
.value
;
2355 if (high
> pst
->texthigh
)
2356 pst
->texthigh
= high
;
2359 case stStatic
: /* Variable */
2360 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2361 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
);
2363 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
);
2367 case stTypedef
:/* Typedef */
2368 class = LOC_TYPEDEF
;
2371 case stConstant
: /* Constant decl */
2378 case stBlock
: /* { }, str, un, enum*/
2379 if (sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2381 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2382 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2383 objfile
->static_psymbols
,
2385 psymtab_language
, objfile
);
2387 /* Skip over the block */
2389 if (new_sdx
<= cur_sdx
)
2391 /* This happens with the Ultrix kernel. */
2392 complain (&block_index_complaint
, name
);
2393 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2398 case stFile
: /* File headers */
2399 case stLabel
: /* Labels */
2400 case stEnd
: /* Ends of files */
2403 case stLocal
: /* Local variables */
2404 /* Normally these are skipped because we skip over
2405 all blocks we see. However, these can occur
2406 as visible symbols in a .h file that contains code. */
2410 /* Both complaints are valid: one gives symbol name,
2411 the other the offending symbol type. */
2412 complain (&unknown_sym_complaint
, name
);
2413 complain (&unknown_st_complaint
, sh
.st
);
2417 /* Use this gdb symbol */
2418 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2419 VAR_NAMESPACE
, class,
2420 objfile
->static_psymbols
, sh
.value
,
2421 psymtab_language
, objfile
);
2423 cur_sdx
++; /* Go to next file symbol */
2426 /* Now do enter the external symbols. */
2427 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2428 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2429 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2430 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2431 for (; --cur_sdx
>= 0; ext_ptr
++)
2433 enum address_class
class;
2437 if (ext_ptr
->ifd
!= f_idx
)
2439 psh
= &ext_ptr
->asym
;
2450 complain (&unknown_ext_complaint
,
2451 ecoff_data (cur_bfd
)->ssext
+ psh
->iss
);
2452 /* Fall through, pretend it's global. */
2457 name
= ecoff_data (cur_bfd
)->ssext
+ psh
->iss
;
2458 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2459 VAR_NAMESPACE
, class,
2460 objfile
->global_psymbols
, (CORE_ADDR
) psh
->value
,
2461 psymtab_language
, objfile
);
2465 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2466 empty and put on the free list. */
2467 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2468 psymtab_include_list
, includes_used
,
2469 -1, save_pst
->texthigh
,
2470 dependency_list
, dependencies_used
);
2471 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2472 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2474 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2475 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2479 /* Now scan the FDRs for dependencies */
2480 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2482 fh
= f_idx
+ ecoff_data (cur_bfd
)->fdr
;
2483 pst
= fdr_to_pst
[f_idx
].pst
;
2485 if (pst
== (struct partial_symtab
*)NULL
)
2488 /* This should catch stabs-in-ecoff. */
2492 /* Skip the first file indirect entry as it is a self dependency
2493 for source files or a reverse .h -> .c dependency for header files. */
2494 pst
->number_of_dependencies
= 0;
2496 ((struct partial_symtab
**)
2497 obstack_alloc (&objfile
->psymbol_obstack
,
2499 * sizeof (struct partial_symtab
*))));
2500 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2504 (*swap_rfd_in
) (cur_bfd
,
2505 ((char *) ecoff_data (cur_bfd
)->external_rfd
2506 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2508 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2510 complain (&bad_file_number_complaint
, rh
);
2514 /* Skip self dependencies of header files. */
2518 /* Do not add to dependeny list if psymtab was empty. */
2519 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2521 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2524 do_cleanups (old_chain
);
2529 mips_next_symbol_text ()
2534 (*ecoff_backend (cur_bfd
)->swap_sym_in
)
2536 ((char *) ecoff_data (cur_bfd
)->external_sym
2537 + ((cur_fdr
->isymBase
+ cur_sdx
)
2538 * ecoff_backend (cur_bfd
)->external_sym_size
)),
2540 return ecoff_data (cur_bfd
)->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2543 /* Ancillary function to psymtab_to_symtab(). Does all the work
2544 for turning the partial symtab PST into a symtab, recurring
2545 first on all dependent psymtabs. The argument FILENAME is
2546 only passed so we can see in debug stack traces what file
2549 This function has a split personality, based on whether the
2550 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2551 The flow of control and even the memory allocation differs. FIXME. */
2554 psymtab_to_symtab_1 (pst
, filename
)
2555 struct partial_symtab
*pst
;
2558 const bfd_size_type external_sym_size
2559 = ecoff_backend (cur_bfd
)->external_sym_size
;
2560 const bfd_size_type external_pdr_size
2561 = ecoff_backend (cur_bfd
)->external_pdr_size
;
2562 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2563 = ecoff_backend (cur_bfd
)->swap_sym_in
;
2564 void (* const swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*))
2565 = ecoff_backend (cur_bfd
)->swap_pdr_in
;
2569 struct linetable
*lines
;
2575 /* Read in all partial symbtabs on which this one is dependent.
2576 NOTE that we do have circular dependencies, sigh. We solved
2577 that by setting pst->readin before this point. */
2579 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2580 if (!pst
->dependencies
[i
]->readin
)
2582 /* Inform about additional files to be read in. */
2585 fputs_filtered (" ", stdout
);
2587 fputs_filtered ("and ", stdout
);
2589 printf_filtered ("%s...",
2590 pst
->dependencies
[i
]->filename
);
2591 wrap_here (""); /* Flush output */
2594 /* We only pass the filename for debug purposes */
2595 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2596 pst
->dependencies
[i
]->filename
);
2599 /* Do nothing if this is a dummy psymtab. */
2601 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2602 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2605 /* Now read the symbols for this symtab */
2607 cur_bfd
= CUR_BFD (pst
);
2608 current_objfile
= pst
->objfile
;
2609 cur_fd
= FDR_IDX (pst
);
2610 fh
= (cur_fd
== -1) ? (FDR
*) NULL
: ecoff_data (cur_bfd
)->fdr
+ cur_fd
;
2613 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2614 processing_gcc_compilation
= 0;
2615 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2619 (*swap_sym_in
) (cur_bfd
,
2620 ((char *) ecoff_data (cur_bfd
)->external_sym
2621 + (fh
->isymBase
+ 1) * external_sym_size
),
2623 if (STREQ (ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
,
2626 /* We indicate that this is a GCC compilation so that certain
2627 features will be enabled in stabsread/dbxread. */
2628 processing_gcc_compilation
= 2;
2632 if (processing_gcc_compilation
!= 0)
2637 unsigned long first_off
= 0;
2639 /* This symbol table contains stabs-in-ecoff entries. */
2641 /* Parse local symbols first */
2643 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2645 current_objfile
= NULL
;
2648 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2654 (*swap_sym_in
) (cur_bfd
,
2655 ((char *) ecoff_data (cur_bfd
)->external_sym
2656 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2658 name
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2660 if (ECOFF_IS_STAB (&sh
))
2662 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2663 process_one_symbol (type_code
, 0, valu
, name
,
2664 pst
->section_offsets
, pst
->objfile
);
2665 if (type_code
== N_FUN
)
2667 /* Make up special symbol to contain
2668 procedure specific info */
2669 struct mips_extra_func_info
*e
=
2670 ((struct mips_extra_func_info
*)
2671 obstack_alloc (¤t_objfile
->symbol_obstack
,
2672 sizeof (struct mips_extra_func_info
)));
2673 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2674 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2675 SYMBOL_CLASS (s
) = LOC_CONST
;
2676 SYMBOL_TYPE (s
) = builtin_type_void
;
2677 SYMBOL_VALUE (s
) = (long) e
;
2678 add_symbol_to_list (s
, &local_symbols
);
2681 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2683 /* Handle encoded stab line number. */
2684 record_line (current_subfile
, sh
.index
, valu
);
2686 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2687 /* These are generated by gcc-2.x, do not complain */
2690 complain (&stab_unknown_complaint
, name
);
2692 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2695 /* Sort the symbol table now, we are done adding symbols to it.
2696 We must do this before parse_procedure calls lookup_symbol. */
2697 sort_symtab_syms (st
);
2699 /* This may not be necessary for stabs symtabs. FIXME. */
2702 /* Fill in procedure info next. */
2704 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2705 + fh
->ipdFirst
* external_pdr_size
);
2706 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2707 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2711 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2717 parse_procedure (&pr
, st
, first_off
);
2722 /* This symbol table contains ordinary ecoff entries. */
2724 /* FIXME: doesn't use pst->section_offsets. */
2730 /* How many symbols will we need */
2731 /* FIXME, this does not count enum values. */
2732 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2736 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2740 f_max
+= fh
->csym
+ fh
->cpd
;
2741 maxlines
= 2 * fh
->cline
;
2742 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2744 /* The proper language was already determined when building
2745 the psymtab, use it. */
2746 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2749 psymtab_language
= st
->language
;
2751 lines
= LINETABLE (st
);
2753 /* Get a new lexical context */
2755 push_parse_stack ();
2756 top_stack
->cur_st
= st
;
2757 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2759 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2760 BLOCK_END (top_stack
->cur_block
) = 0;
2761 top_stack
->blocktype
= stFile
;
2762 top_stack
->maxsyms
= 2 * f_max
;
2763 top_stack
->cur_type
= 0;
2764 top_stack
->procadr
= 0;
2765 top_stack
->numargs
= 0;
2772 /* Parse local symbols first */
2773 sym_ptr
= ((char *) ecoff_data (cur_bfd
)->external_sym
2774 + fh
->isymBase
* external_sym_size
);
2775 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2776 while (sym_ptr
< sym_end
)
2781 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2782 c
= parse_symbol (&sh
,
2783 (ecoff_data (cur_bfd
)->external_aux
2785 sym_ptr
, fh
->fBigendian
);
2786 sym_ptr
+= c
* external_sym_size
;
2789 /* Linenumbers. At the end, check if we can save memory.
2790 parse_lines has to look ahead an arbitrary number of PDR
2791 structures, so we swap them all first. */
2795 struct cleanup
*old_chain
;
2801 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2803 old_chain
= make_cleanup (free
, pr_block
);
2805 pdr_ptr
= ((char *) ecoff_data (cur_bfd
)->external_pdr
2806 + fh
->ipdFirst
* external_pdr_size
);
2807 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2811 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2812 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2814 parse_lines (fh
, pr_block
, lines
);
2815 if (lines
->nitems
< fh
->cline
)
2816 lines
= shrink_linetable (lines
);
2818 /* Fill in procedure info next. */
2820 pdr_in_end
= pdr_in
+ fh
->cpd
;
2821 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2822 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2824 do_cleanups (old_chain
);
2828 LINETABLE (st
) = lines
;
2830 /* .. and our share of externals.
2831 XXX use the global list to speed up things here. how?
2832 FIXME, Maybe quit once we have found the right number of ext's? */
2833 top_stack
->cur_st
= st
;
2834 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2836 top_stack
->blocktype
= stFile
;
2837 top_stack
->maxsyms
= (ecoff_data (cur_bfd
)->symbolic_header
.isymMax
2838 + ecoff_data (cur_bfd
)->symbolic_header
.ipdMax
2839 + ecoff_data (cur_bfd
)->symbolic_header
.iextMax
);
2841 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2842 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2843 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2845 /* If there are undefined, tell the user */
2846 if (n_undef_symbols
)
2848 printf_filtered ("File %s contains %d unresolved references:",
2849 st
->filename
, n_undef_symbols
);
2850 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2851 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2852 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2857 /* Sort the symbol table now, we are done adding symbols to it.*/
2858 sort_symtab_syms (st
);
2863 /* Now link the psymtab and the symtab. */
2866 current_objfile
= NULL
;
2869 /* Ancillary parsing procedures. */
2871 /* Lookup the type at relative index RN. Return it in TPP
2872 if found and in any event come up with its name PNAME.
2873 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2874 Return value says how many aux symbols we ate. */
2877 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2881 enum type_code type_code
; /* Use to alloc new type if none is found. */
2893 struct mips_pending
*pend
;
2895 *tpp
= (struct type
*)NULL
;
2897 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2899 /* Escape index means 'the next one' */
2900 if (rn
->rfd
== 0xfff)
2903 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2910 /* mips cc uses a rf of -1 for opaque struct definitions.
2911 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2912 resolve them if the struct gets defined in another compilation unit. */
2915 *pname
= "<undefined>";
2916 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2917 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2921 /* mips cc uses an escaped rn->index of 0 for struct return types
2922 of procedures that were compiled without -g. These will always remain
2924 if (rn
->rfd
== 0xfff && rn
->index
== 0)
2926 *pname
= "<undefined>";
2930 /* Find the relative file descriptor and the symbol in it. */
2931 fh
= get_rfd (fd
, rf
);
2932 xref_fd
= fh
- ecoff_data (cur_bfd
)->fdr
;
2934 if (rn
->index
>= fh
->csym
)
2936 /* File indirect entry is corrupt. */
2937 *pname
= "<illegal>";
2938 complain (&bad_rfd_entry_complaint
,
2939 sym_name
, xref_fd
, rn
->index
);
2943 /* If we have processed this symbol then we left a forwarding
2944 pointer to the type in the pending list. If not, we`ll put
2945 it in a list of pending types, to be processed later when
2946 the file will be. In any event, we collect the name for the
2949 esh
= ((char *) ecoff_data (cur_bfd
)->external_sym
2950 + ((fh
->isymBase
+ rn
->index
)
2951 * ecoff_backend (cur_bfd
)->external_sym_size
));
2952 (*ecoff_backend (cur_bfd
)->swap_sym_in
) (cur_bfd
, esh
, &sh
);
2954 /* Make sure that this type of cross reference can be handled. */
2956 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
2957 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
2958 && sh
.st
!= stEnum
))
2960 /* File indirect entry is corrupt. */
2961 *pname
= "<illegal>";
2962 complain (&bad_rfd_entry_complaint
,
2963 sym_name
, xref_fd
, rn
->index
);
2967 *pname
= ecoff_data (cur_bfd
)->ss
+ fh
->issBase
+ sh
.iss
;
2969 pend
= is_pending_symbol (fh
, esh
);
2974 /* We have not yet seen this type. */
2976 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
2980 /* alpha cc puts out a stTypedef with a sh.iss of zero for
2982 a) forward declarations of structs/unions/enums which are not
2983 defined in this compilation unit.
2984 For these the type will be void. This is a bad design decision
2985 as cross referencing across compilation units is impossible
2986 due to the missing name.
2987 b) forward declarations of structs/unions/enums which are defined
2988 later in this file or in another file in the same compilation
2989 unit. Simply cross reference those again to get the
2991 The forward references are not entered in the pending list and
2992 in the symbol table. */
2994 ecoff_swap_tir_in (bigend
,
2995 &(ecoff_data (cur_bfd
)->external_aux
2996 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2998 if (tir
.tq0
!= tqNil
)
2999 complain (&illegal_forward_tq0_complaint
, sym_name
);
3003 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3005 *pname
= "<undefined>";
3012 (ecoff_data (cur_bfd
)->external_aux
3013 + fh
->iauxBase
+ sh
.index
+ 1),
3014 tpp
, type_code
, pname
,
3015 fh
->fBigendian
, sym_name
);
3019 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3020 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3026 else if (sh
.st
== stTypedef
)
3028 /* Parse the type for a normal typedef. This might recursively call
3029 cross_ref till we get a non typedef'ed type.
3030 FIXME: This is not correct behaviour, but gdb currently
3031 cannot handle typedefs without type copying. But type copying is
3032 impossible as we might have mutual forward references between
3033 two files and the copied type would not get filled in when
3034 we later parse its definition. */
3035 *tpp
= parse_type (xref_fd
,
3036 (ecoff_data (cur_bfd
)->external_aux
3037 + fh
->iauxBase
+ sh
.index
),
3040 (ecoff_data (cur_bfd
)->ss
3041 + fh
->issBase
+ sh
.iss
));
3045 /* Cross reference to a struct/union/enum which is defined
3046 in another file in the same compilation unit but that file
3047 has not been parsed yet.
3048 Initialize the type only, it will be filled in when
3049 it's definition is parsed. */
3050 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3052 add_pending (fh
, esh
, *tpp
);
3055 /* We used one auxent normally, two if we got a "next one" rf. */
3060 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3061 keeping the symtab sorted */
3063 static struct symbol
*
3064 mylookup_symbol (name
, block
, namespace, class)
3066 register struct block
*block
;
3067 enum namespace namespace;
3068 enum address_class
class;
3070 register int bot
, top
, inc
;
3071 register struct symbol
*sym
;
3074 top
= BLOCK_NSYMS (block
);
3078 sym
= BLOCK_SYM (block
, bot
);
3079 if (SYMBOL_NAME (sym
)[0] == inc
3080 && SYMBOL_NAMESPACE (sym
) == namespace
3081 && SYMBOL_CLASS (sym
) == class
3082 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3086 block
= BLOCK_SUPERBLOCK (block
);
3088 return mylookup_symbol (name
, block
, namespace, class);
3093 /* Add a new symbol S to a block B.
3094 Infrequently, we will need to reallocate the block to make it bigger.
3095 We only detect this case when adding to top_stack->cur_block, since
3096 that's the only time we know how big the block is. FIXME. */
3103 int nsyms
= BLOCK_NSYMS (b
)++;
3104 struct block
*origb
;
3105 struct parse_stack
*stackp
;
3107 if (b
== top_stack
->cur_block
&&
3108 nsyms
>= top_stack
->maxsyms
)
3110 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3111 /* In this case shrink_block is actually grow_block, since
3112 BLOCK_NSYMS(b) is larger than its current size. */
3114 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3116 /* Now run through the stack replacing pointers to the
3117 original block. shrink_block has already done this
3118 for the blockvector and BLOCK_FUNCTION. */
3119 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3121 if (stackp
->cur_block
== origb
)
3123 stackp
->cur_block
= b
;
3124 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3128 BLOCK_SYM (b
, nsyms
) = s
;
3131 /* Add a new block B to a symtab S */
3138 struct blockvector
*bv
= BLOCKVECTOR (s
);
3140 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3141 (sizeof (struct blockvector
)
3142 + BLOCKVECTOR_NBLOCKS (bv
)
3143 * sizeof (bv
->block
)));
3144 if (bv
!= BLOCKVECTOR (s
))
3145 BLOCKVECTOR (s
) = bv
;
3147 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3150 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3151 MIPS' linenumber encoding might need more than one byte
3152 to describe it, LAST is used to detect these continuation lines.
3154 Combining lines with the same line number seems like a bad idea.
3155 E.g: There could be a line number entry with the same line number after the
3156 prologue and GDB should not ignore it (this is a better way to find
3157 a prologue than mips_skip_prologue).
3158 But due to the compressed line table format there are line number entries
3159 for the same line which are needed to bridge the gap to the next
3160 line number entry. These entries have a bogus address info with them
3161 and we are unable to tell them from intended duplicate line number
3163 This is another reason why -ggdb debugging format is preferable. */
3166 add_line (lt
, lineno
, adr
, last
)
3167 struct linetable
*lt
;
3173 last
= -2; /* make sure we record first line */
3175 if (last
== lineno
) /* skip continuation lines */
3178 lt
->item
[lt
->nitems
].line
= lineno
;
3179 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3183 /* Sorting and reordering procedures */
3185 /* Blocks with a smaller low bound should come first */
3188 compare_blocks (arg1
, arg2
)
3189 const void *arg1
, *arg2
;
3191 register int addr_diff
;
3192 struct block
**b1
= (struct block
**) arg1
;
3193 struct block
**b2
= (struct block
**) arg2
;
3195 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3197 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3201 /* Sort the blocks of a symtab S.
3202 Reorder the blocks in the blockvector by code-address,
3203 as required by some MI search routines */
3209 struct blockvector
*bv
= BLOCKVECTOR (s
);
3211 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3214 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3215 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3216 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3217 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3221 * This is very unfortunate: normally all functions are compiled in
3222 * the order they are found, but if the file is compiled -O3 things
3223 * are very different. It would be nice to find a reliable test
3224 * to detect -O3 images in advance.
3226 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3227 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3228 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3229 sizeof (struct block
*),
3233 register CORE_ADDR high
= 0;
3234 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3236 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3237 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3238 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3239 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3242 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3243 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3245 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3246 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3247 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3248 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3252 /* Constructor/restructor/destructor procedures */
3254 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3255 MAXSYMS and linenumbers MAXLINES we'll put in it */
3257 static struct symtab
*
3258 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3262 struct objfile
*objfile
;
3264 struct symtab
*s
= allocate_symtab (name
, objfile
);
3266 LINETABLE (s
) = new_linetable (maxlines
);
3268 /* All symtabs must have at least two blocks */
3269 BLOCKVECTOR (s
) = new_bvect (2);
3270 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3271 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3272 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3273 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3275 s
->free_code
= free_linetable
;
3280 /* Allocate a new partial_symtab NAME */
3282 static struct partial_symtab
*
3283 new_psymtab (name
, objfile
)
3285 struct objfile
*objfile
;
3287 struct partial_symtab
*psymtab
;
3289 psymtab
= allocate_psymtab (name
, objfile
);
3291 /* Keep a backpointer to the file's symbols */
3293 psymtab
->read_symtab_private
= ((char *)
3294 obstack_alloc (&objfile
->psymbol_obstack
,
3295 sizeof (struct symloc
)));
3296 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3297 CUR_BFD (psymtab
) = cur_bfd
;
3299 /* The way to turn this into a symtab is to call... */
3300 psymtab
->read_symtab
= mipscoff_psymtab_to_symtab
;
3305 /* Allocate a linetable array of the given SIZE. Since the struct
3306 already includes one item, we subtract one when calculating the
3307 proper size to allocate. */
3309 static struct linetable
*
3310 new_linetable (size
)
3313 struct linetable
*l
;
3315 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3316 l
= (struct linetable
*) xmalloc (size
);
3321 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3322 I am not so sure about the 3.4 ones.
3324 Since the struct linetable already includes one item, we subtract one when
3325 calculating the proper size to allocate. */
3327 static struct linetable
*
3328 shrink_linetable (lt
)
3329 struct linetable
*lt
;
3332 return (struct linetable
*) xrealloc ((PTR
) lt
,
3333 (sizeof (struct linetable
)
3335 * sizeof (lt
->item
))));
3338 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3340 static struct blockvector
*
3344 struct blockvector
*bv
;
3347 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3348 bv
= (struct blockvector
*) xzalloc (size
);
3350 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3355 /* Allocate and zero a new block of MAXSYMS symbols */
3357 static struct block
*
3361 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3363 return (struct block
*) xzalloc (size
);
3366 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3367 Shrink_block can also be used by add_symbol to grow a block. */
3369 static struct block
*
3375 struct blockvector
*bv
= BLOCKVECTOR (s
);
3378 /* Just reallocate it and fix references to the old one */
3380 new = (struct block
*) xrealloc ((PTR
) b
,
3381 (sizeof (struct block
)
3382 + ((BLOCK_NSYMS (b
) - 1)
3383 * sizeof (struct symbol
*))));
3385 /* Should chase pointers to old one. Fortunately, that`s just
3386 the block`s function and inferior blocks */
3387 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3388 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3389 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3390 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3391 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3392 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3393 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3397 /* Create a new symbol with printname NAME */
3399 static struct symbol
*
3403 struct symbol
*s
= ((struct symbol
*)
3404 obstack_alloc (¤t_objfile
->symbol_obstack
,
3405 sizeof (struct symbol
)));
3407 memset ((PTR
) s
, 0, sizeof (*s
));
3408 SYMBOL_NAME (s
) = name
;
3409 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3410 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3414 /* Create a new type with printname NAME */
3416 static struct type
*
3422 t
= alloc_type (current_objfile
);
3423 TYPE_NAME (t
) = name
;
3424 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3429 /* Things used for calling functions in the inferior.
3430 These functions are exported to our companion
3431 mips-tdep.c file and are here because they play
3432 with the symbol-table explicitly. */
3434 /* Sigtramp: make sure we have all the necessary information
3435 about the signal trampoline code. Since the official code
3436 from MIPS does not do so, we make up that information ourselves.
3437 If they fix the library (unlikely) this code will neutralize itself. */
3444 struct block
*b
, *b0
= NULL
;
3446 sigtramp_address
= -1;
3448 /* We have to handle the following cases here:
3449 a) The Mips library has a sigtramp label within sigvec.
3450 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3451 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3454 b0
= SYMBOL_BLOCK_VALUE (s
);
3455 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3459 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3460 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3463 /* But maybe this program uses its own version of sigvec */
3467 /* Did we or MIPSco fix the library ? */
3468 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3470 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3471 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3475 sigtramp_address
= SYMBOL_VALUE (s
);
3476 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3478 /* But what symtab does it live in ? */
3479 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3482 * Ok, there goes the fix: turn it into a procedure, with all the
3483 * needed info. Note we make it a nested procedure of sigvec,
3484 * which is the way the (assembly) code is actually written.
3486 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3487 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3488 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3490 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3492 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3494 SYMBOL_BLOCK_VALUE (s
) = b
;
3495 BLOCK_START (b
) = sigtramp_address
;
3496 BLOCK_END (b
) = sigtramp_end
;
3497 BLOCK_FUNCTION (b
) = s
;
3498 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3502 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3504 struct mips_extra_func_info
*e
=
3505 ((struct mips_extra_func_info
*)
3506 xzalloc (sizeof (struct mips_extra_func_info
)));
3508 e
->numargs
= 0; /* the kernel thinks otherwise */
3509 /* align_longword(sigcontext + SIGFRAME) */
3510 e
->pdr
.frameoffset
= 0x150;
3511 e
->pdr
.framereg
= SP_REGNUM
;
3512 /* read_next_frame_reg provides the true pc at the time of signal */
3513 e
->pdr
.pcreg
= PC_REGNUM
;
3514 e
->pdr
.regmask
= -2;
3515 e
->pdr
.regoffset
= -(41 * sizeof (int));
3516 e
->pdr
.fregmask
= -1;
3517 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3518 e
->pdr
.isym
= (long) s
;
3519 e
->pdr
.adr
= sigtramp_address
;
3521 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3522 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3523 SYMBOL_VALUE (s
) = (long) e
;
3524 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3525 SYMBOL_CLASS (s
) = LOC_CONST
;
3526 SYMBOL_TYPE (s
) = builtin_type_void
;
3527 current_objfile
= NULL
;
3530 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3534 /* Fake up identical offsets for all sections. */
3536 struct section_offsets
*
3537 mipscoff_symfile_offsets (objfile
, addr
)
3538 struct objfile
*objfile
;
3541 struct section_offsets
*section_offsets
;
3544 section_offsets
= ((struct section_offsets
*)
3545 obstack_alloc (&objfile
->psymbol_obstack
,
3546 (sizeof (struct section_offsets
)
3547 + (sizeof (section_offsets
->offsets
)
3548 * (SECT_OFF_MAX
- 1)))));
3550 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
3551 ANOFFSET (section_offsets
, i
) = addr
;
3553 return section_offsets
;
3556 /* Initialization */
3558 static struct sym_fns ecoff_sym_fns
=
3560 "ecoff", /* sym_name: name or name prefix of BFD target type */
3561 5, /* sym_namelen: number of significant sym_name chars */
3562 mipscoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3563 mipscoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3564 mipscoff_symfile_read
, /* sym_read: read a symbol file into symtab */
3565 mipscoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3566 mipscoff_symfile_offsets
, /* sym_offsets: dummy FIXME til implem sym reloc */
3567 NULL
/* next: pointer to next struct sym_fns */
3572 _initialize_mipsread ()
3574 add_symtab_fns (&ecoff_sym_fns
);
3576 /* Missing basic types */
3578 builtin_type_string
=
3579 init_type (TYPE_CODE_STRING
,
3580 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3582 (struct objfile
*) NULL
);
3583 builtin_type_complex
=
3584 init_type (TYPE_CODE_FLT
,
3585 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3587 (struct objfile
*) NULL
);
3588 builtin_type_double_complex
=
3589 init_type (TYPE_CODE_FLT
,
3590 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3591 0, "double complex",
3592 (struct objfile
*) NULL
);
3593 builtin_type_fixed_dec
=
3594 init_type (TYPE_CODE_INT
,
3595 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3597 (struct objfile
*) NULL
);
3598 builtin_type_float_dec
=
3599 init_type (TYPE_CODE_FLT
,
3600 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3601 0, "floating decimal",
3602 (struct objfile
*) NULL
);