1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
5 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 /* This module provides the function mdebug_build_psymtabs. It reads
25 ECOFF debugging information into partial symbol tables. The
26 debugging information is read from two structures. A struct
27 ecoff_debug_swap includes the sizes of each ECOFF structure and
28 swapping routines; these are fixed for a particular target. A
29 struct ecoff_debug_info points to the debugging information for a
30 particular object file.
32 ECOFF symbol tables are mostly written in the byte order of the
33 target machine. However, one section of the table (the auxiliary
34 symbol information) is written in the host byte order. There is a
35 bit in the other symbol info which describes which host byte order
36 was used. ECOFF thereby takes the trophy from Intel `b.out' for
37 the most brain-dead adaptation of a file format to byte order.
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
50 #include "stabsread.h"
51 #include "complaints.h"
53 #if !defined (SEEK_SET)
58 /* These are needed if the tm.h file does not contain the necessary
59 mips specific definitions. */
61 #ifndef MIPS_EFI_SYMBOL_NAME
62 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
{
68 } *mips_extra_func_info_t
;
75 #include <sys/types.h>
78 #include <sys/param.h>
83 #include "gdb-stabs.h"
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
93 #include "expression.h"
94 #include "language.h" /* Needed inside partial-stab.h */
96 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
97 #ifndef ECOFF_REG_TO_REGNUM
98 #define ECOFF_REG_TO_REGNUM(num) (num)
101 /* Each partial symbol table entry contains a pointer to private data for the
102 sym_read function to use when expanding a partial symbol table entry
103 to a full symbol table entry. */
107 /* Index of the FDR that this psymtab represents. */
109 /* The BFD that the psymtab was created from. */
111 const struct ecoff_debug_swap
*debug_swap
;
112 struct ecoff_debug_info
*debug_info
;
113 struct mdebug_pending
**pending_list
;
114 /* Pointer to external symbols for this file. */
116 /* Size of extern_tab. */
118 enum language pst_language
;
121 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
122 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
123 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
124 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
125 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
126 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
128 /* Things we import explicitly from other modules */
130 extern int info_verbose
;
132 /* Various complaints about symbol reading that don't abort the process */
134 static struct complaint bad_file_number_complaint
=
135 {"bad file number %d", 0, 0};
137 static struct complaint index_complaint
=
138 {"bad aux index at symbol %s", 0, 0};
140 static struct complaint aux_index_complaint
=
141 {"bad proc end in aux found from symbol %s", 0, 0};
143 static struct complaint block_index_complaint
=
144 {"bad aux index at block symbol %s", 0, 0};
146 static struct complaint unknown_ext_complaint
=
147 {"unknown external symbol %s", 0, 0};
149 static struct complaint unknown_sym_complaint
=
150 {"unknown local symbol %s", 0, 0};
152 static struct complaint unknown_st_complaint
=
153 {"with type %d", 0, 0};
155 static struct complaint block_overflow_complaint
=
156 {"block containing %s overfilled", 0, 0};
158 static struct complaint basic_type_complaint
=
159 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
161 static struct complaint unknown_type_qual_complaint
=
162 {"unknown type qualifier 0x%x", 0, 0};
164 static struct complaint array_index_type_complaint
=
165 {"illegal array index type for %s, assuming int", 0, 0};
167 static struct complaint bad_tag_guess_complaint
=
168 {"guessed tag type of %s incorrectly", 0, 0};
170 static struct complaint block_member_complaint
=
171 {"declaration block contains unhandled symbol type %d", 0, 0};
173 static struct complaint stEnd_complaint
=
174 {"stEnd with storage class %d not handled", 0, 0};
176 static struct complaint unknown_mdebug_symtype_complaint
=
177 {"unknown symbol type 0x%x", 0, 0};
179 static struct complaint stab_unknown_complaint
=
180 {"unknown stabs symbol %s", 0, 0};
182 static struct complaint pdr_for_nonsymbol_complaint
=
183 {"PDR for %s, but no symbol", 0, 0};
185 static struct complaint pdr_static_symbol_complaint
=
186 {"can't handle PDR for static proc at 0x%lx", 0, 0};
188 static struct complaint bad_setjmp_pdr_complaint
=
189 {"fixing bad setjmp PDR from libc", 0, 0};
191 static struct complaint bad_fbitfield_complaint
=
192 {"can't handle TIR fBitfield for %s", 0, 0};
194 static struct complaint bad_continued_complaint
=
195 {"illegal TIR continued for %s", 0, 0};
197 static struct complaint bad_rfd_entry_complaint
=
198 {"bad rfd entry for %s: file %d, index %d", 0, 0};
200 static struct complaint unexpected_type_code_complaint
=
201 {"unexpected type code for %s", 0, 0};
203 static struct complaint unable_to_cross_ref_complaint
=
204 {"unable to cross ref btTypedef for %s", 0, 0};
206 static struct complaint illegal_forward_tq0_complaint
=
207 {"illegal tq0 in forward typedef for %s", 0, 0};
209 static struct complaint illegal_forward_bt_complaint
=
210 {"illegal bt %d in forward typedef for %s", 0, 0};
212 static struct complaint bad_linetable_guess_complaint
=
213 {"guessed size of linetable for %s incorrectly", 0, 0};
215 static struct complaint bad_ext_ifd_complaint
=
216 {"bad ifd for external symbol: %d (max %d)", 0, 0};
218 static struct complaint bad_ext_iss_complaint
=
219 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
221 /* Macros and extra defs */
223 /* Puns: hard to find whether -g was used and how */
225 #define MIN_GLEVEL GLEVEL_0
226 #define compare_glevel(a,b) \
227 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
228 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
230 /* Things that really are local to this module */
232 /* Remember what we deduced to be the source language of this psymtab. */
234 static enum language psymtab_language
= language_unknown
;
240 /* How to parse debugging information for CUR_BFD. */
242 static const struct ecoff_debug_swap
*debug_swap
;
244 /* Pointers to debugging information for CUR_BFD. */
246 static struct ecoff_debug_info
*debug_info
;
248 /* Pointer to current file decriptor record, and its index */
253 /* Index of current symbol */
257 /* Note how much "debuggable" this image is. We would like
258 to see at least one FDR with full symbols */
263 /* When examining .o files, report on undefined symbols */
265 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
267 /* Pseudo symbol to use when putting stabs into the symbol table. */
269 static char stabs_symbol
[] = STABS_SYMBOL
;
271 /* Types corresponding to btComplex, btDComplex, etc. These are here
272 rather than in gdbtypes.c or some such, because the meaning of codes
273 like btComplex is specific to the mdebug debug format. FIXME: We should
274 be using our own types thoughout this file, instead of sometimes using
277 static struct type
*mdebug_type_fixed_dec
;
278 static struct type
*mdebug_type_float_dec
;
279 static struct type
*mdebug_type_string
;
281 /* Types for symbols from files compiled without debugging info. */
283 static struct type
*nodebug_func_symbol_type
;
284 static struct type
*nodebug_var_symbol_type
;
286 /* Nonzero if we have seen ecoff debugging info for a file. */
288 static int found_ecoff_debugging_info
;
290 /* Forward declarations */
293 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
296 parse_partial_symbols
PARAMS ((struct objfile
*,
297 struct section_offsets
*));
300 *get_rfd
PARAMS ((int, int));
303 has_opaque_xref
PARAMS ((FDR
*, SYMR
*));
306 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
307 char **, int, char *));
309 static struct symbol
*
310 new_symbol
PARAMS ((char *));
313 new_type
PARAMS ((char *));
315 static struct block
*
316 new_block
PARAMS ((int));
318 static struct symtab
*
319 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
321 static struct linetable
*
322 new_linetable
PARAMS ((int));
324 static struct blockvector
*
325 new_bvect
PARAMS ((int));
328 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int, struct section_offsets
*));
331 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
333 static struct symbol
*
334 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
335 enum address_class
));
337 static struct block
*
338 shrink_block
PARAMS ((struct block
*, struct symtab
*));
341 xzalloc
PARAMS ((unsigned int));
344 sort_blocks
PARAMS ((struct symtab
*));
347 compare_blocks
PARAMS ((const void *, const void *));
349 static struct partial_symtab
*
350 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
353 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
356 add_block
PARAMS ((struct block
*, struct symtab
*));
359 add_symbol
PARAMS ((struct symbol
*, struct block
*));
362 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
364 static struct linetable
*
365 shrink_linetable
PARAMS ((struct linetable
*));
368 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int));
371 mdebug_next_symbol_text
PARAMS ((void));
373 /* Address bounds for the signal trampoline in inferior, if any */
375 CORE_ADDR sigtramp_address
, sigtramp_end
;
377 /* Allocate zeroed memory */
383 PTR p
= xmalloc (size
);
389 /* Exported procedure: Builds a symtab from the PST partial one.
390 Restores the environment in effect when PST was created, delegates
391 most of the work to an ancillary procedure, and sorts
392 and reorders the symtab list at the end */
395 mdebug_psymtab_to_symtab (pst
)
396 struct partial_symtab
*pst
;
404 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
405 gdb_flush (gdb_stdout
);
408 next_symbol_text_func
= mdebug_next_symbol_text
;
410 psymtab_to_symtab_1 (pst
, pst
->filename
);
412 /* Match with global symbols. This only needs to be done once,
413 after all of the symtabs and dependencies have been read in. */
414 scan_file_globals (pst
->objfile
);
417 printf_filtered ("done.\n");
420 /* File-level interface functions */
422 /* Find a file descriptor given its index RF relative to a file CF */
432 fdrs
= debug_info
->fdr
;
434 /* Object files do not have the RFD table, all refs are absolute */
437 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
438 ((char *) debug_info
->external_rfd
440 * debug_swap
->external_rfd_size
)),
445 /* Return a safer print NAME for a file descriptor */
452 return "<stripped file>";
455 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
459 /* Read in and parse the symtab of the file OBJFILE. Symbols from
460 different sections are relocated via the SECTION_OFFSETS. */
463 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
464 struct objfile
*objfile
;
465 const struct ecoff_debug_swap
*swap
;
466 struct ecoff_debug_info
*info
;
467 struct section_offsets
*section_offsets
;
469 cur_bfd
= objfile
->obfd
;
473 /* Make sure all the FDR information is swapped in. */
474 if (info
->fdr
== (FDR
*) NULL
)
480 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
481 (info
->symbolic_header
.ifdMax
483 fdr_src
= info
->external_fdr
;
485 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
487 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
488 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
491 parse_partial_symbols (objfile
, section_offsets
);
494 /* Check to make sure file was compiled with -g. If not, warn the
495 user of this limitation. */
496 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
498 if (max_gdbinfo
== 0)
499 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
501 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
502 gdb_flush (gdb_stdout
);
507 /* Local utilities */
509 /* Map of FDR indexes to partial symtabs */
513 struct partial_symtab
*pst
; /* the psymtab proper */
514 long n_globals
; /* exported globals (external symbols) */
515 long globals_offset
; /* cumulative */
519 /* Utility stack, used to nest procedures and blocks properly.
520 It is a doubly linked list, to avoid too many alloc/free.
521 Since we might need it quite a few times it is NOT deallocated
524 static struct parse_stack
526 struct parse_stack
*next
, *prev
;
527 struct symtab
*cur_st
; /* Current symtab. */
528 struct block
*cur_block
; /* Block in it. */
530 /* What are we parsing. stFile, or stBlock are for files and
531 blocks. stProc or stStaticProc means we have seen the start of a
532 procedure, but not the start of the block within in. When we see
533 the start of that block, we change it to stNil, without pushing a
534 new block, i.e. stNil means both a procedure and a block. */
538 int maxsyms
; /* Max symbols in this block. */
539 struct type
*cur_type
; /* Type we parse fields for. */
540 int cur_field
; /* Field number in cur_type. */
541 CORE_ADDR procadr
; /* Start addres of this procedure */
542 int numargs
; /* Its argument count */
545 *top_stack
; /* Top stack ptr */
548 /* Enter a new lexical context */
553 struct parse_stack
*new;
555 /* Reuse frames if possible */
556 if (top_stack
&& top_stack
->prev
)
557 new = top_stack
->prev
;
559 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
560 /* Initialize new frame with previous content */
563 register struct parse_stack
*prev
= new->prev
;
566 top_stack
->prev
= new;
568 new->next
= top_stack
;
573 /* Exit a lexical context */
581 top_stack
= top_stack
->next
;
585 /* Cross-references might be to things we haven't looked at
586 yet, e.g. type references. To avoid too many type
587 duplications we keep a quick fixup table, an array
588 of lists of references indexed by file descriptor */
590 struct mdebug_pending
592 struct mdebug_pending
*next
; /* link */
593 char *s
; /* the unswapped symbol */
594 struct type
*t
; /* its partial type descriptor */
598 /* The pending information is kept for an entire object file, and used
599 to be in the sym_private field. I took it out when I split
600 mdebugread from mipsread, because this might not be the only type
601 of symbols read from an object file. Instead, we allocate the
602 pending information table when we create the partial symbols, and
603 we store a pointer to the single table in each psymtab. */
605 static struct mdebug_pending
**pending_list
;
607 /* Check whether we already saw symbol SH in file FH */
609 static struct mdebug_pending
*
610 is_pending_symbol (fh
, sh
)
614 int f_idx
= fh
- debug_info
->fdr
;
615 register struct mdebug_pending
*p
;
617 /* Linear search is ok, list is typically no more than 10 deep */
618 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
624 /* Add a new symbol SH of type T */
627 add_pending (fh
, sh
, t
)
632 int f_idx
= fh
- debug_info
->fdr
;
633 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
635 /* Make sure we do not make duplicates */
638 p
= ((struct mdebug_pending
*)
639 obstack_alloc (¤t_objfile
->psymbol_obstack
,
640 sizeof (struct mdebug_pending
)));
643 p
->next
= pending_list
[f_idx
];
644 pending_list
[f_idx
] = p
;
649 /* Parsing Routines proper. */
651 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
652 For blocks, procedures and types we open a new lexical context.
653 This is basically just a big switch on the symbol's type. Argument
654 AX is the base pointer of aux symbols for this file (fh->iauxBase).
655 EXT_SH points to the unswapped symbol, which is needed for struct,
656 union, etc., types; it is NULL for an EXTR. BIGEND says whether
657 aux symbols are big-endian or little-endian. Return count of
658 SYMR's handled (normally one). */
661 parse_symbol (sh
, ax
, ext_sh
, bigend
, section_offsets
)
666 struct section_offsets
*section_offsets
;
668 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
669 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
670 debug_swap
->swap_sym_in
;
674 struct mdebug_pending
*pend
;
678 enum address_class
class;
680 long svalue
= sh
->value
;
683 if (ext_sh
== (char *) NULL
)
684 name
= debug_info
->ssext
+ sh
->iss
;
686 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
691 /* The value of a stEnd symbol is the displacement from the
692 corresponding start symbol value, do not relocate it. */
694 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
701 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
705 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
714 case stGlobal
: /* external symbol, goes into global block */
716 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
718 s
= new_symbol (name
);
719 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
722 case stStatic
: /* static data, goes into current block. */
724 b
= top_stack
->cur_block
;
725 s
= new_symbol (name
);
726 if (sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
728 /* It is a FORTRAN common block. At least for SGI Fortran the
729 address is not in the symbol; we need to fix it later in
730 scan_file_globals. */
731 int bucket
= hashname (SYMBOL_NAME (s
));
732 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
733 global_sym_chain
[bucket
] = s
;
736 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
739 case stLocal
: /* local variable, goes into current block */
740 if (sh
->sc
== scRegister
)
742 class = LOC_REGISTER
;
743 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
747 b
= top_stack
->cur_block
;
748 s
= new_symbol (name
);
749 SYMBOL_VALUE (s
) = svalue
;
751 data
: /* Common code for symbols describing data */
752 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
753 SYMBOL_CLASS (s
) = class;
756 /* Type could be missing if file is compiled without debugging info. */
757 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
|| sh
->index
== indexNil
)
758 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
760 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
761 /* Value of a data symbol is its memory address */
764 case stParam
: /* arg to procedure, goes into current block */
766 found_ecoff_debugging_info
= 1;
767 top_stack
->numargs
++;
769 /* Special GNU C++ name. */
770 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
771 name
= "this"; /* FIXME, not alloc'd in obstack */
772 s
= new_symbol (name
);
774 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
778 /* Pass by value in register. */
779 SYMBOL_CLASS(s
) = LOC_REGPARM
;
780 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
783 /* Pass by reference on stack. */
784 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
787 /* Pass by reference in register. */
788 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
789 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
792 /* Pass by value on stack. */
793 SYMBOL_CLASS(s
) = LOC_ARG
;
796 SYMBOL_VALUE (s
) = svalue
;
797 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
798 add_symbol (s
, top_stack
->cur_block
);
801 case stLabel
: /* label, goes into current block */
802 s
= new_symbol (name
);
803 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
804 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
805 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
806 SYMBOL_TYPE (s
) = builtin_type_int
;
807 add_symbol (s
, top_stack
->cur_block
);
810 case stProc
: /* Procedure, usually goes into global block */
811 case stStaticProc
: /* Static procedure, goes into current block */
812 s
= new_symbol (name
);
813 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
814 SYMBOL_CLASS (s
) = LOC_BLOCK
;
815 /* Type of the return value */
816 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
817 t
= builtin_type_int
;
819 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
820 b
= top_stack
->cur_block
;
821 if (sh
->st
== stProc
)
823 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
824 /* The next test should normally be true, but provides a
825 hook for nested functions (which we don't want to make
827 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
828 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
829 /* Irix 5 sometimes has duplicate names for the same
830 function. We want to add such names up at the global
831 level, not as a nested function. */
832 else if (sh
->value
== top_stack
->procadr
)
833 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
837 /* Make a type for the procedure itself */
838 SYMBOL_TYPE (s
) = lookup_function_type (t
);
840 /* Create and enter a new lexical context */
841 b
= new_block (top_stack
->maxsyms
);
842 SYMBOL_BLOCK_VALUE (s
) = b
;
843 BLOCK_FUNCTION (b
) = s
;
844 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
845 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
846 add_block (b
, top_stack
->cur_st
);
848 /* Not if we only have partial info */
849 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
853 top_stack
->cur_block
= b
;
854 top_stack
->blocktype
= sh
->st
;
855 top_stack
->cur_type
= SYMBOL_TYPE (s
);
856 top_stack
->cur_field
= -1;
857 top_stack
->procadr
= sh
->value
;
858 top_stack
->numargs
= 0;
861 /* Beginning of code for structure, union, and enum definitions.
862 They all share a common set of local variables, defined here. */
864 enum type_code type_code
;
870 case stStruct
: /* Start a block defining a struct type */
871 type_code
= TYPE_CODE_STRUCT
;
872 goto structured_common
;
874 case stUnion
: /* Start a block defining a union type */
875 type_code
= TYPE_CODE_UNION
;
876 goto structured_common
;
878 case stEnum
: /* Start a block defining an enum type */
879 type_code
= TYPE_CODE_ENUM
;
880 goto structured_common
;
882 case stBlock
: /* Either a lexical block, or some type */
883 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
884 goto case_stBlock_code
; /* Lexical block */
886 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
888 /* Common code for handling struct, union, enum, and/or as-yet-
889 unknown-type blocks of info about structured data. `type_code'
890 has been set to the proper TYPE_CODE, if we know it. */
892 found_ecoff_debugging_info
= 1;
894 top_stack
->blocktype
= stBlock
;
896 /* First count the number of fields and the highest value. */
899 for (ext_tsym
= ext_sh
+ external_sym_size
;
901 ext_tsym
+= external_sym_size
)
905 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
913 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
914 /* If the type of the member is Nil (or Void),
915 without qualifiers, assume the tag is an
917 if (tsym
.index
== indexNil
)
918 type_code
= TYPE_CODE_ENUM
;
921 (*debug_swap
->swap_tir_in
) (bigend
,
922 &ax
[tsym
.index
].a_ti
,
924 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
926 type_code
= TYPE_CODE_ENUM
;
929 if (tsym
.value
> max_value
)
930 max_value
= tsym
.value
;
939 /* This is a no-op; is it trying to tell us something
940 we should be checking? */
941 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
945 /* This is something like a struct within a
946 struct. Skip over the fields of the inner
947 struct. The -1 is because the for loop will
948 increment ext_tsym. */
949 ext_tsym
= ((char *) debug_info
->external_sym
950 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
951 * external_sym_size
));
957 /* mips cc puts out a typedef for struct x if it is not yet
958 defined when it encounters
959 struct y { struct x *xp; };
964 /* Irix5 cc puts out a stIndirect for struct x if it is not
965 yet defined when it encounters
966 struct y { struct x *xp; };
971 complain (&block_member_complaint
, tsym
.st
);
976 /* In an stBlock, there is no way to distinguish structs,
977 unions, and enums at this point. This is a bug in the
978 original design (that has been fixed with the recent
979 addition of the stStruct, stUnion, and stEnum symbol
980 types.) The way you can tell is if/when you see a variable
981 or field of that type. In that case the variable's type
982 (in the AUX table) says if the type is struct, union, or
983 enum, and points back to the stBlock here. So you can
984 patch the tag kind up later - but only if there actually is
985 a variable or field of that type.
987 So until we know for sure, we will guess at this point.
989 If the first member has index==indexNil or a void type,
990 assume we have an enumeration.
991 Otherwise, if there is more than one member, and all
992 the members have offset 0, assume we have a union.
993 Otherwise, assume we have a struct.
995 The heuristic could guess wrong in the case of of an
996 enumeration with no members or a union with one (or zero)
997 members, or when all except the last field of a struct have
998 width zero. These are uncommon and/or illegal situations,
999 and in any case guessing wrong probably doesn't matter
1002 But if we later do find out we were wrong, we fixup the tag
1003 kind. Members of an enumeration must be handled
1004 differently from struct/union fields, and that is harder to
1005 patch up, but luckily we shouldn't need to. (If there are
1006 any enumeration members, we can tell for sure it's an enum
1009 if (type_code
== TYPE_CODE_UNDEF
)
1010 if (nfields
> 1 && max_value
== 0)
1011 type_code
= TYPE_CODE_UNION
;
1013 type_code
= TYPE_CODE_STRUCT
;
1015 /* Create a new type or use the pending type. */
1016 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1017 if (pend
== (struct mdebug_pending
*) NULL
)
1019 t
= new_type (NULL
);
1020 add_pending (cur_fdr
, ext_sh
, t
);
1025 /* Do not set the tag name if it is a compiler generated tag name
1026 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1027 Alpha cc puts out an sh->iss of zero for those. */
1028 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1029 TYPE_TAG_NAME (t
) = NULL
;
1031 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1034 TYPE_CODE (t
) = type_code
;
1035 TYPE_LENGTH (t
) = sh
->value
;
1036 TYPE_NFIELDS (t
) = nfields
;
1037 TYPE_FIELDS (t
) = f
= ((struct field
*)
1039 nfields
* sizeof (struct field
)));
1041 if (type_code
== TYPE_CODE_ENUM
)
1043 /* This is a non-empty enum. */
1045 /* DEC c89 has the number of enumerators in the sh.value field,
1046 not the type length, so we have to compensate for that
1047 incompatibility quirk.
1048 This might do the wrong thing for an enum with one or two
1049 enumerators and gcc -gcoff -fshort-enums, but these cases
1050 are hopefully rare enough. */
1051 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1052 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1053 for (ext_tsym
= ext_sh
+ external_sym_size
;
1055 ext_tsym
+= external_sym_size
)
1058 struct symbol
*enum_sym
;
1060 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1062 if (tsym
.st
!= stMember
)
1065 f
->bitpos
= tsym
.value
;
1067 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1070 enum_sym
= ((struct symbol
*)
1071 obstack_alloc (¤t_objfile
->symbol_obstack
,
1072 sizeof (struct symbol
)));
1073 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1074 SYMBOL_NAME (enum_sym
) = f
->name
;
1075 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1076 SYMBOL_TYPE (enum_sym
) = t
;
1077 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1078 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1079 add_symbol (enum_sym
, top_stack
->cur_block
);
1081 /* Skip the stMembers that we've handled. */
1086 /* make this the current type */
1087 top_stack
->cur_type
= t
;
1088 top_stack
->cur_field
= 0;
1090 /* Do not create a symbol for alpha cc unnamed structs. */
1094 /* gcc puts out an empty struct for an opaque struct definitions,
1095 do not create a symbol for it either. */
1096 if (TYPE_NFIELDS (t
) == 0)
1098 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1102 s
= new_symbol (name
);
1103 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1104 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1105 SYMBOL_VALUE (s
) = 0;
1106 SYMBOL_TYPE (s
) = t
;
1107 add_symbol (s
, top_stack
->cur_block
);
1110 /* End of local variables shared by struct, union, enum, and
1111 block (as yet unknown struct/union/enum) processing. */
1115 found_ecoff_debugging_info
= 1;
1116 /* beginnning of (code) block. Value of symbol
1117 is the displacement from procedure start */
1118 push_parse_stack ();
1120 /* Do not start a new block if this is the outermost block of a
1121 procedure. This allows the LOC_BLOCK symbol to point to the
1122 block with the local variables, so funcname::var works. */
1123 if (top_stack
->blocktype
== stProc
1124 || top_stack
->blocktype
== stStaticProc
)
1126 top_stack
->blocktype
= stNil
;
1130 top_stack
->blocktype
= stBlock
;
1131 b
= new_block (top_stack
->maxsyms
);
1132 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1133 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1134 top_stack
->cur_block
= b
;
1135 add_block (b
, top_stack
->cur_st
);
1138 case stEnd
: /* end (of anything) */
1139 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1141 /* Finished with type */
1142 top_stack
->cur_type
= 0;
1144 else if (sh
->sc
== scText
&&
1145 (top_stack
->blocktype
== stProc
||
1146 top_stack
->blocktype
== stStaticProc
))
1148 /* Finished with procedure */
1149 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1150 struct mips_extra_func_info
*e
;
1152 struct type
*ftype
= top_stack
->cur_type
;
1155 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1157 /* Make up special symbol to contain procedure specific info */
1158 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1159 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1160 SYMBOL_CLASS (s
) = LOC_CONST
;
1161 SYMBOL_TYPE (s
) = builtin_type_void
;
1162 e
= ((struct mips_extra_func_info
*)
1163 obstack_alloc (¤t_objfile
->symbol_obstack
,
1164 sizeof (struct mips_extra_func_info
)));
1165 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
1166 SYMBOL_VALUE (s
) = (long) e
;
1167 e
->numargs
= top_stack
->numargs
;
1168 e
->pdr
.framereg
= -1;
1169 add_symbol (s
, top_stack
->cur_block
);
1171 /* Reallocate symbols, saving memory */
1172 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1174 /* f77 emits proc-level with address bounds==[0,0],
1175 So look for such child blocks, and patch them. */
1176 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1178 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1179 if (BLOCK_SUPERBLOCK (b_bad
) == b
1180 && BLOCK_START (b_bad
) == top_stack
->procadr
1181 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1183 BLOCK_START (b_bad
) = BLOCK_START (b
);
1184 BLOCK_END (b_bad
) = BLOCK_END (b
);
1188 if (TYPE_NFIELDS (ftype
) <= 0)
1190 /* No parameter type information is recorded with the function's
1191 type. Set that from the type of the parameter symbols. */
1192 int nparams
= top_stack
->numargs
;
1198 TYPE_NFIELDS (ftype
) = nparams
;
1199 TYPE_FIELDS (ftype
) = (struct field
*)
1200 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1202 for (i
= iparams
= 0; iparams
< nparams
; i
++)
1204 sym
= BLOCK_SYM (b
, i
);
1205 switch (SYMBOL_CLASS (sym
))
1210 case LOC_REGPARM_ADDR
:
1211 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1221 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1223 /* End of (code) block. The value of the symbol is the
1224 displacement from the procedure`s start address of the
1225 end of this block. */
1226 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1227 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1229 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1231 /* End of outermost block. Pop parse stack and ignore. The
1232 following stEnd of stProc will take care of the block. */
1235 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1237 /* End of file. Pop parse stack and ignore. Higher
1238 level code deals with this. */
1242 complain (&stEnd_complaint
, sh
->sc
);
1244 pop_parse_stack (); /* restore previous lexical context */
1247 case stMember
: /* member of struct or union */
1248 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1250 f
->bitpos
= sh
->value
;
1252 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1253 f
->bitsize
= bitsize
;
1256 case stIndirect
: /* forward declaration on Irix5 */
1257 /* Forward declarations from Irix5 cc are handled by cross_ref,
1261 case stTypedef
: /* type definition */
1262 found_ecoff_debugging_info
= 1;
1264 /* Typedefs for forward declarations and opaque structs from alpha cc
1265 are handled by cross_ref, skip them. */
1269 /* Parse the type or use the pending type. */
1270 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1271 if (pend
== (struct mdebug_pending
*) NULL
)
1273 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1274 add_pending (cur_fdr
, ext_sh
, t
);
1279 /* mips cc puts out a typedef with the name of the struct for forward
1280 declarations. These should not go into the symbol table and
1281 TYPE_NAME should not be set for them.
1282 They can't be distinguished from an intentional typedef to
1283 the same name however:
1285 struct x { int ix; int jx; };
1289 struct xx {int ixx; int jxx; };
1290 generates a cross referencing stTypedef for x and xx.
1291 The user visible effect of this is that the type of a pointer
1292 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1293 The problem is fixed with alpha cc and Irix5 cc. */
1295 /* However if the typedef cross references to an opaque aggregate, it
1296 is safe to omit it from the symbol table. */
1298 if (has_opaque_xref (cur_fdr
, sh
))
1300 s
= new_symbol (name
);
1301 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1302 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1303 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1304 SYMBOL_TYPE (s
) = t
;
1305 add_symbol (s
, top_stack
->cur_block
);
1307 /* Incomplete definitions of structs should not get a name. */
1308 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1309 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1310 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1311 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1313 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1314 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1316 /* If we are giving a name to a type such as "pointer to
1317 foo" or "function returning foo", we better not set
1318 the TYPE_NAME. If the program contains "typedef char
1319 *caddr_t;", we don't want all variables of type char
1320 * to print as caddr_t. This is not just a
1321 consequence of GDB's type management; CC and GCC (at
1322 least through version 2.4) both output variables of
1323 either type char * or caddr_t with the type
1324 refering to the stTypedef symbol for caddr_t. If a future
1325 compiler cleans this up it GDB is not ready for it
1326 yet, but if it becomes ready we somehow need to
1327 disable this check (without breaking the PCC/GCC2.4
1332 Fortunately, this check seems not to be necessary
1333 for anything except pointers or functions. */
1336 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1340 case stFile
: /* file name */
1341 push_parse_stack ();
1342 top_stack
->blocktype
= sh
->st
;
1345 /* I`ve never seen these for C */
1347 break; /* register relocation */
1349 break; /* forwarding address */
1351 break; /* constant */
1353 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1360 /* Parse the type information provided in the raw AX entries for
1361 the symbol SH. Return the bitfield size in BS, in case.
1362 We must byte-swap the AX entries before we use them; BIGEND says whether
1363 they are big-endian or little-endian (from fh->fBigendian). */
1365 static struct type
*
1366 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1369 unsigned int aux_index
;
1374 /* Null entries in this map are treated specially */
1375 static struct type
**map_bt
[] =
1377 &builtin_type_void
, /* btNil */
1379 &builtin_type_char
, /* btChar */
1380 &builtin_type_unsigned_char
,/* btUChar */
1381 &builtin_type_short
, /* btShort */
1382 &builtin_type_unsigned_short
, /* btUShort */
1383 &builtin_type_int
, /* btInt */
1384 &builtin_type_unsigned_int
, /* btUInt */
1385 &builtin_type_long
, /* btLong */
1386 &builtin_type_unsigned_long
,/* btULong */
1387 &builtin_type_float
, /* btFloat */
1388 &builtin_type_double
, /* btDouble */
1395 &builtin_type_complex
, /* btComplex */
1396 &builtin_type_double_complex
,/* btDComplex */
1398 &mdebug_type_fixed_dec
, /* btFixedDec */
1399 &mdebug_type_float_dec
, /* btFloatDec */
1400 &mdebug_type_string
, /* btString */
1403 &builtin_type_void
, /* btVoid */
1404 0, /* DEC C++: Pointer to member */
1405 0, /* DEC C++: Virtual function table */
1406 0, /* DEC C++: Class (Record) */
1407 &builtin_type_long
, /* btLong64 */
1408 &builtin_type_unsigned_long
, /* btULong64 */
1409 &builtin_type_long_long
, /* btLongLong64 */
1410 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1411 &builtin_type_unsigned_long
, /* btAdr64 */
1412 &builtin_type_long
, /* btInt64 */
1413 &builtin_type_unsigned_long
, /* btUInt64 */
1417 struct type
*tp
= 0;
1418 enum type_code type_code
= TYPE_CODE_UNDEF
;
1420 /* Handle undefined types, they have indexNil. */
1421 if (aux_index
== indexNil
)
1422 return builtin_type_int
;
1424 /* Handle corrupt aux indices. */
1425 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1427 complain (&index_complaint
, sym_name
);
1428 return builtin_type_int
;
1432 /* Use aux as a type information record, map its basic type. */
1433 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1434 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1436 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1437 return builtin_type_int
;
1441 tp
= *map_bt
[t
->bt
];
1446 /* Cannot use builtin types -- build our own */
1450 tp
= lookup_pointer_type (builtin_type_void
);
1453 type_code
= TYPE_CODE_STRUCT
;
1456 type_code
= TYPE_CODE_UNION
;
1459 type_code
= TYPE_CODE_ENUM
;
1462 type_code
= TYPE_CODE_RANGE
;
1465 type_code
= TYPE_CODE_SET
;
1468 /* alpha cc uses this for typedefs. The true type will be
1469 obtained by crossreferencing below. */
1470 type_code
= TYPE_CODE_ERROR
;
1473 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1474 return builtin_type_int
;
1478 /* Move on to next aux */
1483 /* Inhibit core dumps with some cfront generated objects that
1485 if (bs
== (int *)NULL
)
1487 complain (&bad_fbitfield_complaint
, sym_name
);
1488 return builtin_type_int
;
1490 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1494 /* All these types really point to some (common) MIPS type
1495 definition, and only the type-qualifiers fully identify
1496 them. We'll make the same effort at sharing. */
1497 if (t
->bt
== btStruct
||
1501 /* btSet (I think) implies that the name is a tag name, not a typedef
1502 name. This apparently is a MIPS extension for C sets. */
1507 /* Try to cross reference this type, build new type on failure. */
1508 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1509 if (tp
== (struct type
*) NULL
)
1510 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1512 /* DEC c89 produces cross references to qualified aggregate types,
1513 dereference them. */
1514 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1515 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1516 tp
= tp
->target_type
;
1518 /* Make sure that TYPE_CODE(tp) has an expected type code.
1519 Any type may be returned from cross_ref if file indirect entries
1521 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1522 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1523 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1525 complain (&unexpected_type_code_complaint
, sym_name
);
1530 /* Usually, TYPE_CODE(tp) is already type_code. The main
1531 exception is if we guessed wrong re struct/union/enum.
1532 But for struct vs. union a wrong guess is harmless, so
1533 don't complain(). */
1534 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1535 && type_code
!= TYPE_CODE_ENUM
)
1536 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1537 && type_code
== TYPE_CODE_ENUM
))
1539 complain (&bad_tag_guess_complaint
, sym_name
);
1542 if (TYPE_CODE (tp
) != type_code
)
1544 TYPE_CODE (tp
) = type_code
;
1547 /* Do not set the tag name if it is a compiler generated tag name
1548 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1549 if (name
[0] == '.' || name
[0] == '\0')
1550 TYPE_TAG_NAME (tp
) = NULL
;
1551 else if (TYPE_TAG_NAME (tp
) == NULL
1552 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1553 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1554 ¤t_objfile
->type_obstack
);
1558 /* All these types really point to some (common) MIPS type
1559 definition, and only the type-qualifiers fully identify
1560 them. We'll make the same effort at sharing.
1561 FIXME: btIndirect cannot happen here as it is handled by the
1562 switch t->bt above. And we are not doing any guessing on range types. */
1563 if (t
->bt
== btIndirect
||
1568 /* Try to cross reference this type, build new type on failure. */
1569 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1570 if (tp
== (struct type
*) NULL
)
1571 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1573 /* Make sure that TYPE_CODE(tp) has an expected type code.
1574 Any type may be returned from cross_ref if file indirect entries
1576 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1578 complain (&unexpected_type_code_complaint
, sym_name
);
1582 /* Usually, TYPE_CODE(tp) is already type_code. The main
1583 exception is if we guessed wrong re struct/union/enum. */
1584 if (TYPE_CODE (tp
) != type_code
)
1586 complain (&bad_tag_guess_complaint
, sym_name
);
1587 TYPE_CODE (tp
) = type_code
;
1589 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1590 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1591 ¤t_objfile
->type_obstack
);
1594 if (t
->bt
== btTypedef
)
1598 /* Try to cross reference this type, it should succeed. */
1599 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1600 if (tp
== (struct type
*) NULL
)
1602 complain (&unable_to_cross_ref_complaint
, sym_name
);
1603 tp
= builtin_type_int
;
1607 /* Deal with range types */
1608 if (t
->bt
== btRange
)
1610 TYPE_NFIELDS (tp
) = 2;
1611 TYPE_FIELDS (tp
) = ((struct field
*)
1612 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1613 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1614 ¤t_objfile
->type_obstack
);
1615 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1617 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1618 ¤t_objfile
->type_obstack
);
1619 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1623 /* Parse all the type qualifiers now. If there are more
1624 than 6 the game will continue in the next aux */
1628 #define PARSE_TQ(tq) \
1629 if (t->tq != tqNil) \
1630 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1642 /* mips cc 2.x and gcc never put out continued aux entries. */
1646 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1650 /* Complain for illegal continuations due to corrupt aux entries. */
1652 complain (&bad_continued_complaint
, sym_name
);
1657 /* Make up a complex type from a basic one. Type is passed by
1658 reference in TPP and side-effected as necessary. The type
1659 qualifier TQ says how to handle the aux symbols at AX for
1660 the symbol SX we are currently analyzing. BIGEND says whether
1661 aux symbols are big-endian or little-endian.
1662 Returns the number of aux symbols we parsed. */
1665 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1676 /* Used in array processing */
1687 t
= lookup_pointer_type (*tpp
);
1692 t
= lookup_function_type (*tpp
);
1699 /* Determine and record the domain type (type of index) */
1700 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1706 rf
= AUX_GET_ISYM (bigend
, ax
);
1709 fh
= get_rfd (fd
, rf
);
1711 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1712 id
, (int *) NULL
, bigend
, sym_name
);
1714 /* The bounds type should be an integer type, but might be anything
1715 else due to corrupt aux entries. */
1716 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1718 complain (&array_index_type_complaint
, sym_name
);
1719 indx
= builtin_type_int
;
1722 /* Get the bounds, and create the array type. */
1724 lower
= AUX_GET_DNLOW (bigend
, ax
);
1726 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1728 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1730 range
= create_range_type ((struct type
*) NULL
, indx
,
1733 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1735 /* We used to fill in the supplied array element bitsize
1736 here if the TYPE_LENGTH of the target type was zero.
1737 This happens for a `pointer to an array of anonymous structs',
1738 but in this case the array element bitsize is also zero,
1739 so nothing is gained.
1740 And we used to check the TYPE_LENGTH of the target type against
1741 the supplied array element bitsize.
1742 gcc causes a mismatch for `pointer to array of object',
1743 since the sdb directives it uses do not have a way of
1744 specifying the bitsize, but it does no harm (the
1745 TYPE_LENGTH should be correct) and we should be able to
1746 ignore the erroneous bitsize from the auxiliary entry safely.
1747 dbx seems to ignore it too. */
1753 /* Volatile -- currently ignored */
1757 /* Const -- currently ignored */
1761 complain (&unknown_type_qual_complaint
, tq
);
1767 /* Parse a procedure descriptor record PR. Note that the procedure is
1768 parsed _after_ the local symbols, now we just insert the extra
1769 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1770 already been placed in the procedure's main block. Note also that
1771 images that have been partially stripped (ld -x) have been deprived
1772 of local symbols, and we have to cope with them here. FIRST_OFF is
1773 the offset of the first procedure for this FDR; we adjust the
1774 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1775 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1776 in question, or NULL to use top_stack->cur_block. */
1778 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long,
1779 struct partial_symtab
*));
1782 parse_procedure (pr
, search_symtab
, first_off
, pst
)
1784 struct symtab
*search_symtab
;
1785 unsigned long first_off
;
1786 struct partial_symtab
*pst
;
1788 struct symbol
*s
, *i
;
1790 struct mips_extra_func_info
*e
;
1793 /* Simple rule to find files linked "-x" */
1794 if (cur_fdr
->rss
== -1)
1798 /* Static procedure at address pr->adr. Sigh. */
1799 /* FIXME-32x64. assuming pr->adr fits in long. */
1800 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1808 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1809 ((char *) debug_info
->external_ext
1811 * debug_swap
->external_ext_size
)),
1813 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1821 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1822 ((char *) debug_info
->external_sym
1823 + ((cur_fdr
->isymBase
+ pr
->isym
)
1824 * debug_swap
->external_sym_size
)),
1826 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1829 if (search_symtab
!= NULL
)
1832 /* This loses both in the case mentioned (want a static, find a global),
1833 but also if we are looking up a non-mangled name which happens to
1834 match the name of a mangled function. */
1835 /* We have to save the cur_fdr across the call to lookup_symbol.
1836 If the pdr is for a static function and if a global function with
1837 the same name exists, lookup_symbol will eventually read in the symtab
1838 for the global function and clobber cur_fdr. */
1839 FDR
*save_cur_fdr
= cur_fdr
;
1840 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1841 cur_fdr
= save_cur_fdr
;
1845 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1851 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1852 VAR_NAMESPACE
, LOC_BLOCK
);
1856 b
= SYMBOL_BLOCK_VALUE (s
);
1860 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1864 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1865 s
= new_symbol (sh_name
);
1866 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1867 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1868 /* Donno its type, hope int is ok */
1869 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1870 add_symbol (s
, top_stack
->cur_block
);
1871 /* Wont have symbols for this one */
1873 SYMBOL_BLOCK_VALUE (s
) = b
;
1874 BLOCK_FUNCTION (b
) = s
;
1875 BLOCK_START (b
) = pr
->adr
;
1876 /* BOUND used to be the end of procedure's text, but the
1877 argument is no longer passed in. */
1878 BLOCK_END (b
) = bound
;
1879 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1880 add_block (b
, top_stack
->cur_st
);
1884 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1888 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1890 e
->pdr
.isym
= (long) s
;
1891 e
->pdr
.adr
+= pst
->textlow
- first_off
;
1893 /* Correct incorrect setjmp procedure descriptor from the library
1894 to make backtrace through setjmp work. */
1895 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1897 complain (&bad_setjmp_pdr_complaint
, 0);
1898 e
->pdr
.pcreg
= RA_REGNUM
;
1899 e
->pdr
.regmask
= 0x80000000;
1900 e
->pdr
.regoffset
= -4;
1904 /* It would be reasonable that functions that have been compiled
1905 without debugging info have a btNil type for their return value,
1906 and functions that are void and are compiled with debugging info
1908 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1909 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1911 The glevel field in cur_fdr could be used to determine the presence
1912 of debugging info, but GCC doesn't always pass the -g switch settings
1913 to the assembler and GAS doesn't set the glevel field from the -g switch
1915 To work around these problems, the return value type of a TYPE_CODE_VOID
1916 function is adjusted accordingly if no debugging info was found in the
1917 compilation unit. */
1919 if (processing_gcc_compilation
== 0
1920 && found_ecoff_debugging_info
== 0
1921 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
1922 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
1925 /* Relocate the extra function info pointed to by the symbol table. */
1928 ecoff_relocate_efi (sym
, delta
)
1932 struct mips_extra_func_info
*e
;
1934 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
1936 e
->pdr
.adr
+= delta
;
1939 /* Parse the external symbol ES. Just call parse_symbol() after
1940 making sure we know where the aux are for it.
1941 BIGEND says whether aux entries are big-endian or little-endian.
1943 This routine clobbers top_stack->cur_block and ->cur_st. */
1945 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
1948 parse_external (es
, bigend
, section_offsets
)
1951 struct section_offsets
*section_offsets
;
1955 if (es
->ifd
!= ifdNil
)
1958 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1959 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1963 cur_fdr
= debug_info
->fdr
;
1967 /* Reading .o files */
1968 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1971 switch (es
->asym
.st
)
1974 /* These are generated for static symbols in .o files,
1995 /* FIXME: Turn this into a complaint? */
1997 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1998 what
, debug_info
->ssext
+ es
->asym
.iss
,
1999 fdr_name (cur_fdr
));
2003 switch (es
->asym
.st
)
2007 /* There is no need to parse the external procedure symbols.
2008 If they are from objects compiled without -g, their index will
2009 be indexNil, and the symbol definition from the minimal symbol
2010 is preferrable (yielding a function returning int instead of int).
2011 If the index points to a local procedure symbol, the local
2012 symbol already provides the correct type.
2013 Note that the index of the external procedure symbol points
2014 to the local procedure symbol in the local symbol table, and
2015 _not_ to the auxiliary symbol info. */
2019 /* Global common symbols are resolved by the runtime loader,
2021 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
2024 /* Note that the case of a symbol with indexNil must be handled
2025 anyways by parse_symbol(). */
2026 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
2033 /* Parse the line number info for file descriptor FH into
2034 GDB's linetable LT. MIPS' encoding requires a little bit
2035 of magic to get things out. Note also that MIPS' line
2036 numbers can go back and forth, apparently we can live
2037 with that and do not need to reorder our linetables */
2039 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
2040 struct partial_symtab
*));
2043 parse_lines (fh
, pr
, lt
, maxlines
, pst
)
2046 struct linetable
*lt
;
2048 struct partial_symtab
*pst
;
2050 unsigned char *base
;
2052 int delta
, count
, lineno
= 0;
2053 unsigned long first_off
= pr
->adr
;
2055 if (fh
->cbLine
== 0)
2058 /* Scan by procedure descriptors */
2060 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2064 unsigned char *halt
;
2066 /* No code for this one */
2067 if (pr
->iline
== ilineNil
||
2068 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2071 /* Determine start and end address of compressed line bytes for
2073 base
= debug_info
->line
+ fh
->cbLineOffset
;
2074 if (j
!= (fh
->cpd
- 1))
2075 halt
= base
+ pr
[1].cbLineOffset
;
2077 halt
= base
+ fh
->cbLine
;
2078 base
+= pr
->cbLineOffset
;
2080 adr
= pst
->textlow
+ pr
->adr
- first_off
;
2082 l
= adr
>> 2; /* in words */
2083 for (lineno
= pr
->lnLow
; base
< halt
; )
2085 count
= *base
& 0x0f;
2086 delta
= *base
++ >> 4;
2091 delta
= (base
[0] << 8) | base
[1];
2092 if (delta
>= 0x8000)
2096 lineno
+= delta
; /* first delta is 0 */
2098 /* Complain if the line table overflows. Could happen
2099 with corrupt binaries. */
2100 if (lt
->nitems
>= maxlines
)
2102 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2105 k
= add_line (lt
, lineno
, l
, k
);
2111 /* Master parsing procedure for first-pass reading of file symbols
2112 into a partial_symtab. */
2115 parse_partial_symbols (objfile
, section_offsets
)
2116 struct objfile
*objfile
;
2117 struct section_offsets
*section_offsets
;
2119 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2120 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2121 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2122 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2123 = debug_swap
->swap_ext_in
;
2124 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2125 = debug_swap
->swap_sym_in
;
2126 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2127 = debug_swap
->swap_rfd_in
;
2129 HDRR
*hdr
= &debug_info
->symbolic_header
;
2130 /* Running pointers */
2135 register EXTR
*ext_in
;
2138 struct partial_symtab
*pst
;
2140 int past_first_source_file
= 0;
2142 /* List of current psymtab's include files */
2143 char **psymtab_include_list
;
2144 int includes_allocated
;
2147 struct pst_map
*fdr_to_pst
;
2148 /* Index within current psymtab dependency list */
2149 struct partial_symtab
**dependency_list
;
2150 int dependencies_used
, dependencies_allocated
;
2151 struct cleanup
*old_chain
;
2153 enum language prev_language
;
2154 asection
*text_sect
;
2155 int relocatable
= 0;
2157 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2158 the shared libraries are prelinked at a high memory address.
2159 We have to adjust the start address of the object file for this case,
2160 by setting it to the start address of the first procedure in the file.
2161 But we should do no adjustments if we are debugging a .o file, where
2162 the text section (and fh->adr) really starts at zero. */
2163 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2164 if (text_sect
!= NULL
2165 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2168 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2169 sizeof (EXTR
) * hdr
->iextMax
);
2171 includes_allocated
= 30;
2173 psymtab_include_list
= (char **) alloca (includes_allocated
*
2175 next_symbol_text_func
= mdebug_next_symbol_text
;
2177 dependencies_allocated
= 30;
2178 dependencies_used
= 0;
2180 (struct partial_symtab
**) alloca (dependencies_allocated
*
2181 sizeof (struct partial_symtab
*));
2183 last_source_file
= NULL
;
2188 * Only parse the Local and External symbols, and the Relative FDR.
2189 * Fixup enough of the loader symtab to be able to use it.
2190 * Allocate space only for the file's portions we need to
2195 max_glevel
= MIN_GLEVEL
;
2197 /* Allocate the map FDR -> PST.
2198 Minor hack: -O3 images might claim some global data belongs
2199 to FDR -1. We`ll go along with that */
2200 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2201 old_chain
= make_cleanup (free
, fdr_to_pst
);
2204 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2205 fdr_to_pst
[-1].pst
= pst
;
2209 /* Allocate the global pending list. */
2211 ((struct mdebug_pending
**)
2212 obstack_alloc (&objfile
->psymbol_obstack
,
2213 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2214 memset ((PTR
) pending_list
, 0,
2215 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2217 /* Pass 0 over external syms: swap them in. */
2218 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2219 make_cleanup (free
, ext_block
);
2221 ext_out
= (char *) debug_info
->external_ext
;
2222 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2224 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2225 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2227 /* Pass 1 over external syms: Presize and partition the list */
2229 ext_in_end
= ext_in
+ hdr
->iextMax
;
2230 for (; ext_in
< ext_in_end
; ext_in
++)
2232 /* See calls to complain below. */
2233 if (ext_in
->ifd
>= -1
2234 && ext_in
->ifd
< hdr
->ifdMax
2235 && ext_in
->asym
.iss
>= 0
2236 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2237 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2240 /* Pass 1.5 over files: partition out global symbol space */
2242 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2244 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2245 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2246 fdr_to_pst
[f_idx
].n_globals
= 0;
2249 /* Pass 2 over external syms: fill in external symbols */
2251 ext_in_end
= ext_in
+ hdr
->iextMax
;
2252 for (; ext_in
< ext_in_end
; ext_in
++)
2254 enum minimal_symbol_type ms_type
= mst_text
;
2255 CORE_ADDR svalue
= ext_in
->asym
.value
;
2257 /* The Irix 5 native tools seem to sometimes generate bogus
2258 external symbols. */
2259 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2261 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2264 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2266 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2271 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2272 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2274 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2277 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2278 switch (ext_in
->asym
.st
)
2281 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2284 ms_type
= mst_file_text
;
2285 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2288 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2290 /* The value of a common symbol is its size, not its address.
2294 else if (ext_in
->asym
.sc
== scData
2295 || ext_in
->asym
.sc
== scSData
2296 || ext_in
->asym
.sc
== scRData
2297 || ext_in
->asym
.sc
== scPData
2298 || ext_in
->asym
.sc
== scXData
)
2301 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2306 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2310 if (ext_in
->asym
.sc
== scAbs
)
2312 else if (ext_in
->asym
.sc
== scText
2313 || ext_in
->asym
.sc
== scInit
2314 || ext_in
->asym
.sc
== scFini
)
2316 ms_type
= mst_file_text
;
2317 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2319 else if (ext_in
->asym
.sc
== scData
2320 || ext_in
->asym
.sc
== scSData
2321 || ext_in
->asym
.sc
== scRData
2322 || ext_in
->asym
.sc
== scPData
2323 || ext_in
->asym
.sc
== scXData
)
2325 ms_type
= mst_file_data
;
2326 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2330 ms_type
= mst_file_bss
;
2331 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2335 /* The alpha has the section start addresses in stLocal symbols
2336 whose name starts with a `.'. Skip those but complain for all
2337 other stLocal symbols. */
2342 ms_type
= mst_unknown
;
2343 complain (&unknown_ext_complaint
, name
);
2345 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2348 /* Pass 3 over files, over local syms: fill in static symbols */
2349 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2351 struct partial_symtab
*save_pst
;
2355 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2359 fdr_to_pst
[f_idx
].pst
= NULL
;
2363 /* Determine the start address for this object file from the
2364 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2368 if (relocatable
|| textlow
!= 0)
2369 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2373 pst
= start_psymtab_common (objfile
, section_offsets
,
2376 objfile
->global_psymbols
.next
,
2377 objfile
->static_psymbols
.next
);
2378 pst
->read_symtab_private
= ((char *)
2379 obstack_alloc (&objfile
->psymbol_obstack
,
2380 sizeof (struct symloc
)));
2381 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2384 FDR_IDX (pst
) = f_idx
;
2385 CUR_BFD (pst
) = cur_bfd
;
2386 DEBUG_SWAP (pst
) = debug_swap
;
2387 DEBUG_INFO (pst
) = debug_info
;
2388 PENDING_LIST (pst
) = pending_list
;
2390 /* The way to turn this into a symtab is to call... */
2391 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2393 /* Set up language for the pst.
2394 The language from the FDR is used if it is unambigious (e.g. cfront
2395 with native cc and g++ will set the language to C).
2396 Otherwise we have to deduce the language from the filename.
2397 Native ecoff has every header file in a separate FDR, so
2398 deduce_language_from_filename will return language_unknown for
2399 a header file, which is not what we want.
2400 But the FDRs for the header files are after the FDR for the source
2401 file, so we can assign the language of the source file to the
2402 following header files. Then we save the language in the private
2403 pst data so that we can reuse it when building symtabs. */
2404 prev_language
= psymtab_language
;
2408 case langCplusplusV2
:
2409 psymtab_language
= language_cplus
;
2412 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2415 if (psymtab_language
== language_unknown
)
2416 psymtab_language
= prev_language
;
2417 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2419 pst
->texthigh
= pst
->textlow
;
2421 /* For stabs-in-ecoff files, the second symbol must be @stab.
2422 This symbol is emitted by mips-tfile to signal that the
2423 current object file uses encapsulated stabs instead of mips
2424 ecoff for local symbols. (It is the second symbol because
2425 the first symbol is the stFile used to signal the start of a
2427 processing_gcc_compilation
= 0;
2430 (*swap_sym_in
) (cur_bfd
,
2431 ((char *) debug_info
->external_sym
2432 + (fh
->isymBase
+ 1) * external_sym_size
),
2434 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2435 processing_gcc_compilation
= 2;
2438 if (processing_gcc_compilation
!= 0)
2440 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2445 (*swap_sym_in
) (cur_bfd
,
2446 (((char *) debug_info
->external_sym
)
2447 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2449 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2450 if (!ECOFF_IS_STAB (&sh
))
2452 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2457 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2458 if (sh
.st
== stStaticProc
)
2460 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2461 prim_record_minimal_symbol_and_info (namestring
,
2468 procaddr
= sh
.value
;
2470 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2471 (debug_info
->external_aux
2474 (*swap_sym_in
) (cur_bfd
,
2475 ((char *) debug_info
->external_sym
2476 + ((fh
->isymBase
+ isym
- 1)
2477 * external_sym_size
)),
2481 long high
= procaddr
+ sh
.value
;
2483 /* Kludge for Irix 5.2 zero fh->adr. */
2485 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2486 pst
->textlow
= procaddr
;
2487 if (high
> pst
->texthigh
)
2488 pst
->texthigh
= high
;
2491 else if (sh
.st
== stStatic
)
2505 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2506 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2507 prim_record_minimal_symbol_and_info (namestring
,
2516 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2517 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2518 prim_record_minimal_symbol_and_info (namestring
,
2529 #define SET_NAMESTRING() \
2530 namestring = debug_info->ss + fh->issBase + sh.iss
2531 #define CUR_SYMBOL_TYPE type_code
2532 #define CUR_SYMBOL_VALUE sh.value
2533 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2535 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2536 #define HANDLE_RBRAC(val) \
2537 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2538 #include "partial-stab.h"
2543 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2546 enum address_class
class;
2548 (*swap_sym_in
) (cur_bfd
,
2549 ((char *) debug_info
->external_sym
2550 + ((fh
->isymBase
+ cur_sdx
)
2551 * external_sym_size
)),
2554 if (ECOFF_IS_STAB (&sh
))
2560 /* Non absolute static symbols go into the minimal table. */
2561 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2562 || (sh
.index
== indexNil
2563 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2565 /* FIXME, premature? */
2570 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2575 /* The value of a stEnd symbol is the displacement from the
2576 corresponding start symbol value, do not relocate it. */
2578 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2585 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2589 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2600 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2601 mst_file_text
, NULL
,
2602 SECT_OFF_TEXT
, objfile
);
2607 /* Usually there is a local and a global stProc symbol
2608 for a function. This means that the function name
2609 has already been entered into the mimimal symbol table
2610 while processing the global symbols in pass 2 above.
2611 One notable exception is the PROGRAM name from
2612 f77 compiled executables, it is only put out as
2613 local stProc symbol, and a global MAIN__ stProc symbol
2614 points to it. It doesn't matter though, as gdb is
2615 still able to find the PROGRAM name via the partial
2616 symbol table, and the MAIN__ symbol via the minimal
2618 if (sh
.st
== stProc
)
2619 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2620 VAR_NAMESPACE
, LOC_BLOCK
,
2621 objfile
->global_psymbols
,
2622 sh
.value
, psymtab_language
, objfile
);
2624 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2625 VAR_NAMESPACE
, LOC_BLOCK
,
2626 objfile
->static_psymbols
,
2627 sh
.value
, psymtab_language
, objfile
);
2629 /* Skip over procedure to next one. */
2630 if (sh
.index
>= hdr
->iauxMax
)
2632 /* Should not happen, but does when cross-compiling
2633 with the MIPS compiler. FIXME -- pull later. */
2634 complain (&index_complaint
, name
);
2635 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2638 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2639 (debug_info
->external_aux
2642 procaddr
= sh
.value
;
2644 if (new_sdx
<= cur_sdx
)
2646 /* This should not happen either... FIXME. */
2647 complain (&aux_index_complaint
, name
);
2648 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2652 (*swap_sym_in
) (cur_bfd
,
2653 ((char *) debug_info
->external_sym
2654 + ((fh
->isymBase
+ cur_sdx
- 1)
2655 * external_sym_size
)),
2660 /* Kludge for Irix 5.2 zero fh->adr. */
2662 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2663 pst
->textlow
= procaddr
;
2665 high
= procaddr
+ sh
.value
;
2666 if (high
> pst
->texthigh
)
2667 pst
->texthigh
= high
;
2670 case stStatic
: /* Variable */
2675 || sh
.sc
== scXData
)
2676 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2677 mst_file_data
, NULL
,
2681 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2688 case stIndirect
:/* Irix5 forward declaration */
2689 /* Skip forward declarations from Irix5 cc */
2692 case stTypedef
:/* Typedef */
2693 /* Skip typedefs for forward declarations and opaque
2694 structs from alpha and mips cc. */
2695 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2697 class = LOC_TYPEDEF
;
2700 case stConstant
: /* Constant decl */
2707 case stBlock
: /* { }, str, un, enum*/
2708 /* Do not create a partial symbol for cc unnamed aggregates
2709 and gcc empty aggregates. */
2710 if ((sh
.sc
== scInfo
2711 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2713 && sh
.index
!= cur_sdx
+ 2)
2715 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2716 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2717 objfile
->static_psymbols
,
2719 psymtab_language
, objfile
);
2721 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2723 /* Skip over the block */
2725 if (new_sdx
<= cur_sdx
)
2727 /* This happens with the Ultrix kernel. */
2728 complain (&block_index_complaint
, name
);
2729 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2734 case stFile
: /* File headers */
2735 case stLabel
: /* Labels */
2736 case stEnd
: /* Ends of files */
2739 case stLocal
: /* Local variables */
2740 /* Normally these are skipped because we skip over
2741 all blocks we see. However, these can occur
2742 as visible symbols in a .h file that contains code. */
2746 /* Both complaints are valid: one gives symbol name,
2747 the other the offending symbol type. */
2748 complain (&unknown_sym_complaint
, name
);
2749 complain (&unknown_st_complaint
, sh
.st
);
2753 /* Use this gdb symbol */
2754 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2755 VAR_NAMESPACE
, class,
2756 objfile
->static_psymbols
, sh
.value
,
2757 psymtab_language
, objfile
);
2759 cur_sdx
++; /* Go to next file symbol */
2762 /* Now do enter the external symbols. */
2763 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2764 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2765 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2766 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2767 for (; --cur_sdx
>= 0; ext_ptr
++)
2769 enum address_class
class;
2774 if (ext_ptr
->ifd
!= f_idx
)
2776 psh
= &ext_ptr
->asym
;
2778 /* Do not add undefined symbols to the partial symbol table. */
2779 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2782 svalue
= psh
->value
;
2786 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2793 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2797 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2804 /* These are generated for static symbols in .o files,
2809 /* External procedure symbols have been entered
2810 into the minimal symbol table in pass 2 above.
2811 Ignore them, as parse_external will ignore them too. */
2817 complain (&unknown_ext_complaint
,
2818 debug_info
->ssext
+ psh
->iss
);
2819 /* Fall through, pretend it's global. */
2821 /* Global common symbols are resolved by the runtime loader,
2823 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2829 name
= debug_info
->ssext
+ psh
->iss
;
2830 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2831 VAR_NAMESPACE
, class,
2832 objfile
->global_psymbols
,
2834 psymtab_language
, objfile
);
2838 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2839 empty and put on the free list. */
2840 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2841 psymtab_include_list
, includes_used
,
2842 -1, save_pst
->texthigh
,
2843 dependency_list
, dependencies_used
);
2844 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2845 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2847 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2848 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2851 /* The objfile has its functions reordered if this partial symbol
2852 table overlaps any other partial symbol table.
2853 We cannot assume a reordered objfile if a partial symbol table
2854 is contained within another partial symbol table, as partial symbol
2855 tables for include files with executable code are contained
2856 within the partial symbol table for the including source file,
2857 and we do not want to flag the objfile reordered for these cases.
2859 This strategy works well for Irix-5.2 shared libraries, but we
2860 might have to use a more elaborate (and slower) algorithm for
2862 save_pst
= fdr_to_pst
[f_idx
].pst
;
2863 if (save_pst
!= NULL
2864 && save_pst
->textlow
!= 0
2865 && !(objfile
->flags
& OBJF_REORDERED
))
2867 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
2870 && save_pst
->textlow
>= pst
->textlow
2871 && save_pst
->textlow
< pst
->texthigh
2872 && save_pst
->texthigh
> pst
->texthigh
)
2874 objfile
->flags
|= OBJF_REORDERED
;
2881 /* Now scan the FDRs for dependencies */
2882 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2884 fh
= f_idx
+ debug_info
->fdr
;
2885 pst
= fdr_to_pst
[f_idx
].pst
;
2887 if (pst
== (struct partial_symtab
*)NULL
)
2890 /* This should catch stabs-in-ecoff. */
2894 /* Skip the first file indirect entry as it is a self dependency
2895 for source files or a reverse .h -> .c dependency for header files. */
2896 pst
->number_of_dependencies
= 0;
2898 ((struct partial_symtab
**)
2899 obstack_alloc (&objfile
->psymbol_obstack
,
2901 * sizeof (struct partial_symtab
*))));
2902 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2906 (*swap_rfd_in
) (cur_bfd
,
2907 ((char *) debug_info
->external_rfd
2908 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2910 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2912 complain (&bad_file_number_complaint
, rh
);
2916 /* Skip self dependencies of header files. */
2920 /* Do not add to dependeny list if psymtab was empty. */
2921 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2923 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2927 /* Remove the dummy psymtab created for -O3 images above, if it is
2928 still empty, to enable the detection of stripped executables. */
2929 if (objfile
->psymtabs
->next
== NULL
2930 && objfile
->psymtabs
->number_of_dependencies
== 0
2931 && objfile
->psymtabs
->n_global_syms
== 0
2932 && objfile
->psymtabs
->n_static_syms
== 0)
2933 objfile
->psymtabs
= NULL
;
2934 do_cleanups (old_chain
);
2937 /* If the current psymbol has an enumerated type, we need to add
2938 all the the enum constants to the partial symbol table. */
2941 handle_psymbol_enumerators (objfile
, fh
, stype
)
2942 struct objfile
*objfile
;
2946 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2947 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2948 = debug_swap
->swap_sym_in
;
2949 char *ext_sym
= ((char *) debug_info
->external_sym
2950 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2960 /* It is an enumerated type if the next symbol entry is a stMember
2961 and its auxiliary index is indexNil or its auxiliary entry
2962 is a plain btNil or btVoid. */
2963 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2964 if (sh
.st
!= stMember
)
2967 if (sh
.index
== indexNil
)
2969 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
2970 &(debug_info
->external_aux
2971 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2973 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2985 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2986 if (sh
.st
!= stMember
)
2988 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2990 /* Note that the value doesn't matter for enum constants
2991 in psymtabs, just in symtabs. */
2992 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2993 VAR_NAMESPACE
, LOC_CONST
,
2994 objfile
->static_psymbols
, 0,
2995 psymtab_language
, objfile
);
2996 ext_sym
+= external_sym_size
;
3001 mdebug_next_symbol_text ()
3006 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3007 ((char *) debug_info
->external_sym
3008 + ((cur_fdr
->isymBase
+ cur_sdx
)
3009 * debug_swap
->external_sym_size
)),
3011 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3014 /* Ancillary function to psymtab_to_symtab(). Does all the work
3015 for turning the partial symtab PST into a symtab, recurring
3016 first on all dependent psymtabs. The argument FILENAME is
3017 only passed so we can see in debug stack traces what file
3020 This function has a split personality, based on whether the
3021 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3022 The flow of control and even the memory allocation differs. FIXME. */
3025 psymtab_to_symtab_1 (pst
, filename
)
3026 struct partial_symtab
*pst
;
3029 bfd_size_type external_sym_size
;
3030 bfd_size_type external_pdr_size
;
3031 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
3032 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
3036 struct linetable
*lines
;
3042 /* Read in all partial symbtabs on which this one is dependent.
3043 NOTE that we do have circular dependencies, sigh. We solved
3044 that by setting pst->readin before this point. */
3046 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3047 if (!pst
->dependencies
[i
]->readin
)
3049 /* Inform about additional files to be read in. */
3052 fputs_filtered (" ", gdb_stdout
);
3054 fputs_filtered ("and ", gdb_stdout
);
3056 printf_filtered ("%s...",
3057 pst
->dependencies
[i
]->filename
);
3058 wrap_here (""); /* Flush output */
3059 gdb_flush (gdb_stdout
);
3061 /* We only pass the filename for debug purposes */
3062 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3063 pst
->dependencies
[i
]->filename
);
3066 /* Do nothing if this is a dummy psymtab. */
3068 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3069 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3072 /* Now read the symbols for this symtab */
3074 cur_bfd
= CUR_BFD (pst
);
3075 debug_swap
= DEBUG_SWAP (pst
);
3076 debug_info
= DEBUG_INFO (pst
);
3077 pending_list
= PENDING_LIST (pst
);
3078 external_sym_size
= debug_swap
->external_sym_size
;
3079 external_pdr_size
= debug_swap
->external_pdr_size
;
3080 swap_sym_in
= debug_swap
->swap_sym_in
;
3081 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3082 current_objfile
= pst
->objfile
;
3083 cur_fd
= FDR_IDX (pst
);
3084 fh
= ((cur_fd
== -1)
3086 : debug_info
->fdr
+ cur_fd
);
3089 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3090 processing_gcc_compilation
= 0;
3091 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3095 (*swap_sym_in
) (cur_bfd
,
3096 ((char *) debug_info
->external_sym
3097 + (fh
->isymBase
+ 1) * external_sym_size
),
3099 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3102 /* We indicate that this is a GCC compilation so that certain
3103 features will be enabled in stabsread/dbxread. */
3104 processing_gcc_compilation
= 2;
3108 if (processing_gcc_compilation
!= 0)
3113 unsigned long first_off
= 0;
3115 /* This symbol table contains stabs-in-ecoff entries. */
3117 /* Parse local symbols first */
3119 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3121 current_objfile
= NULL
;
3124 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3130 (*swap_sym_in
) (cur_bfd
,
3131 (((char *) debug_info
->external_sym
)
3132 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3134 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3136 if (ECOFF_IS_STAB (&sh
))
3138 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3140 /* We should never get non N_STAB symbols here, but they
3141 should be harmless, so keep process_one_symbol from
3142 complaining about them. */
3143 if (type_code
& N_STAB
)
3145 process_one_symbol (type_code
, 0, valu
, name
,
3146 pst
->section_offsets
, pst
->objfile
);
3148 if (type_code
== N_FUN
)
3150 /* Make up special symbol to contain
3151 procedure specific info */
3152 struct mips_extra_func_info
*e
=
3153 ((struct mips_extra_func_info
*)
3154 obstack_alloc (¤t_objfile
->symbol_obstack
,
3155 sizeof (struct mips_extra_func_info
)));
3156 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3158 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
3159 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3160 SYMBOL_CLASS (s
) = LOC_CONST
;
3161 SYMBOL_TYPE (s
) = builtin_type_void
;
3162 SYMBOL_VALUE (s
) = (long) e
;
3163 e
->pdr
.framereg
= -1;
3164 add_symbol_to_list (s
, &local_symbols
);
3167 else if (sh
.st
== stLabel
)
3169 if (sh
.index
== indexNil
)
3171 /* This is what the gcc2_compiled and __gnu_compiled_*
3172 show up as. So don't complain. */
3176 /* Handle encoded stab line number. */
3177 record_line (current_subfile
, sh
.index
, valu
);
3179 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3180 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3181 /* These are generated by gcc-2.x, do not complain */
3184 complain (&stab_unknown_complaint
, name
);
3186 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
3189 /* Sort the symbol table now, we are done adding symbols to it.
3190 We must do this before parse_procedure calls lookup_symbol. */
3191 sort_symtab_syms (st
);
3193 /* There used to be a call to sort_blocks here, but this should not
3194 be necessary for stabs symtabs. And as sort_blocks modifies the
3195 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3196 it did the wrong thing if the first procedure in a file was
3197 generated via asm statements. */
3199 /* Fill in procedure info next. */
3201 pdr_ptr
= ((char *) debug_info
->external_pdr
3202 + fh
->ipdFirst
* external_pdr_size
);
3203 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3204 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
3208 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
3214 parse_procedure (&pr
, st
, first_off
, pst
);
3219 /* This symbol table contains ordinary ecoff entries. */
3221 /* FIXME: doesn't use pst->section_offsets. */
3227 /* How many symbols will we need */
3228 /* FIXME, this does not count enum values. */
3229 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
3233 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
3237 f_max
+= fh
->csym
+ fh
->cpd
;
3238 maxlines
= 2 * fh
->cline
;
3239 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
3241 /* The proper language was already determined when building
3242 the psymtab, use it. */
3243 st
->language
= PST_PRIVATE (pst
)->pst_language
;
3246 psymtab_language
= st
->language
;
3248 lines
= LINETABLE (st
);
3250 /* Get a new lexical context */
3252 push_parse_stack ();
3253 top_stack
->cur_st
= st
;
3254 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
3256 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
3257 BLOCK_END (top_stack
->cur_block
) = 0;
3258 top_stack
->blocktype
= stFile
;
3259 top_stack
->maxsyms
= 2 * f_max
;
3260 top_stack
->cur_type
= 0;
3261 top_stack
->procadr
= 0;
3262 top_stack
->numargs
= 0;
3263 found_ecoff_debugging_info
= 0;
3270 /* Parse local symbols first */
3271 sym_ptr
= ((char *) debug_info
->external_sym
3272 + fh
->isymBase
* external_sym_size
);
3273 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
3274 while (sym_ptr
< sym_end
)
3279 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
3280 c
= parse_symbol (&sh
,
3281 debug_info
->external_aux
+ fh
->iauxBase
,
3282 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3283 sym_ptr
+= c
* external_sym_size
;
3286 /* Linenumbers. At the end, check if we can save memory.
3287 parse_lines has to look ahead an arbitrary number of PDR
3288 structures, so we swap them all first. */
3292 struct cleanup
*old_chain
;
3298 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3300 old_chain
= make_cleanup (free
, pr_block
);
3302 pdr_ptr
= ((char *) debug_info
->external_pdr
3303 + fh
->ipdFirst
* external_pdr_size
);
3304 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3308 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3309 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3311 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
);
3312 if (lines
->nitems
< fh
->cline
)
3313 lines
= shrink_linetable (lines
);
3315 /* Fill in procedure info next. */
3317 pdr_in_end
= pdr_in
+ fh
->cpd
;
3318 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3319 parse_procedure (pdr_in
, 0, pr_block
->adr
, pst
);
3321 do_cleanups (old_chain
);
3325 LINETABLE (st
) = lines
;
3327 /* .. and our share of externals.
3328 XXX use the global list to speed up things here. how?
3329 FIXME, Maybe quit once we have found the right number of ext's? */
3330 top_stack
->cur_st
= st
;
3331 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3333 top_stack
->blocktype
= stFile
;
3335 = (debug_info
->symbolic_header
.isymMax
3336 + debug_info
->symbolic_header
.ipdMax
3337 + debug_info
->symbolic_header
.iextMax
);
3339 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3340 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3341 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3343 /* If there are undefined symbols, tell the user.
3344 The alpha has an undefined symbol for every symbol that is
3345 from a shared library, so tell the user only if verbose is on. */
3346 if (info_verbose
&& n_undef_symbols
)
3348 printf_filtered ("File %s contains %d unresolved references:",
3349 st
->filename
, n_undef_symbols
);
3350 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3351 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3352 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3359 /* Sort the symbol table now, we are done adding symbols to it.*/
3360 sort_symtab_syms (st
);
3365 /* Now link the psymtab and the symtab. */
3368 current_objfile
= NULL
;
3371 /* Ancillary parsing procedures. */
3373 /* Return 1 if the symbol pointed to by SH has a cross reference
3374 to an opaque aggregate type, else 0. */
3377 has_opaque_xref (fh
, sh
)
3386 if (sh
->index
== indexNil
)
3389 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
3390 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
3391 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
3395 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
3396 if (rn
->rfd
== 0xfff)
3397 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
3405 /* Lookup the type at relative index RN. Return it in TPP
3406 if found and in any event come up with its name PNAME.
3407 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3408 Return value says how many aux symbols we ate. */
3411 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3415 enum type_code type_code
; /* Use to alloc new type if none is found. */
3427 struct mdebug_pending
*pend
;
3429 *tpp
= (struct type
*)NULL
;
3431 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
3433 /* Escape index means 'the next one' */
3434 if (rn
->rfd
== 0xfff)
3437 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3444 /* mips cc uses a rf of -1 for opaque struct definitions.
3445 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3446 resolve them if the struct gets defined in another compilation unit. */
3449 *pname
= "<undefined>";
3450 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3451 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3455 /* mips cc uses an escaped rn->index of 0 for struct return types
3456 of procedures that were compiled without -g. These will always remain
3458 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3460 *pname
= "<undefined>";
3464 /* Find the relative file descriptor and the symbol in it. */
3465 fh
= get_rfd (fd
, rf
);
3466 xref_fd
= fh
- debug_info
->fdr
;
3468 if (rn
->index
>= fh
->csym
)
3470 /* File indirect entry is corrupt. */
3471 *pname
= "<illegal>";
3472 complain (&bad_rfd_entry_complaint
,
3473 sym_name
, xref_fd
, rn
->index
);
3477 /* If we have processed this symbol then we left a forwarding
3478 pointer to the type in the pending list. If not, we`ll put
3479 it in a list of pending types, to be processed later when
3480 the file will be. In any event, we collect the name for the
3483 esh
= ((char *) debug_info
->external_sym
3484 + ((fh
->isymBase
+ rn
->index
)
3485 * debug_swap
->external_sym_size
));
3486 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3488 /* Make sure that this type of cross reference can be handled. */
3489 if ((sh
.sc
!= scInfo
3490 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
3491 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3492 && sh
.st
!= stEnum
))
3493 && (sh
.st
!= stBlock
|| (sh
.sc
!= scCommon
&& sh
.sc
!= scSCommon
)))
3495 /* File indirect entry is corrupt. */
3496 *pname
= "<illegal>";
3497 complain (&bad_rfd_entry_complaint
,
3498 sym_name
, xref_fd
, rn
->index
);
3502 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3504 pend
= is_pending_symbol (fh
, esh
);
3509 /* We have not yet seen this type. */
3511 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
3515 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3517 a) forward declarations of structs/unions/enums which are not
3518 defined in this compilation unit.
3519 For these the type will be void. This is a bad design decision
3520 as cross referencing across compilation units is impossible
3521 due to the missing name.
3522 b) forward declarations of structs/unions/enums which are defined
3523 later in this file or in another file in the same compilation
3524 unit. Irix5 cc uses a stIndirect symbol for this.
3525 Simply cross reference those again to get the true type.
3526 The forward references are not entered in the pending list and
3527 in the symbol table. */
3529 (*debug_swap
->swap_tir_in
) (bigend
,
3530 &(debug_info
->external_aux
3531 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3533 if (tir
.tq0
!= tqNil
)
3534 complain (&illegal_forward_tq0_complaint
, sym_name
);
3538 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3540 *pname
= "<undefined>";
3547 (debug_info
->external_aux
3548 + fh
->iauxBase
+ sh
.index
+ 1),
3549 tpp
, type_code
, pname
,
3550 fh
->fBigendian
, sym_name
);
3554 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3555 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3561 else if (sh
.st
== stTypedef
)
3563 /* Parse the type for a normal typedef. This might recursively call
3564 cross_ref till we get a non typedef'ed type.
3565 FIXME: This is not correct behaviour, but gdb currently
3566 cannot handle typedefs without type copying. But type copying is
3567 impossible as we might have mutual forward references between
3568 two files and the copied type would not get filled in when
3569 we later parse its definition. */
3570 *tpp
= parse_type (xref_fd
,
3571 debug_info
->external_aux
+ fh
->iauxBase
,
3575 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3579 /* Cross reference to a struct/union/enum which is defined
3580 in another file in the same compilation unit but that file
3581 has not been parsed yet.
3582 Initialize the type only, it will be filled in when
3583 it's definition is parsed. */
3584 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3586 add_pending (fh
, esh
, *tpp
);
3589 /* We used one auxent normally, two if we got a "next one" rf. */
3594 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3595 keeping the symtab sorted */
3597 static struct symbol
*
3598 mylookup_symbol (name
, block
, namespace, class)
3600 register struct block
*block
;
3601 enum namespace namespace;
3602 enum address_class
class;
3604 register int bot
, top
, inc
;
3605 register struct symbol
*sym
;
3608 top
= BLOCK_NSYMS (block
);
3612 sym
= BLOCK_SYM (block
, bot
);
3613 if (SYMBOL_NAME (sym
)[0] == inc
3614 && SYMBOL_NAMESPACE (sym
) == namespace
3615 && SYMBOL_CLASS (sym
) == class
3616 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3620 block
= BLOCK_SUPERBLOCK (block
);
3622 return mylookup_symbol (name
, block
, namespace, class);
3627 /* Add a new symbol S to a block B.
3628 Infrequently, we will need to reallocate the block to make it bigger.
3629 We only detect this case when adding to top_stack->cur_block, since
3630 that's the only time we know how big the block is. FIXME. */
3637 int nsyms
= BLOCK_NSYMS (b
)++;
3638 struct block
*origb
;
3639 struct parse_stack
*stackp
;
3641 if (b
== top_stack
->cur_block
&&
3642 nsyms
>= top_stack
->maxsyms
)
3644 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3645 /* In this case shrink_block is actually grow_block, since
3646 BLOCK_NSYMS(b) is larger than its current size. */
3648 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3650 /* Now run through the stack replacing pointers to the
3651 original block. shrink_block has already done this
3652 for the blockvector and BLOCK_FUNCTION. */
3653 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3655 if (stackp
->cur_block
== origb
)
3657 stackp
->cur_block
= b
;
3658 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3662 BLOCK_SYM (b
, nsyms
) = s
;
3665 /* Add a new block B to a symtab S */
3672 struct blockvector
*bv
= BLOCKVECTOR (s
);
3674 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3675 (sizeof (struct blockvector
)
3676 + BLOCKVECTOR_NBLOCKS (bv
)
3677 * sizeof (bv
->block
)));
3678 if (bv
!= BLOCKVECTOR (s
))
3679 BLOCKVECTOR (s
) = bv
;
3681 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3684 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3685 MIPS' linenumber encoding might need more than one byte
3686 to describe it, LAST is used to detect these continuation lines.
3688 Combining lines with the same line number seems like a bad idea.
3689 E.g: There could be a line number entry with the same line number after the
3690 prologue and GDB should not ignore it (this is a better way to find
3691 a prologue than mips_skip_prologue).
3692 But due to the compressed line table format there are line number entries
3693 for the same line which are needed to bridge the gap to the next
3694 line number entry. These entries have a bogus address info with them
3695 and we are unable to tell them from intended duplicate line number
3697 This is another reason why -ggdb debugging format is preferable. */
3700 add_line (lt
, lineno
, adr
, last
)
3701 struct linetable
*lt
;
3706 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3707 Change them to something sensible. */
3711 last
= -2; /* make sure we record first line */
3713 if (last
== lineno
) /* skip continuation lines */
3716 lt
->item
[lt
->nitems
].line
= lineno
;
3717 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3721 /* Sorting and reordering procedures */
3723 /* Blocks with a smaller low bound should come first */
3726 compare_blocks (arg1
, arg2
)
3730 register int addr_diff
;
3731 struct block
**b1
= (struct block
**) arg1
;
3732 struct block
**b2
= (struct block
**) arg2
;
3734 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3736 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3740 /* Sort the blocks of a symtab S.
3741 Reorder the blocks in the blockvector by code-address,
3742 as required by some MI search routines */
3748 struct blockvector
*bv
= BLOCKVECTOR (s
);
3750 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3753 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3754 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3755 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3756 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3760 * This is very unfortunate: normally all functions are compiled in
3761 * the order they are found, but if the file is compiled -O3 things
3762 * are very different. It would be nice to find a reliable test
3763 * to detect -O3 images in advance.
3765 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3766 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3767 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3768 sizeof (struct block
*),
3772 register CORE_ADDR high
= 0;
3773 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3775 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3776 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3777 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3778 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3781 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3782 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3784 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3785 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3786 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3787 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3791 /* Constructor/restructor/destructor procedures */
3793 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3794 MAXSYMS and linenumbers MAXLINES we'll put in it */
3796 static struct symtab
*
3797 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3801 struct objfile
*objfile
;
3803 struct symtab
*s
= allocate_symtab (name
, objfile
);
3805 LINETABLE (s
) = new_linetable (maxlines
);
3807 /* All symtabs must have at least two blocks */
3808 BLOCKVECTOR (s
) = new_bvect (2);
3809 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3810 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3811 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3812 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3814 s
->free_code
= free_linetable
;
3819 /* Allocate a new partial_symtab NAME */
3821 static struct partial_symtab
*
3822 new_psymtab (name
, objfile
, section_offsets
)
3824 struct objfile
*objfile
;
3825 struct section_offsets
*section_offsets
;
3827 struct partial_symtab
*psymtab
;
3829 psymtab
= allocate_psymtab (name
, objfile
);
3830 psymtab
->section_offsets
= section_offsets
;
3832 /* Keep a backpointer to the file's symbols */
3834 psymtab
->read_symtab_private
= ((char *)
3835 obstack_alloc (&objfile
->psymbol_obstack
,
3836 sizeof (struct symloc
)));
3837 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3838 CUR_BFD (psymtab
) = cur_bfd
;
3839 DEBUG_SWAP (psymtab
) = debug_swap
;
3840 DEBUG_INFO (psymtab
) = debug_info
;
3841 PENDING_LIST (psymtab
) = pending_list
;
3843 /* The way to turn this into a symtab is to call... */
3844 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3849 /* Allocate a linetable array of the given SIZE. Since the struct
3850 already includes one item, we subtract one when calculating the
3851 proper size to allocate. */
3853 static struct linetable
*
3854 new_linetable (size
)
3857 struct linetable
*l
;
3859 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3860 l
= (struct linetable
*) xmalloc (size
);
3865 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3866 I am not so sure about the 3.4 ones.
3868 Since the struct linetable already includes one item, we subtract one when
3869 calculating the proper size to allocate. */
3871 static struct linetable
*
3872 shrink_linetable (lt
)
3873 struct linetable
*lt
;
3876 return (struct linetable
*) xrealloc ((PTR
) lt
,
3877 (sizeof (struct linetable
)
3879 * sizeof (lt
->item
))));
3882 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3884 static struct blockvector
*
3888 struct blockvector
*bv
;
3891 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3892 bv
= (struct blockvector
*) xzalloc (size
);
3894 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3899 /* Allocate and zero a new block of MAXSYMS symbols */
3901 static struct block
*
3905 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3907 return (struct block
*) xzalloc (size
);
3910 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3911 Shrink_block can also be used by add_symbol to grow a block. */
3913 static struct block
*
3919 struct blockvector
*bv
= BLOCKVECTOR (s
);
3922 /* Just reallocate it and fix references to the old one */
3924 new = (struct block
*) xrealloc ((PTR
) b
,
3925 (sizeof (struct block
)
3926 + ((BLOCK_NSYMS (b
) - 1)
3927 * sizeof (struct symbol
*))));
3929 /* Should chase pointers to old one. Fortunately, that`s just
3930 the block`s function and inferior blocks */
3931 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3932 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3933 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3934 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3935 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3936 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3937 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3941 /* Create a new symbol with printname NAME */
3943 static struct symbol
*
3947 struct symbol
*s
= ((struct symbol
*)
3948 obstack_alloc (¤t_objfile
->symbol_obstack
,
3949 sizeof (struct symbol
)));
3951 memset ((PTR
) s
, 0, sizeof (*s
));
3952 SYMBOL_NAME (s
) = name
;
3953 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3954 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3958 /* Create a new type with printname NAME */
3960 static struct type
*
3966 t
= alloc_type (current_objfile
);
3967 TYPE_NAME (t
) = name
;
3968 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3972 /* Read ECOFF debugging information from a BFD section. This is
3973 called from elfread.c. It parses the section into a
3974 ecoff_debug_info struct, and then lets the rest of the file handle
3978 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3979 struct objfile
*objfile
;
3980 const struct ecoff_debug_swap
*swap
;
3982 struct section_offsets
*section_offsets
;
3984 bfd
*abfd
= objfile
->obfd
;
3985 struct ecoff_debug_info
*info
;
3987 info
= ((struct ecoff_debug_info
*)
3988 obstack_alloc (&objfile
->psymbol_obstack
,
3989 sizeof (struct ecoff_debug_info
)));
3991 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
3992 error ("Error reading ECOFF debugging information: %s",
3993 bfd_errmsg (bfd_get_error ()));
3995 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3999 /* Things used for calling functions in the inferior.
4000 These functions are exported to our companion
4001 mips-tdep.c file and are here because they play
4002 with the symbol-table explicitly. */
4004 /* Sigtramp: make sure we have all the necessary information
4005 about the signal trampoline code. Since the official code
4006 from MIPS does not do so, we make up that information ourselves.
4007 If they fix the library (unlikely) this code will neutralize itself. */
4009 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4010 here because it calls functions defined in this file, but perhaps
4011 this could be handled in a better way. */
4018 struct block
*b
, *b0
= NULL
;
4020 sigtramp_address
= -1;
4022 /* We have to handle the following cases here:
4023 a) The Mips library has a sigtramp label within sigvec.
4024 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4025 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
4028 b0
= SYMBOL_BLOCK_VALUE (s
);
4029 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
4033 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4034 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
4037 /* But maybe this program uses its own version of sigvec */
4041 /* Did we or MIPSco fix the library ? */
4042 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
4044 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
4045 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
4049 sigtramp_address
= SYMBOL_VALUE (s
);
4050 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
4052 /* But what symtab does it live in ? */
4053 st
= find_pc_symtab (SYMBOL_VALUE (s
));
4056 * Ok, there goes the fix: turn it into a procedure, with all the
4057 * needed info. Note we make it a nested procedure of sigvec,
4058 * which is the way the (assembly) code is actually written.
4060 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4061 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4062 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4064 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
4066 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4068 SYMBOL_BLOCK_VALUE (s
) = b
;
4069 BLOCK_START (b
) = sigtramp_address
;
4070 BLOCK_END (b
) = sigtramp_end
;
4071 BLOCK_FUNCTION (b
) = s
;
4072 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4076 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4078 struct mips_extra_func_info
*e
=
4079 ((struct mips_extra_func_info
*)
4080 xzalloc (sizeof (struct mips_extra_func_info
)));
4082 e
->numargs
= 0; /* the kernel thinks otherwise */
4083 e
->pdr
.frameoffset
= 32;
4084 e
->pdr
.framereg
= SP_REGNUM
;
4085 /* Note that setting pcreg is no longer strictly necessary as
4086 mips_frame_saved_pc is now aware of signal handler frames. */
4087 e
->pdr
.pcreg
= PC_REGNUM
;
4088 e
->pdr
.regmask
= -2;
4089 /* Offset to saved r31, in the sigtramp case the saved registers
4090 are above the frame in the sigcontext.
4091 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4092 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4093 and 32 * 4 bytes for the floating point registers. */
4094 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4095 e
->pdr
.fregmask
= -1;
4096 /* Offset to saved f30 (first saved *double* register). */
4097 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4098 e
->pdr
.isym
= (long) s
;
4099 e
->pdr
.adr
= sigtramp_address
;
4101 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4102 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4103 SYMBOL_VALUE (s
) = (long) e
;
4104 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4105 SYMBOL_CLASS (s
) = LOC_CONST
;
4106 SYMBOL_TYPE (s
) = builtin_type_void
;
4107 current_objfile
= NULL
;
4110 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4114 _initialize_mdebugread ()
4116 /* Missing basic types */
4118 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4120 mdebug_type_string
=
4121 init_type (TYPE_CODE_STRING
,
4122 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4124 (struct objfile
*) NULL
);
4126 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4127 good? Would we be better off with TYPE_CODE_ERROR? Should
4128 TYPE_CODE_ERROR print things in hex if it knows the size? */
4129 mdebug_type_fixed_dec
=
4130 init_type (TYPE_CODE_INT
,
4131 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4133 (struct objfile
*) NULL
);
4135 mdebug_type_float_dec
=
4136 init_type (TYPE_CODE_ERROR
,
4137 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4138 0, "floating decimal",
4139 (struct objfile
*) NULL
);
4141 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
4142 "<function, no debug info>", NULL
);
4143 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = builtin_type_int
;
4144 nodebug_var_symbol_type
=
4145 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4146 "<variable, no debug info>", NULL
);