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 /* We put a pointer to this structure in the read_symtab_private field
106 /* Index of the FDR that this psymtab represents. */
108 /* The BFD that the psymtab was created from. */
110 const struct ecoff_debug_swap
*debug_swap
;
111 struct ecoff_debug_info
*debug_info
;
112 struct mdebug_pending
**pending_list
;
113 /* Pointer to external symbols for this file. */
115 /* Size of extern_tab. */
117 enum language pst_language
;
120 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
121 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
122 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
123 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
124 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
125 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
127 /* Things we import explicitly from other modules */
129 extern int info_verbose
;
131 /* Various complaints about symbol reading that don't abort the process */
133 static struct complaint bad_file_number_complaint
=
134 {"bad file number %d", 0, 0};
136 static struct complaint index_complaint
=
137 {"bad aux index at symbol %s", 0, 0};
139 static struct complaint aux_index_complaint
=
140 {"bad proc end in aux found from symbol %s", 0, 0};
142 static struct complaint block_index_complaint
=
143 {"bad aux index at block symbol %s", 0, 0};
145 static struct complaint unknown_ext_complaint
=
146 {"unknown external symbol %s", 0, 0};
148 static struct complaint unknown_sym_complaint
=
149 {"unknown local symbol %s", 0, 0};
151 static struct complaint unknown_st_complaint
=
152 {"with type %d", 0, 0};
154 static struct complaint block_overflow_complaint
=
155 {"block containing %s overfilled", 0, 0};
157 static struct complaint basic_type_complaint
=
158 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
160 static struct complaint unknown_type_qual_complaint
=
161 {"unknown type qualifier 0x%x", 0, 0};
163 static struct complaint array_index_type_complaint
=
164 {"illegal array index type for %s, assuming int", 0, 0};
166 static struct complaint bad_tag_guess_complaint
=
167 {"guessed tag type of %s incorrectly", 0, 0};
169 static struct complaint block_member_complaint
=
170 {"declaration block contains unhandled symbol type %d", 0, 0};
172 static struct complaint stEnd_complaint
=
173 {"stEnd with storage class %d not handled", 0, 0};
175 static struct complaint unknown_mdebug_symtype_complaint
=
176 {"unknown symbol type 0x%x", 0, 0};
178 static struct complaint stab_unknown_complaint
=
179 {"unknown stabs symbol %s", 0, 0};
181 static struct complaint pdr_for_nonsymbol_complaint
=
182 {"PDR for %s, but no symbol", 0, 0};
184 static struct complaint pdr_static_symbol_complaint
=
185 {"can't handle PDR for static proc at 0x%lx", 0, 0};
187 static struct complaint bad_setjmp_pdr_complaint
=
188 {"fixing bad setjmp PDR from libc", 0, 0};
190 static struct complaint bad_fbitfield_complaint
=
191 {"can't handle TIR fBitfield for %s", 0, 0};
193 static struct complaint bad_continued_complaint
=
194 {"illegal TIR continued for %s", 0, 0};
196 static struct complaint bad_rfd_entry_complaint
=
197 {"bad rfd entry for %s: file %d, index %d", 0, 0};
199 static struct complaint unexpected_type_code_complaint
=
200 {"unexpected type code for %s", 0, 0};
202 static struct complaint unable_to_cross_ref_complaint
=
203 {"unable to cross ref btTypedef for %s", 0, 0};
205 static struct complaint illegal_forward_tq0_complaint
=
206 {"illegal tq0 in forward typedef for %s", 0, 0};
208 static struct complaint illegal_forward_bt_complaint
=
209 {"illegal bt %d in forward typedef for %s", 0, 0};
211 static struct complaint bad_linetable_guess_complaint
=
212 {"guessed size of linetable for %s incorrectly", 0, 0};
214 static struct complaint bad_ext_ifd_complaint
=
215 {"bad ifd for external symbol: %d (max %d)", 0, 0};
217 static struct complaint bad_ext_iss_complaint
=
218 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
220 /* Macros and extra defs */
222 /* Puns: hard to find whether -g was used and how */
224 #define MIN_GLEVEL GLEVEL_0
225 #define compare_glevel(a,b) \
226 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
227 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
229 /* Things that really are local to this module */
231 /* Remember what we deduced to be the source language of this psymtab. */
233 static enum language psymtab_language
= language_unknown
;
239 /* How to parse debugging information for CUR_BFD. */
241 static const struct ecoff_debug_swap
*debug_swap
;
243 /* Pointers to debugging information for CUR_BFD. */
245 static struct ecoff_debug_info
*debug_info
;
247 /* Pointer to current file decriptor record, and its index */
252 /* Index of current symbol */
256 /* Note how much "debuggable" this image is. We would like
257 to see at least one FDR with full symbols */
262 /* When examining .o files, report on undefined symbols */
264 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
266 /* Pseudo symbol to use when putting stabs into the symbol table. */
268 static char stabs_symbol
[] = STABS_SYMBOL
;
270 /* Types corresponding to btComplex, btDComplex, etc. These are here
271 rather than in gdbtypes.c or some such, because the meaning of codes
272 like btComplex is specific to the mdebug debug format. FIXME: We should
273 be using our own types thoughout this file, instead of sometimes using
276 static struct type
*mdebug_type_fixed_dec
;
277 static struct type
*mdebug_type_float_dec
;
278 static struct type
*mdebug_type_string
;
280 /* Types for symbols from files compiled without debugging info. */
282 static struct type
*nodebug_func_symbol_type
;
283 static struct type
*nodebug_var_symbol_type
;
285 /* Nonzero if we have seen ecoff debugging info for a file. */
287 static int found_ecoff_debugging_info
;
289 /* Forward declarations */
292 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
295 parse_partial_symbols
PARAMS ((struct objfile
*,
296 struct section_offsets
*));
299 *get_rfd
PARAMS ((int, int));
302 has_opaque_xref
PARAMS ((FDR
*, SYMR
*));
305 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
306 char **, int, char *));
308 static struct symbol
*
309 new_symbol
PARAMS ((char *));
312 new_type
PARAMS ((char *));
314 static struct block
*
315 new_block
PARAMS ((int));
317 static struct symtab
*
318 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
320 static struct linetable
*
321 new_linetable
PARAMS ((int));
323 static struct blockvector
*
324 new_bvect
PARAMS ((int));
327 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int, struct section_offsets
*));
330 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
332 static struct symbol
*
333 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
334 enum address_class
));
336 static struct block
*
337 shrink_block
PARAMS ((struct block
*, struct symtab
*));
340 xzalloc
PARAMS ((unsigned int));
343 sort_blocks
PARAMS ((struct symtab
*));
346 compare_blocks
PARAMS ((const void *, const void *));
348 static struct partial_symtab
*
349 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
352 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
355 add_block
PARAMS ((struct block
*, struct symtab
*));
358 add_symbol
PARAMS ((struct symbol
*, struct block
*));
361 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
363 static struct linetable
*
364 shrink_linetable
PARAMS ((struct linetable
*));
367 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int));
370 mdebug_next_symbol_text
PARAMS ((void));
372 /* Address bounds for the signal trampoline in inferior, if any */
374 CORE_ADDR sigtramp_address
, sigtramp_end
;
376 /* Allocate zeroed memory */
382 PTR p
= xmalloc (size
);
388 /* Exported procedure: Builds a symtab from the PST partial one.
389 Restores the environment in effect when PST was created, delegates
390 most of the work to an ancillary procedure, and sorts
391 and reorders the symtab list at the end */
394 mdebug_psymtab_to_symtab (pst
)
395 struct partial_symtab
*pst
;
403 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
404 gdb_flush (gdb_stdout
);
407 next_symbol_text_func
= mdebug_next_symbol_text
;
409 psymtab_to_symtab_1 (pst
, pst
->filename
);
411 /* Match with global symbols. This only needs to be done once,
412 after all of the symtabs and dependencies have been read in. */
413 scan_file_globals (pst
->objfile
);
416 printf_filtered ("done.\n");
419 /* File-level interface functions */
421 /* Find a file descriptor given its index RF relative to a file CF */
431 fdrs
= debug_info
->fdr
;
433 /* Object files do not have the RFD table, all refs are absolute */
436 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
437 ((char *) debug_info
->external_rfd
439 * debug_swap
->external_rfd_size
)),
444 /* Return a safer print NAME for a file descriptor */
451 return "<stripped file>";
454 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
458 /* Read in and parse the symtab of the file OBJFILE. Symbols from
459 different sections are relocated via the SECTION_OFFSETS. */
462 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
463 struct objfile
*objfile
;
464 const struct ecoff_debug_swap
*swap
;
465 struct ecoff_debug_info
*info
;
466 struct section_offsets
*section_offsets
;
468 cur_bfd
= objfile
->obfd
;
472 /* Make sure all the FDR information is swapped in. */
473 if (info
->fdr
== (FDR
*) NULL
)
479 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
480 (info
->symbolic_header
.ifdMax
482 fdr_src
= info
->external_fdr
;
484 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
486 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
487 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
490 parse_partial_symbols (objfile
, section_offsets
);
493 /* Check to make sure file was compiled with -g. If not, warn the
494 user of this limitation. */
495 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
497 if (max_gdbinfo
== 0)
498 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
500 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
501 gdb_flush (gdb_stdout
);
506 /* Local utilities */
508 /* Map of FDR indexes to partial symtabs */
512 struct partial_symtab
*pst
; /* the psymtab proper */
513 long n_globals
; /* exported globals (external symbols) */
514 long globals_offset
; /* cumulative */
518 /* Utility stack, used to nest procedures and blocks properly.
519 It is a doubly linked list, to avoid too many alloc/free.
520 Since we might need it quite a few times it is NOT deallocated
523 static struct parse_stack
525 struct parse_stack
*next
, *prev
;
526 struct symtab
*cur_st
; /* Current symtab. */
527 struct block
*cur_block
; /* Block in it. */
529 /* What are we parsing. stFile, or stBlock are for files and
530 blocks. stProc or stStaticProc means we have seen the start of a
531 procedure, but not the start of the block within in. When we see
532 the start of that block, we change it to stNil, without pushing a
533 new block, i.e. stNil means both a procedure and a block. */
537 int maxsyms
; /* Max symbols in this block. */
538 struct type
*cur_type
; /* Type we parse fields for. */
539 int cur_field
; /* Field number in cur_type. */
540 CORE_ADDR procadr
; /* Start addres of this procedure */
541 int numargs
; /* Its argument count */
544 *top_stack
; /* Top stack ptr */
547 /* Enter a new lexical context */
552 struct parse_stack
*new;
554 /* Reuse frames if possible */
555 if (top_stack
&& top_stack
->prev
)
556 new = top_stack
->prev
;
558 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
559 /* Initialize new frame with previous content */
562 register struct parse_stack
*prev
= new->prev
;
565 top_stack
->prev
= new;
567 new->next
= top_stack
;
572 /* Exit a lexical context */
580 top_stack
= top_stack
->next
;
584 /* Cross-references might be to things we haven't looked at
585 yet, e.g. type references. To avoid too many type
586 duplications we keep a quick fixup table, an array
587 of lists of references indexed by file descriptor */
589 struct mdebug_pending
591 struct mdebug_pending
*next
; /* link */
592 char *s
; /* the unswapped symbol */
593 struct type
*t
; /* its partial type descriptor */
597 /* The pending information is kept for an entire object file, and used
598 to be in the sym_private field. I took it out when I split
599 mdebugread from mipsread, because this might not be the only type
600 of symbols read from an object file. Instead, we allocate the
601 pending information table when we create the partial symbols, and
602 we store a pointer to the single table in each psymtab. */
604 static struct mdebug_pending
**pending_list
;
606 /* Check whether we already saw symbol SH in file FH */
608 static struct mdebug_pending
*
609 is_pending_symbol (fh
, sh
)
613 int f_idx
= fh
- debug_info
->fdr
;
614 register struct mdebug_pending
*p
;
616 /* Linear search is ok, list is typically no more than 10 deep */
617 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
623 /* Add a new symbol SH of type T */
626 add_pending (fh
, sh
, t
)
631 int f_idx
= fh
- debug_info
->fdr
;
632 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
634 /* Make sure we do not make duplicates */
637 p
= ((struct mdebug_pending
*)
638 obstack_alloc (¤t_objfile
->psymbol_obstack
,
639 sizeof (struct mdebug_pending
)));
642 p
->next
= pending_list
[f_idx
];
643 pending_list
[f_idx
] = p
;
648 /* Parsing Routines proper. */
650 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
651 For blocks, procedures and types we open a new lexical context.
652 This is basically just a big switch on the symbol's type. Argument
653 AX is the base pointer of aux symbols for this file (fh->iauxBase).
654 EXT_SH points to the unswapped symbol, which is needed for struct,
655 union, etc., types; it is NULL for an EXTR. BIGEND says whether
656 aux symbols are big-endian or little-endian. Return count of
657 SYMR's handled (normally one). */
660 parse_symbol (sh
, ax
, ext_sh
, bigend
, section_offsets
)
665 struct section_offsets
*section_offsets
;
667 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
668 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
669 debug_swap
->swap_sym_in
;
673 struct mdebug_pending
*pend
;
677 enum address_class
class;
679 long svalue
= sh
->value
;
682 if (ext_sh
== (char *) NULL
)
683 name
= debug_info
->ssext
+ sh
->iss
;
685 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
690 /* Do not relocate relative values.
691 The value of a stEnd symbol is the displacement from the
692 corresponding start symbol value.
693 The value of a stBlock symbol is the displacement from the
694 procedure address. */
695 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
696 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
703 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
707 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
716 case stGlobal
: /* external symbol, goes into global block */
718 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
720 s
= new_symbol (name
);
721 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
724 case stStatic
: /* static data, goes into current block. */
726 b
= top_stack
->cur_block
;
727 s
= new_symbol (name
);
728 if (sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
730 /* It is a FORTRAN common block. At least for SGI Fortran the
731 address is not in the symbol; we need to fix it later in
732 scan_file_globals. */
733 int bucket
= hashname (SYMBOL_NAME (s
));
734 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
735 global_sym_chain
[bucket
] = s
;
738 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
741 case stLocal
: /* local variable, goes into current block */
742 if (sh
->sc
== scRegister
)
744 class = LOC_REGISTER
;
745 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
749 b
= top_stack
->cur_block
;
750 s
= new_symbol (name
);
751 SYMBOL_VALUE (s
) = svalue
;
753 data
: /* Common code for symbols describing data */
754 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
755 SYMBOL_CLASS (s
) = class;
758 /* Type could be missing if file is compiled without debugging info. */
759 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
|| sh
->index
== indexNil
)
760 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
762 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
763 /* Value of a data symbol is its memory address */
766 case stParam
: /* arg to procedure, goes into current block */
768 found_ecoff_debugging_info
= 1;
769 top_stack
->numargs
++;
771 /* Special GNU C++ name. */
772 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
773 name
= "this"; /* FIXME, not alloc'd in obstack */
774 s
= new_symbol (name
);
776 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
780 /* Pass by value in register. */
781 SYMBOL_CLASS(s
) = LOC_REGPARM
;
782 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
785 /* Pass by reference on stack. */
786 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
789 /* Pass by reference in register. */
790 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
791 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
794 /* Pass by value on stack. */
795 SYMBOL_CLASS(s
) = LOC_ARG
;
798 SYMBOL_VALUE (s
) = svalue
;
799 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
800 add_symbol (s
, top_stack
->cur_block
);
803 case stLabel
: /* label, goes into current block */
804 s
= new_symbol (name
);
805 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
806 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
807 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
808 SYMBOL_TYPE (s
) = builtin_type_int
;
809 add_symbol (s
, top_stack
->cur_block
);
812 case stProc
: /* Procedure, usually goes into global block */
813 case stStaticProc
: /* Static procedure, goes into current block */
814 s
= new_symbol (name
);
815 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
816 SYMBOL_CLASS (s
) = LOC_BLOCK
;
817 /* Type of the return value */
818 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
819 t
= builtin_type_int
;
821 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
822 b
= top_stack
->cur_block
;
823 if (sh
->st
== stProc
)
825 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
826 /* The next test should normally be true, but provides a
827 hook for nested functions (which we don't want to make
829 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
830 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
831 /* Irix 5 sometimes has duplicate names for the same
832 function. We want to add such names up at the global
833 level, not as a nested function. */
834 else if (sh
->value
== top_stack
->procadr
)
835 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
839 /* Make a type for the procedure itself */
840 SYMBOL_TYPE (s
) = lookup_function_type (t
);
842 /* Create and enter a new lexical context */
843 b
= new_block (top_stack
->maxsyms
);
844 SYMBOL_BLOCK_VALUE (s
) = b
;
845 BLOCK_FUNCTION (b
) = s
;
846 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
847 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
848 add_block (b
, top_stack
->cur_st
);
850 /* Not if we only have partial info */
851 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
855 top_stack
->cur_block
= b
;
856 top_stack
->blocktype
= sh
->st
;
857 top_stack
->cur_type
= SYMBOL_TYPE (s
);
858 top_stack
->cur_field
= -1;
859 top_stack
->procadr
= sh
->value
;
860 top_stack
->numargs
= 0;
863 /* Beginning of code for structure, union, and enum definitions.
864 They all share a common set of local variables, defined here. */
866 enum type_code type_code
;
872 case stStruct
: /* Start a block defining a struct type */
873 type_code
= TYPE_CODE_STRUCT
;
874 goto structured_common
;
876 case stUnion
: /* Start a block defining a union type */
877 type_code
= TYPE_CODE_UNION
;
878 goto structured_common
;
880 case stEnum
: /* Start a block defining an enum type */
881 type_code
= TYPE_CODE_ENUM
;
882 goto structured_common
;
884 case stBlock
: /* Either a lexical block, or some type */
885 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
886 goto case_stBlock_code
; /* Lexical block */
888 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
890 /* Common code for handling struct, union, enum, and/or as-yet-
891 unknown-type blocks of info about structured data. `type_code'
892 has been set to the proper TYPE_CODE, if we know it. */
894 found_ecoff_debugging_info
= 1;
896 top_stack
->blocktype
= stBlock
;
898 /* First count the number of fields and the highest value. */
901 for (ext_tsym
= ext_sh
+ external_sym_size
;
903 ext_tsym
+= external_sym_size
)
907 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
915 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
916 /* If the type of the member is Nil (or Void),
917 without qualifiers, assume the tag is an
919 if (tsym
.index
== indexNil
)
920 type_code
= TYPE_CODE_ENUM
;
923 (*debug_swap
->swap_tir_in
) (bigend
,
924 &ax
[tsym
.index
].a_ti
,
926 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
928 type_code
= TYPE_CODE_ENUM
;
931 if (tsym
.value
> max_value
)
932 max_value
= tsym
.value
;
941 /* This is a no-op; is it trying to tell us something
942 we should be checking? */
943 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
947 /* This is something like a struct within a
948 struct. Skip over the fields of the inner
949 struct. The -1 is because the for loop will
950 increment ext_tsym. */
951 ext_tsym
= ((char *) debug_info
->external_sym
952 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
953 * external_sym_size
));
959 /* mips cc puts out a typedef for struct x if it is not yet
960 defined when it encounters
961 struct y { struct x *xp; };
966 /* Irix5 cc puts out a stIndirect for struct x if it is not
967 yet defined when it encounters
968 struct y { struct x *xp; };
973 complain (&block_member_complaint
, tsym
.st
);
978 /* In an stBlock, there is no way to distinguish structs,
979 unions, and enums at this point. This is a bug in the
980 original design (that has been fixed with the recent
981 addition of the stStruct, stUnion, and stEnum symbol
982 types.) The way you can tell is if/when you see a variable
983 or field of that type. In that case the variable's type
984 (in the AUX table) says if the type is struct, union, or
985 enum, and points back to the stBlock here. So you can
986 patch the tag kind up later - but only if there actually is
987 a variable or field of that type.
989 So until we know for sure, we will guess at this point.
991 If the first member has index==indexNil or a void type,
992 assume we have an enumeration.
993 Otherwise, if there is more than one member, and all
994 the members have offset 0, assume we have a union.
995 Otherwise, assume we have a struct.
997 The heuristic could guess wrong in the case of of an
998 enumeration with no members or a union with one (or zero)
999 members, or when all except the last field of a struct have
1000 width zero. These are uncommon and/or illegal situations,
1001 and in any case guessing wrong probably doesn't matter
1004 But if we later do find out we were wrong, we fixup the tag
1005 kind. Members of an enumeration must be handled
1006 differently from struct/union fields, and that is harder to
1007 patch up, but luckily we shouldn't need to. (If there are
1008 any enumeration members, we can tell for sure it's an enum
1011 if (type_code
== TYPE_CODE_UNDEF
)
1012 if (nfields
> 1 && max_value
== 0)
1013 type_code
= TYPE_CODE_UNION
;
1015 type_code
= TYPE_CODE_STRUCT
;
1017 /* Create a new type or use the pending type. */
1018 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1019 if (pend
== (struct mdebug_pending
*) NULL
)
1021 t
= new_type (NULL
);
1022 add_pending (cur_fdr
, ext_sh
, t
);
1027 /* Do not set the tag name if it is a compiler generated tag name
1028 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1029 Alpha cc puts out an sh->iss of zero for those. */
1030 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1031 TYPE_TAG_NAME (t
) = NULL
;
1033 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1036 TYPE_CODE (t
) = type_code
;
1037 TYPE_LENGTH (t
) = sh
->value
;
1038 TYPE_NFIELDS (t
) = nfields
;
1039 TYPE_FIELDS (t
) = f
= ((struct field
*)
1041 nfields
* sizeof (struct field
)));
1043 if (type_code
== TYPE_CODE_ENUM
)
1045 /* This is a non-empty enum. */
1047 /* DEC c89 has the number of enumerators in the sh.value field,
1048 not the type length, so we have to compensate for that
1049 incompatibility quirk.
1050 This might do the wrong thing for an enum with one or two
1051 enumerators and gcc -gcoff -fshort-enums, but these cases
1052 are hopefully rare enough. */
1053 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1054 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1055 for (ext_tsym
= ext_sh
+ external_sym_size
;
1057 ext_tsym
+= external_sym_size
)
1060 struct symbol
*enum_sym
;
1062 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1064 if (tsym
.st
!= stMember
)
1067 f
->bitpos
= tsym
.value
;
1069 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1072 enum_sym
= ((struct symbol
*)
1073 obstack_alloc (¤t_objfile
->symbol_obstack
,
1074 sizeof (struct symbol
)));
1075 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1076 SYMBOL_NAME (enum_sym
) = f
->name
;
1077 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1078 SYMBOL_TYPE (enum_sym
) = t
;
1079 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1080 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1081 add_symbol (enum_sym
, top_stack
->cur_block
);
1083 /* Skip the stMembers that we've handled. */
1088 /* make this the current type */
1089 top_stack
->cur_type
= t
;
1090 top_stack
->cur_field
= 0;
1092 /* Do not create a symbol for alpha cc unnamed structs. */
1096 /* gcc puts out an empty struct for an opaque struct definitions,
1097 do not create a symbol for it either. */
1098 if (TYPE_NFIELDS (t
) == 0)
1100 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1104 s
= new_symbol (name
);
1105 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1106 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1107 SYMBOL_VALUE (s
) = 0;
1108 SYMBOL_TYPE (s
) = t
;
1109 add_symbol (s
, top_stack
->cur_block
);
1112 /* End of local variables shared by struct, union, enum, and
1113 block (as yet unknown struct/union/enum) processing. */
1117 found_ecoff_debugging_info
= 1;
1118 /* beginnning of (code) block. Value of symbol
1119 is the displacement from procedure start */
1120 push_parse_stack ();
1122 /* Do not start a new block if this is the outermost block of a
1123 procedure. This allows the LOC_BLOCK symbol to point to the
1124 block with the local variables, so funcname::var works. */
1125 if (top_stack
->blocktype
== stProc
1126 || top_stack
->blocktype
== stStaticProc
)
1128 top_stack
->blocktype
= stNil
;
1132 top_stack
->blocktype
= stBlock
;
1133 b
= new_block (top_stack
->maxsyms
);
1134 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1135 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1136 top_stack
->cur_block
= b
;
1137 add_block (b
, top_stack
->cur_st
);
1140 case stEnd
: /* end (of anything) */
1141 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1143 /* Finished with type */
1144 top_stack
->cur_type
= 0;
1146 else if (sh
->sc
== scText
&&
1147 (top_stack
->blocktype
== stProc
||
1148 top_stack
->blocktype
== stStaticProc
))
1150 /* Finished with procedure */
1151 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1152 struct mips_extra_func_info
*e
;
1154 struct type
*ftype
= top_stack
->cur_type
;
1157 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1159 /* Make up special symbol to contain procedure specific info */
1160 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1161 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1162 SYMBOL_CLASS (s
) = LOC_CONST
;
1163 SYMBOL_TYPE (s
) = builtin_type_void
;
1164 e
= ((struct mips_extra_func_info
*)
1165 obstack_alloc (¤t_objfile
->symbol_obstack
,
1166 sizeof (struct mips_extra_func_info
)));
1167 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
1168 SYMBOL_VALUE (s
) = (long) e
;
1169 e
->numargs
= top_stack
->numargs
;
1170 e
->pdr
.framereg
= -1;
1171 add_symbol (s
, top_stack
->cur_block
);
1173 /* Reallocate symbols, saving memory */
1174 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1176 /* f77 emits proc-level with address bounds==[0,0],
1177 So look for such child blocks, and patch them. */
1178 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1180 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1181 if (BLOCK_SUPERBLOCK (b_bad
) == b
1182 && BLOCK_START (b_bad
) == top_stack
->procadr
1183 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1185 BLOCK_START (b_bad
) = BLOCK_START (b
);
1186 BLOCK_END (b_bad
) = BLOCK_END (b
);
1190 if (TYPE_NFIELDS (ftype
) <= 0)
1192 /* No parameter type information is recorded with the function's
1193 type. Set that from the type of the parameter symbols. */
1194 int nparams
= top_stack
->numargs
;
1200 TYPE_NFIELDS (ftype
) = nparams
;
1201 TYPE_FIELDS (ftype
) = (struct field
*)
1202 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1204 for (i
= iparams
= 0; iparams
< nparams
; i
++)
1206 sym
= BLOCK_SYM (b
, i
);
1207 switch (SYMBOL_CLASS (sym
))
1212 case LOC_REGPARM_ADDR
:
1213 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1223 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1225 /* End of (code) block. The value of the symbol is the
1226 displacement from the procedure`s start address of the
1227 end of this block. */
1228 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1229 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1231 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1233 /* End of outermost block. Pop parse stack and ignore. The
1234 following stEnd of stProc will take care of the block. */
1237 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1239 /* End of file. Pop parse stack and ignore. Higher
1240 level code deals with this. */
1244 complain (&stEnd_complaint
, sh
->sc
);
1246 pop_parse_stack (); /* restore previous lexical context */
1249 case stMember
: /* member of struct or union */
1250 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1252 f
->bitpos
= sh
->value
;
1254 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1255 f
->bitsize
= bitsize
;
1258 case stIndirect
: /* forward declaration on Irix5 */
1259 /* Forward declarations from Irix5 cc are handled by cross_ref,
1263 case stTypedef
: /* type definition */
1264 found_ecoff_debugging_info
= 1;
1266 /* Typedefs for forward declarations and opaque structs from alpha cc
1267 are handled by cross_ref, skip them. */
1271 /* Parse the type or use the pending type. */
1272 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1273 if (pend
== (struct mdebug_pending
*) NULL
)
1275 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1276 add_pending (cur_fdr
, ext_sh
, t
);
1281 /* mips cc puts out a typedef with the name of the struct for forward
1282 declarations. These should not go into the symbol table and
1283 TYPE_NAME should not be set for them.
1284 They can't be distinguished from an intentional typedef to
1285 the same name however:
1287 struct x { int ix; int jx; };
1291 struct xx {int ixx; int jxx; };
1292 generates a cross referencing stTypedef for x and xx.
1293 The user visible effect of this is that the type of a pointer
1294 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1295 The problem is fixed with alpha cc and Irix5 cc. */
1297 /* However if the typedef cross references to an opaque aggregate, it
1298 is safe to omit it from the symbol table. */
1300 if (has_opaque_xref (cur_fdr
, sh
))
1302 s
= new_symbol (name
);
1303 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1304 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1305 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1306 SYMBOL_TYPE (s
) = t
;
1307 add_symbol (s
, top_stack
->cur_block
);
1309 /* Incomplete definitions of structs should not get a name. */
1310 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1311 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1312 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1313 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1315 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1316 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1318 /* If we are giving a name to a type such as "pointer to
1319 foo" or "function returning foo", we better not set
1320 the TYPE_NAME. If the program contains "typedef char
1321 *caddr_t;", we don't want all variables of type char
1322 * to print as caddr_t. This is not just a
1323 consequence of GDB's type management; CC and GCC (at
1324 least through version 2.4) both output variables of
1325 either type char * or caddr_t with the type
1326 refering to the stTypedef symbol for caddr_t. If a future
1327 compiler cleans this up it GDB is not ready for it
1328 yet, but if it becomes ready we somehow need to
1329 disable this check (without breaking the PCC/GCC2.4
1334 Fortunately, this check seems not to be necessary
1335 for anything except pointers or functions. */
1338 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1342 case stFile
: /* file name */
1343 push_parse_stack ();
1344 top_stack
->blocktype
= sh
->st
;
1347 /* I`ve never seen these for C */
1349 break; /* register relocation */
1351 break; /* forwarding address */
1353 break; /* constant */
1355 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1362 /* Parse the type information provided in the raw AX entries for
1363 the symbol SH. Return the bitfield size in BS, in case.
1364 We must byte-swap the AX entries before we use them; BIGEND says whether
1365 they are big-endian or little-endian (from fh->fBigendian). */
1367 static struct type
*
1368 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1371 unsigned int aux_index
;
1376 /* Null entries in this map are treated specially */
1377 static struct type
**map_bt
[] =
1379 &builtin_type_void
, /* btNil */
1381 &builtin_type_char
, /* btChar */
1382 &builtin_type_unsigned_char
,/* btUChar */
1383 &builtin_type_short
, /* btShort */
1384 &builtin_type_unsigned_short
, /* btUShort */
1385 &builtin_type_int
, /* btInt */
1386 &builtin_type_unsigned_int
, /* btUInt */
1387 &builtin_type_long
, /* btLong */
1388 &builtin_type_unsigned_long
,/* btULong */
1389 &builtin_type_float
, /* btFloat */
1390 &builtin_type_double
, /* btDouble */
1397 &builtin_type_complex
, /* btComplex */
1398 &builtin_type_double_complex
,/* btDComplex */
1400 &mdebug_type_fixed_dec
, /* btFixedDec */
1401 &mdebug_type_float_dec
, /* btFloatDec */
1402 &mdebug_type_string
, /* btString */
1405 &builtin_type_void
, /* btVoid */
1406 0, /* DEC C++: Pointer to member */
1407 0, /* DEC C++: Virtual function table */
1408 0, /* DEC C++: Class (Record) */
1409 &builtin_type_long
, /* btLong64 */
1410 &builtin_type_unsigned_long
, /* btULong64 */
1411 &builtin_type_long_long
, /* btLongLong64 */
1412 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1413 &builtin_type_unsigned_long
, /* btAdr64 */
1414 &builtin_type_long
, /* btInt64 */
1415 &builtin_type_unsigned_long
, /* btUInt64 */
1419 struct type
*tp
= 0;
1420 enum type_code type_code
= TYPE_CODE_UNDEF
;
1422 /* Handle undefined types, they have indexNil. */
1423 if (aux_index
== indexNil
)
1424 return builtin_type_int
;
1426 /* Handle corrupt aux indices. */
1427 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1429 complain (&index_complaint
, sym_name
);
1430 return builtin_type_int
;
1434 /* Use aux as a type information record, map its basic type. */
1435 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1436 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1438 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1439 return builtin_type_int
;
1443 tp
= *map_bt
[t
->bt
];
1448 /* Cannot use builtin types -- build our own */
1452 tp
= lookup_pointer_type (builtin_type_void
);
1455 type_code
= TYPE_CODE_STRUCT
;
1458 type_code
= TYPE_CODE_UNION
;
1461 type_code
= TYPE_CODE_ENUM
;
1464 type_code
= TYPE_CODE_RANGE
;
1467 type_code
= TYPE_CODE_SET
;
1470 /* alpha cc uses this for typedefs. The true type will be
1471 obtained by crossreferencing below. */
1472 type_code
= TYPE_CODE_ERROR
;
1475 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1476 return builtin_type_int
;
1480 /* Move on to next aux */
1485 /* Inhibit core dumps with some cfront generated objects that
1487 if (bs
== (int *)NULL
)
1489 complain (&bad_fbitfield_complaint
, sym_name
);
1490 return builtin_type_int
;
1492 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1496 /* All these types really point to some (common) MIPS type
1497 definition, and only the type-qualifiers fully identify
1498 them. We'll make the same effort at sharing. */
1499 if (t
->bt
== btStruct
||
1503 /* btSet (I think) implies that the name is a tag name, not a typedef
1504 name. This apparently is a MIPS extension for C sets. */
1509 /* Try to cross reference this type, build new type on failure. */
1510 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1511 if (tp
== (struct type
*) NULL
)
1512 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1514 /* DEC c89 produces cross references to qualified aggregate types,
1515 dereference them. */
1516 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1517 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1518 tp
= tp
->target_type
;
1520 /* Make sure that TYPE_CODE(tp) has an expected type code.
1521 Any type may be returned from cross_ref if file indirect entries
1523 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1524 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1525 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1527 complain (&unexpected_type_code_complaint
, sym_name
);
1532 /* Usually, TYPE_CODE(tp) is already type_code. The main
1533 exception is if we guessed wrong re struct/union/enum.
1534 But for struct vs. union a wrong guess is harmless, so
1535 don't complain(). */
1536 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1537 && type_code
!= TYPE_CODE_ENUM
)
1538 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1539 && type_code
== TYPE_CODE_ENUM
))
1541 complain (&bad_tag_guess_complaint
, sym_name
);
1544 if (TYPE_CODE (tp
) != type_code
)
1546 TYPE_CODE (tp
) = type_code
;
1549 /* Do not set the tag name if it is a compiler generated tag name
1550 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1551 if (name
[0] == '.' || name
[0] == '\0')
1552 TYPE_TAG_NAME (tp
) = NULL
;
1553 else if (TYPE_TAG_NAME (tp
) == NULL
1554 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1555 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1556 ¤t_objfile
->type_obstack
);
1560 /* All these types really point to some (common) MIPS type
1561 definition, and only the type-qualifiers fully identify
1562 them. We'll make the same effort at sharing.
1563 FIXME: btIndirect cannot happen here as it is handled by the
1564 switch t->bt above. And we are not doing any guessing on range types. */
1565 if (t
->bt
== btIndirect
||
1570 /* Try to cross reference this type, build new type on failure. */
1571 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1572 if (tp
== (struct type
*) NULL
)
1573 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1575 /* Make sure that TYPE_CODE(tp) has an expected type code.
1576 Any type may be returned from cross_ref if file indirect entries
1578 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1580 complain (&unexpected_type_code_complaint
, sym_name
);
1584 /* Usually, TYPE_CODE(tp) is already type_code. The main
1585 exception is if we guessed wrong re struct/union/enum. */
1586 if (TYPE_CODE (tp
) != type_code
)
1588 complain (&bad_tag_guess_complaint
, sym_name
);
1589 TYPE_CODE (tp
) = type_code
;
1591 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1592 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1593 ¤t_objfile
->type_obstack
);
1596 if (t
->bt
== btTypedef
)
1600 /* Try to cross reference this type, it should succeed. */
1601 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1602 if (tp
== (struct type
*) NULL
)
1604 complain (&unable_to_cross_ref_complaint
, sym_name
);
1605 tp
= builtin_type_int
;
1609 /* Deal with range types */
1610 if (t
->bt
== btRange
)
1612 TYPE_NFIELDS (tp
) = 2;
1613 TYPE_FIELDS (tp
) = ((struct field
*)
1614 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1615 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1616 ¤t_objfile
->type_obstack
);
1617 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1619 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1620 ¤t_objfile
->type_obstack
);
1621 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1625 /* Parse all the type qualifiers now. If there are more
1626 than 6 the game will continue in the next aux */
1630 #define PARSE_TQ(tq) \
1631 if (t->tq != tqNil) \
1632 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1644 /* mips cc 2.x and gcc never put out continued aux entries. */
1648 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1652 /* Complain for illegal continuations due to corrupt aux entries. */
1654 complain (&bad_continued_complaint
, sym_name
);
1659 /* Make up a complex type from a basic one. Type is passed by
1660 reference in TPP and side-effected as necessary. The type
1661 qualifier TQ says how to handle the aux symbols at AX for
1662 the symbol SX we are currently analyzing. BIGEND says whether
1663 aux symbols are big-endian or little-endian.
1664 Returns the number of aux symbols we parsed. */
1667 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1678 /* Used in array processing */
1689 t
= lookup_pointer_type (*tpp
);
1694 t
= lookup_function_type (*tpp
);
1701 /* Determine and record the domain type (type of index) */
1702 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1708 rf
= AUX_GET_ISYM (bigend
, ax
);
1711 fh
= get_rfd (fd
, rf
);
1713 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1714 id
, (int *) NULL
, bigend
, sym_name
);
1716 /* The bounds type should be an integer type, but might be anything
1717 else due to corrupt aux entries. */
1718 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1720 complain (&array_index_type_complaint
, sym_name
);
1721 indx
= builtin_type_int
;
1724 /* Get the bounds, and create the array type. */
1726 lower
= AUX_GET_DNLOW (bigend
, ax
);
1728 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1730 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1732 range
= create_range_type ((struct type
*) NULL
, indx
,
1735 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1737 /* We used to fill in the supplied array element bitsize
1738 here if the TYPE_LENGTH of the target type was zero.
1739 This happens for a `pointer to an array of anonymous structs',
1740 but in this case the array element bitsize is also zero,
1741 so nothing is gained.
1742 And we used to check the TYPE_LENGTH of the target type against
1743 the supplied array element bitsize.
1744 gcc causes a mismatch for `pointer to array of object',
1745 since the sdb directives it uses do not have a way of
1746 specifying the bitsize, but it does no harm (the
1747 TYPE_LENGTH should be correct) and we should be able to
1748 ignore the erroneous bitsize from the auxiliary entry safely.
1749 dbx seems to ignore it too. */
1755 /* Volatile -- currently ignored */
1759 /* Const -- currently ignored */
1763 complain (&unknown_type_qual_complaint
, tq
);
1769 /* Parse a procedure descriptor record PR. Note that the procedure is
1770 parsed _after_ the local symbols, now we just insert the extra
1771 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1772 already been placed in the procedure's main block. Note also that
1773 images that have been partially stripped (ld -x) have been deprived
1774 of local symbols, and we have to cope with them here. FIRST_OFF is
1775 the offset of the first procedure for this FDR; we adjust the
1776 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1777 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1778 in question, or NULL to use top_stack->cur_block. */
1780 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long,
1781 struct partial_symtab
*));
1784 parse_procedure (pr
, search_symtab
, first_off
, pst
)
1786 struct symtab
*search_symtab
;
1787 unsigned long first_off
;
1788 struct partial_symtab
*pst
;
1790 struct symbol
*s
, *i
;
1792 struct mips_extra_func_info
*e
;
1795 /* Simple rule to find files linked "-x" */
1796 if (cur_fdr
->rss
== -1)
1800 /* Static procedure at address pr->adr. Sigh. */
1801 /* FIXME-32x64. assuming pr->adr fits in long. */
1802 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1810 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1811 ((char *) debug_info
->external_ext
1813 * debug_swap
->external_ext_size
)),
1815 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1823 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1824 ((char *) debug_info
->external_sym
1825 + ((cur_fdr
->isymBase
+ pr
->isym
)
1826 * debug_swap
->external_sym_size
)),
1828 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1831 if (search_symtab
!= NULL
)
1834 /* This loses both in the case mentioned (want a static, find a global),
1835 but also if we are looking up a non-mangled name which happens to
1836 match the name of a mangled function. */
1837 /* We have to save the cur_fdr across the call to lookup_symbol.
1838 If the pdr is for a static function and if a global function with
1839 the same name exists, lookup_symbol will eventually read in the symtab
1840 for the global function and clobber cur_fdr. */
1841 FDR
*save_cur_fdr
= cur_fdr
;
1842 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1843 cur_fdr
= save_cur_fdr
;
1847 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1853 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1854 VAR_NAMESPACE
, LOC_BLOCK
);
1858 b
= SYMBOL_BLOCK_VALUE (s
);
1862 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1866 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1867 s
= new_symbol (sh_name
);
1868 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1869 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1870 /* Donno its type, hope int is ok */
1871 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1872 add_symbol (s
, top_stack
->cur_block
);
1873 /* Wont have symbols for this one */
1875 SYMBOL_BLOCK_VALUE (s
) = b
;
1876 BLOCK_FUNCTION (b
) = s
;
1877 BLOCK_START (b
) = pr
->adr
;
1878 /* BOUND used to be the end of procedure's text, but the
1879 argument is no longer passed in. */
1880 BLOCK_END (b
) = bound
;
1881 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1882 add_block (b
, top_stack
->cur_st
);
1886 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1890 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1892 e
->pdr
.isym
= (long) s
;
1893 e
->pdr
.adr
+= pst
->textlow
- first_off
;
1895 /* Correct incorrect setjmp procedure descriptor from the library
1896 to make backtrace through setjmp work. */
1897 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1899 complain (&bad_setjmp_pdr_complaint
, 0);
1900 e
->pdr
.pcreg
= RA_REGNUM
;
1901 e
->pdr
.regmask
= 0x80000000;
1902 e
->pdr
.regoffset
= -4;
1906 /* It would be reasonable that functions that have been compiled
1907 without debugging info have a btNil type for their return value,
1908 and functions that are void and are compiled with debugging info
1910 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1911 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1913 The glevel field in cur_fdr could be used to determine the presence
1914 of debugging info, but GCC doesn't always pass the -g switch settings
1915 to the assembler and GAS doesn't set the glevel field from the -g switch
1917 To work around these problems, the return value type of a TYPE_CODE_VOID
1918 function is adjusted accordingly if no debugging info was found in the
1919 compilation unit. */
1921 if (processing_gcc_compilation
== 0
1922 && found_ecoff_debugging_info
== 0
1923 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
1924 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
1927 /* Relocate the extra function info pointed to by the symbol table. */
1930 ecoff_relocate_efi (sym
, delta
)
1934 struct mips_extra_func_info
*e
;
1936 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
1938 e
->pdr
.adr
+= delta
;
1941 /* Parse the external symbol ES. Just call parse_symbol() after
1942 making sure we know where the aux are for it.
1943 BIGEND says whether aux entries are big-endian or little-endian.
1945 This routine clobbers top_stack->cur_block and ->cur_st. */
1947 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
1950 parse_external (es
, bigend
, section_offsets
)
1953 struct section_offsets
*section_offsets
;
1957 if (es
->ifd
!= ifdNil
)
1960 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1961 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1965 cur_fdr
= debug_info
->fdr
;
1969 /* Reading .o files */
1970 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1973 switch (es
->asym
.st
)
1976 /* These are generated for static symbols in .o files,
1997 /* FIXME: Turn this into a complaint? */
1999 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2000 what
, debug_info
->ssext
+ es
->asym
.iss
,
2001 fdr_name (cur_fdr
));
2005 switch (es
->asym
.st
)
2009 /* There is no need to parse the external procedure symbols.
2010 If they are from objects compiled without -g, their index will
2011 be indexNil, and the symbol definition from the minimal symbol
2012 is preferrable (yielding a function returning int instead of int).
2013 If the index points to a local procedure symbol, the local
2014 symbol already provides the correct type.
2015 Note that the index of the external procedure symbol points
2016 to the local procedure symbol in the local symbol table, and
2017 _not_ to the auxiliary symbol info. */
2021 /* Global common symbols are resolved by the runtime loader,
2023 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
2026 /* Note that the case of a symbol with indexNil must be handled
2027 anyways by parse_symbol(). */
2028 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
2035 /* Parse the line number info for file descriptor FH into
2036 GDB's linetable LT. MIPS' encoding requires a little bit
2037 of magic to get things out. Note also that MIPS' line
2038 numbers can go back and forth, apparently we can live
2039 with that and do not need to reorder our linetables */
2041 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
2042 struct partial_symtab
*));
2045 parse_lines (fh
, pr
, lt
, maxlines
, pst
)
2048 struct linetable
*lt
;
2050 struct partial_symtab
*pst
;
2052 unsigned char *base
;
2054 int delta
, count
, lineno
= 0;
2055 unsigned long first_off
= pr
->adr
;
2057 if (fh
->cbLine
== 0)
2060 /* Scan by procedure descriptors */
2062 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2066 unsigned char *halt
;
2068 /* No code for this one */
2069 if (pr
->iline
== ilineNil
||
2070 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2073 /* Determine start and end address of compressed line bytes for
2075 base
= debug_info
->line
+ fh
->cbLineOffset
;
2076 if (j
!= (fh
->cpd
- 1))
2077 halt
= base
+ pr
[1].cbLineOffset
;
2079 halt
= base
+ fh
->cbLine
;
2080 base
+= pr
->cbLineOffset
;
2082 adr
= pst
->textlow
+ pr
->adr
- first_off
;
2084 l
= adr
>> 2; /* in words */
2085 for (lineno
= pr
->lnLow
; base
< halt
; )
2087 count
= *base
& 0x0f;
2088 delta
= *base
++ >> 4;
2093 delta
= (base
[0] << 8) | base
[1];
2094 if (delta
>= 0x8000)
2098 lineno
+= delta
; /* first delta is 0 */
2100 /* Complain if the line table overflows. Could happen
2101 with corrupt binaries. */
2102 if (lt
->nitems
>= maxlines
)
2104 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2107 k
= add_line (lt
, lineno
, l
, k
);
2113 /* Master parsing procedure for first-pass reading of file symbols
2114 into a partial_symtab. */
2117 parse_partial_symbols (objfile
, section_offsets
)
2118 struct objfile
*objfile
;
2119 struct section_offsets
*section_offsets
;
2121 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2122 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2123 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2124 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2125 = debug_swap
->swap_ext_in
;
2126 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2127 = debug_swap
->swap_sym_in
;
2128 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2129 = debug_swap
->swap_rfd_in
;
2131 HDRR
*hdr
= &debug_info
->symbolic_header
;
2132 /* Running pointers */
2137 register EXTR
*ext_in
;
2140 struct partial_symtab
*pst
;
2142 int past_first_source_file
= 0;
2144 /* List of current psymtab's include files */
2145 char **psymtab_include_list
;
2146 int includes_allocated
;
2149 struct pst_map
*fdr_to_pst
;
2150 /* Index within current psymtab dependency list */
2151 struct partial_symtab
**dependency_list
;
2152 int dependencies_used
, dependencies_allocated
;
2153 struct cleanup
*old_chain
;
2155 enum language prev_language
;
2156 asection
*text_sect
;
2157 int relocatable
= 0;
2159 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2160 the shared libraries are prelinked at a high memory address.
2161 We have to adjust the start address of the object file for this case,
2162 by setting it to the start address of the first procedure in the file.
2163 But we should do no adjustments if we are debugging a .o file, where
2164 the text section (and fh->adr) really starts at zero. */
2165 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2166 if (text_sect
!= NULL
2167 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2170 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2171 sizeof (EXTR
) * hdr
->iextMax
);
2173 includes_allocated
= 30;
2175 psymtab_include_list
= (char **) alloca (includes_allocated
*
2177 next_symbol_text_func
= mdebug_next_symbol_text
;
2179 dependencies_allocated
= 30;
2180 dependencies_used
= 0;
2182 (struct partial_symtab
**) alloca (dependencies_allocated
*
2183 sizeof (struct partial_symtab
*));
2185 last_source_file
= NULL
;
2190 * Only parse the Local and External symbols, and the Relative FDR.
2191 * Fixup enough of the loader symtab to be able to use it.
2192 * Allocate space only for the file's portions we need to
2197 max_glevel
= MIN_GLEVEL
;
2199 /* Allocate the map FDR -> PST.
2200 Minor hack: -O3 images might claim some global data belongs
2201 to FDR -1. We`ll go along with that */
2202 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2203 old_chain
= make_cleanup (free
, fdr_to_pst
);
2206 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2207 fdr_to_pst
[-1].pst
= pst
;
2211 /* Allocate the global pending list. */
2213 ((struct mdebug_pending
**)
2214 obstack_alloc (&objfile
->psymbol_obstack
,
2215 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2216 memset ((PTR
) pending_list
, 0,
2217 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2219 /* Pass 0 over external syms: swap them in. */
2220 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2221 make_cleanup (free
, ext_block
);
2223 ext_out
= (char *) debug_info
->external_ext
;
2224 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2226 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2227 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2229 /* Pass 1 over external syms: Presize and partition the list */
2231 ext_in_end
= ext_in
+ hdr
->iextMax
;
2232 for (; ext_in
< ext_in_end
; ext_in
++)
2234 /* See calls to complain below. */
2235 if (ext_in
->ifd
>= -1
2236 && ext_in
->ifd
< hdr
->ifdMax
2237 && ext_in
->asym
.iss
>= 0
2238 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2239 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2242 /* Pass 1.5 over files: partition out global symbol space */
2244 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2246 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2247 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2248 fdr_to_pst
[f_idx
].n_globals
= 0;
2251 /* Pass 2 over external syms: fill in external symbols */
2253 ext_in_end
= ext_in
+ hdr
->iextMax
;
2254 for (; ext_in
< ext_in_end
; ext_in
++)
2256 enum minimal_symbol_type ms_type
= mst_text
;
2257 CORE_ADDR svalue
= ext_in
->asym
.value
;
2259 /* The Irix 5 native tools seem to sometimes generate bogus
2260 external symbols. */
2261 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2263 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2266 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2268 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2273 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2274 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2276 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2279 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2280 switch (ext_in
->asym
.st
)
2283 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2286 ms_type
= mst_file_text
;
2287 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2290 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2292 /* The value of a common symbol is its size, not its address.
2296 else if (ext_in
->asym
.sc
== scData
2297 || ext_in
->asym
.sc
== scSData
2298 || ext_in
->asym
.sc
== scRData
2299 || ext_in
->asym
.sc
== scPData
2300 || ext_in
->asym
.sc
== scXData
)
2303 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2308 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2312 if (ext_in
->asym
.sc
== scAbs
)
2314 else if (ext_in
->asym
.sc
== scText
2315 || ext_in
->asym
.sc
== scInit
2316 || ext_in
->asym
.sc
== scFini
)
2318 ms_type
= mst_file_text
;
2319 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2321 else if (ext_in
->asym
.sc
== scData
2322 || ext_in
->asym
.sc
== scSData
2323 || ext_in
->asym
.sc
== scRData
2324 || ext_in
->asym
.sc
== scPData
2325 || ext_in
->asym
.sc
== scXData
)
2327 ms_type
= mst_file_data
;
2328 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2332 ms_type
= mst_file_bss
;
2333 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2337 /* The alpha has the section start addresses in stLocal symbols
2338 whose name starts with a `.'. Skip those but complain for all
2339 other stLocal symbols. */
2344 ms_type
= mst_unknown
;
2345 complain (&unknown_ext_complaint
, name
);
2347 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2350 /* Pass 3 over files, over local syms: fill in static symbols */
2351 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2353 struct partial_symtab
*save_pst
;
2357 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2361 fdr_to_pst
[f_idx
].pst
= NULL
;
2365 /* Determine the start address for this object file from the
2366 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2370 if (relocatable
|| textlow
!= 0)
2371 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2375 pst
= start_psymtab_common (objfile
, section_offsets
,
2378 objfile
->global_psymbols
.next
,
2379 objfile
->static_psymbols
.next
);
2380 pst
->read_symtab_private
= ((char *)
2381 obstack_alloc (&objfile
->psymbol_obstack
,
2382 sizeof (struct symloc
)));
2383 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2386 FDR_IDX (pst
) = f_idx
;
2387 CUR_BFD (pst
) = cur_bfd
;
2388 DEBUG_SWAP (pst
) = debug_swap
;
2389 DEBUG_INFO (pst
) = debug_info
;
2390 PENDING_LIST (pst
) = pending_list
;
2392 /* The way to turn this into a symtab is to call... */
2393 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2395 /* Set up language for the pst.
2396 The language from the FDR is used if it is unambigious (e.g. cfront
2397 with native cc and g++ will set the language to C).
2398 Otherwise we have to deduce the language from the filename.
2399 Native ecoff has every header file in a separate FDR, so
2400 deduce_language_from_filename will return language_unknown for
2401 a header file, which is not what we want.
2402 But the FDRs for the header files are after the FDR for the source
2403 file, so we can assign the language of the source file to the
2404 following header files. Then we save the language in the private
2405 pst data so that we can reuse it when building symtabs. */
2406 prev_language
= psymtab_language
;
2410 case langCplusplusV2
:
2411 psymtab_language
= language_cplus
;
2414 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2417 if (psymtab_language
== language_unknown
)
2418 psymtab_language
= prev_language
;
2419 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2421 pst
->texthigh
= pst
->textlow
;
2423 /* For stabs-in-ecoff files, the second symbol must be @stab.
2424 This symbol is emitted by mips-tfile to signal that the
2425 current object file uses encapsulated stabs instead of mips
2426 ecoff for local symbols. (It is the second symbol because
2427 the first symbol is the stFile used to signal the start of a
2429 processing_gcc_compilation
= 0;
2432 (*swap_sym_in
) (cur_bfd
,
2433 ((char *) debug_info
->external_sym
2434 + (fh
->isymBase
+ 1) * external_sym_size
),
2436 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2437 processing_gcc_compilation
= 2;
2440 if (processing_gcc_compilation
!= 0)
2442 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2447 (*swap_sym_in
) (cur_bfd
,
2448 (((char *) debug_info
->external_sym
)
2449 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2451 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2452 if (!ECOFF_IS_STAB (&sh
))
2454 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2459 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2460 if (sh
.st
== stStaticProc
)
2462 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2463 prim_record_minimal_symbol_and_info (namestring
,
2470 procaddr
= sh
.value
;
2472 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2473 (debug_info
->external_aux
2476 (*swap_sym_in
) (cur_bfd
,
2477 ((char *) debug_info
->external_sym
2478 + ((fh
->isymBase
+ isym
- 1)
2479 * external_sym_size
)),
2483 long high
= procaddr
+ sh
.value
;
2485 /* Kludge for Irix 5.2 zero fh->adr. */
2487 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2488 pst
->textlow
= procaddr
;
2489 if (high
> pst
->texthigh
)
2490 pst
->texthigh
= high
;
2493 else if (sh
.st
== stStatic
)
2507 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2508 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2509 prim_record_minimal_symbol_and_info (namestring
,
2518 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2519 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2520 prim_record_minimal_symbol_and_info (namestring
,
2531 #define SET_NAMESTRING() \
2532 namestring = debug_info->ss + fh->issBase + sh.iss
2533 #define CUR_SYMBOL_TYPE type_code
2534 #define CUR_SYMBOL_VALUE sh.value
2535 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2537 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2538 #define HANDLE_RBRAC(val) \
2539 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2540 #include "partial-stab.h"
2545 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2548 enum address_class
class;
2550 (*swap_sym_in
) (cur_bfd
,
2551 ((char *) debug_info
->external_sym
2552 + ((fh
->isymBase
+ cur_sdx
)
2553 * external_sym_size
)),
2556 if (ECOFF_IS_STAB (&sh
))
2562 /* Non absolute static symbols go into the minimal table. */
2563 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2564 || (sh
.index
== indexNil
2565 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2567 /* FIXME, premature? */
2572 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2577 /* The value of a stEnd symbol is the displacement from the
2578 corresponding start symbol value, do not relocate it. */
2580 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2587 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2591 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2602 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2603 mst_file_text
, NULL
,
2604 SECT_OFF_TEXT
, objfile
);
2609 /* Usually there is a local and a global stProc symbol
2610 for a function. This means that the function name
2611 has already been entered into the mimimal symbol table
2612 while processing the global symbols in pass 2 above.
2613 One notable exception is the PROGRAM name from
2614 f77 compiled executables, it is only put out as
2615 local stProc symbol, and a global MAIN__ stProc symbol
2616 points to it. It doesn't matter though, as gdb is
2617 still able to find the PROGRAM name via the partial
2618 symbol table, and the MAIN__ symbol via the minimal
2620 if (sh
.st
== stProc
)
2621 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2622 VAR_NAMESPACE
, LOC_BLOCK
,
2623 objfile
->global_psymbols
,
2624 sh
.value
, psymtab_language
, objfile
);
2626 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2627 VAR_NAMESPACE
, LOC_BLOCK
,
2628 objfile
->static_psymbols
,
2629 sh
.value
, psymtab_language
, objfile
);
2631 /* Skip over procedure to next one. */
2632 if (sh
.index
>= hdr
->iauxMax
)
2634 /* Should not happen, but does when cross-compiling
2635 with the MIPS compiler. FIXME -- pull later. */
2636 complain (&index_complaint
, name
);
2637 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2640 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2641 (debug_info
->external_aux
2644 procaddr
= sh
.value
;
2646 if (new_sdx
<= cur_sdx
)
2648 /* This should not happen either... FIXME. */
2649 complain (&aux_index_complaint
, name
);
2650 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2654 (*swap_sym_in
) (cur_bfd
,
2655 ((char *) debug_info
->external_sym
2656 + ((fh
->isymBase
+ cur_sdx
- 1)
2657 * external_sym_size
)),
2662 /* Kludge for Irix 5.2 zero fh->adr. */
2664 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2665 pst
->textlow
= procaddr
;
2667 high
= procaddr
+ sh
.value
;
2668 if (high
> pst
->texthigh
)
2669 pst
->texthigh
= high
;
2672 case stStatic
: /* Variable */
2677 || sh
.sc
== scXData
)
2678 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2679 mst_file_data
, NULL
,
2683 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2690 case stIndirect
:/* Irix5 forward declaration */
2691 /* Skip forward declarations from Irix5 cc */
2694 case stTypedef
:/* Typedef */
2695 /* Skip typedefs for forward declarations and opaque
2696 structs from alpha and mips cc. */
2697 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2699 class = LOC_TYPEDEF
;
2702 case stConstant
: /* Constant decl */
2709 case stBlock
: /* { }, str, un, enum*/
2710 /* Do not create a partial symbol for cc unnamed aggregates
2711 and gcc empty aggregates. */
2712 if ((sh
.sc
== scInfo
2713 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2715 && sh
.index
!= cur_sdx
+ 2)
2717 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2718 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2719 objfile
->static_psymbols
,
2721 psymtab_language
, objfile
);
2723 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2725 /* Skip over the block */
2727 if (new_sdx
<= cur_sdx
)
2729 /* This happens with the Ultrix kernel. */
2730 complain (&block_index_complaint
, name
);
2731 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2736 case stFile
: /* File headers */
2737 case stLabel
: /* Labels */
2738 case stEnd
: /* Ends of files */
2741 case stLocal
: /* Local variables */
2742 /* Normally these are skipped because we skip over
2743 all blocks we see. However, these can occur
2744 as visible symbols in a .h file that contains code. */
2748 /* Both complaints are valid: one gives symbol name,
2749 the other the offending symbol type. */
2750 complain (&unknown_sym_complaint
, name
);
2751 complain (&unknown_st_complaint
, sh
.st
);
2755 /* Use this gdb symbol */
2756 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2757 VAR_NAMESPACE
, class,
2758 objfile
->static_psymbols
, sh
.value
,
2759 psymtab_language
, objfile
);
2761 cur_sdx
++; /* Go to next file symbol */
2764 /* Now do enter the external symbols. */
2765 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2766 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2767 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2768 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2769 for (; --cur_sdx
>= 0; ext_ptr
++)
2771 enum address_class
class;
2776 if (ext_ptr
->ifd
!= f_idx
)
2778 psh
= &ext_ptr
->asym
;
2780 /* Do not add undefined symbols to the partial symbol table. */
2781 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2784 svalue
= psh
->value
;
2788 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2795 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2799 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2806 /* These are generated for static symbols in .o files,
2811 /* External procedure symbols have been entered
2812 into the minimal symbol table in pass 2 above.
2813 Ignore them, as parse_external will ignore them too. */
2819 complain (&unknown_ext_complaint
,
2820 debug_info
->ssext
+ psh
->iss
);
2821 /* Fall through, pretend it's global. */
2823 /* Global common symbols are resolved by the runtime loader,
2825 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2831 name
= debug_info
->ssext
+ psh
->iss
;
2832 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2833 VAR_NAMESPACE
, class,
2834 objfile
->global_psymbols
,
2836 psymtab_language
, objfile
);
2840 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2841 empty and put on the free list. */
2842 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2843 psymtab_include_list
, includes_used
,
2844 -1, save_pst
->texthigh
,
2845 dependency_list
, dependencies_used
);
2846 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2847 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2849 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2850 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2853 /* The objfile has its functions reordered if this partial symbol
2854 table overlaps any other partial symbol table.
2855 We cannot assume a reordered objfile if a partial symbol table
2856 is contained within another partial symbol table, as partial symbol
2857 tables for include files with executable code are contained
2858 within the partial symbol table for the including source file,
2859 and we do not want to flag the objfile reordered for these cases.
2861 This strategy works well for Irix-5.2 shared libraries, but we
2862 might have to use a more elaborate (and slower) algorithm for
2864 save_pst
= fdr_to_pst
[f_idx
].pst
;
2865 if (save_pst
!= NULL
2866 && save_pst
->textlow
!= 0
2867 && !(objfile
->flags
& OBJF_REORDERED
))
2869 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
2872 && save_pst
->textlow
>= pst
->textlow
2873 && save_pst
->textlow
< pst
->texthigh
2874 && save_pst
->texthigh
> pst
->texthigh
)
2876 objfile
->flags
|= OBJF_REORDERED
;
2883 /* Now scan the FDRs for dependencies */
2884 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2886 fh
= f_idx
+ debug_info
->fdr
;
2887 pst
= fdr_to_pst
[f_idx
].pst
;
2889 if (pst
== (struct partial_symtab
*)NULL
)
2892 /* This should catch stabs-in-ecoff. */
2896 /* Skip the first file indirect entry as it is a self dependency
2897 for source files or a reverse .h -> .c dependency for header files. */
2898 pst
->number_of_dependencies
= 0;
2900 ((struct partial_symtab
**)
2901 obstack_alloc (&objfile
->psymbol_obstack
,
2903 * sizeof (struct partial_symtab
*))));
2904 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2908 (*swap_rfd_in
) (cur_bfd
,
2909 ((char *) debug_info
->external_rfd
2910 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2912 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2914 complain (&bad_file_number_complaint
, rh
);
2918 /* Skip self dependencies of header files. */
2922 /* Do not add to dependeny list if psymtab was empty. */
2923 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2925 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2929 /* Remove the dummy psymtab created for -O3 images above, if it is
2930 still empty, to enable the detection of stripped executables. */
2931 if (objfile
->psymtabs
->next
== NULL
2932 && objfile
->psymtabs
->number_of_dependencies
== 0
2933 && objfile
->psymtabs
->n_global_syms
== 0
2934 && objfile
->psymtabs
->n_static_syms
== 0)
2935 objfile
->psymtabs
= NULL
;
2936 do_cleanups (old_chain
);
2939 /* If the current psymbol has an enumerated type, we need to add
2940 all the the enum constants to the partial symbol table. */
2943 handle_psymbol_enumerators (objfile
, fh
, stype
)
2944 struct objfile
*objfile
;
2948 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2949 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2950 = debug_swap
->swap_sym_in
;
2951 char *ext_sym
= ((char *) debug_info
->external_sym
2952 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2962 /* It is an enumerated type if the next symbol entry is a stMember
2963 and its auxiliary index is indexNil or its auxiliary entry
2964 is a plain btNil or btVoid. */
2965 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2966 if (sh
.st
!= stMember
)
2969 if (sh
.index
== indexNil
)
2971 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
2972 &(debug_info
->external_aux
2973 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2975 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2987 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2988 if (sh
.st
!= stMember
)
2990 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2992 /* Note that the value doesn't matter for enum constants
2993 in psymtabs, just in symtabs. */
2994 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2995 VAR_NAMESPACE
, LOC_CONST
,
2996 objfile
->static_psymbols
, 0,
2997 psymtab_language
, objfile
);
2998 ext_sym
+= external_sym_size
;
3003 mdebug_next_symbol_text ()
3008 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3009 ((char *) debug_info
->external_sym
3010 + ((cur_fdr
->isymBase
+ cur_sdx
)
3011 * debug_swap
->external_sym_size
)),
3013 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3016 /* Ancillary function to psymtab_to_symtab(). Does all the work
3017 for turning the partial symtab PST into a symtab, recurring
3018 first on all dependent psymtabs. The argument FILENAME is
3019 only passed so we can see in debug stack traces what file
3022 This function has a split personality, based on whether the
3023 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3024 The flow of control and even the memory allocation differs. FIXME. */
3027 psymtab_to_symtab_1 (pst
, filename
)
3028 struct partial_symtab
*pst
;
3031 bfd_size_type external_sym_size
;
3032 bfd_size_type external_pdr_size
;
3033 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
3034 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
3038 struct linetable
*lines
;
3044 /* Read in all partial symbtabs on which this one is dependent.
3045 NOTE that we do have circular dependencies, sigh. We solved
3046 that by setting pst->readin before this point. */
3048 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3049 if (!pst
->dependencies
[i
]->readin
)
3051 /* Inform about additional files to be read in. */
3054 fputs_filtered (" ", gdb_stdout
);
3056 fputs_filtered ("and ", gdb_stdout
);
3058 printf_filtered ("%s...",
3059 pst
->dependencies
[i
]->filename
);
3060 wrap_here (""); /* Flush output */
3061 gdb_flush (gdb_stdout
);
3063 /* We only pass the filename for debug purposes */
3064 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3065 pst
->dependencies
[i
]->filename
);
3068 /* Do nothing if this is a dummy psymtab. */
3070 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3071 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3074 /* Now read the symbols for this symtab */
3076 cur_bfd
= CUR_BFD (pst
);
3077 debug_swap
= DEBUG_SWAP (pst
);
3078 debug_info
= DEBUG_INFO (pst
);
3079 pending_list
= PENDING_LIST (pst
);
3080 external_sym_size
= debug_swap
->external_sym_size
;
3081 external_pdr_size
= debug_swap
->external_pdr_size
;
3082 swap_sym_in
= debug_swap
->swap_sym_in
;
3083 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3084 current_objfile
= pst
->objfile
;
3085 cur_fd
= FDR_IDX (pst
);
3086 fh
= ((cur_fd
== -1)
3088 : debug_info
->fdr
+ cur_fd
);
3091 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3092 processing_gcc_compilation
= 0;
3093 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3097 (*swap_sym_in
) (cur_bfd
,
3098 ((char *) debug_info
->external_sym
3099 + (fh
->isymBase
+ 1) * external_sym_size
),
3101 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3104 /* We indicate that this is a GCC compilation so that certain
3105 features will be enabled in stabsread/dbxread. */
3106 processing_gcc_compilation
= 2;
3110 if (processing_gcc_compilation
!= 0)
3115 unsigned long first_off
= 0;
3117 /* This symbol table contains stabs-in-ecoff entries. */
3119 /* Parse local symbols first */
3121 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3123 current_objfile
= NULL
;
3126 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3132 (*swap_sym_in
) (cur_bfd
,
3133 (((char *) debug_info
->external_sym
)
3134 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3136 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3138 if (ECOFF_IS_STAB (&sh
))
3140 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3142 /* We should never get non N_STAB symbols here, but they
3143 should be harmless, so keep process_one_symbol from
3144 complaining about them. */
3145 if (type_code
& N_STAB
)
3147 process_one_symbol (type_code
, 0, valu
, name
,
3148 pst
->section_offsets
, pst
->objfile
);
3150 if (type_code
== N_FUN
)
3152 /* Make up special symbol to contain
3153 procedure specific info */
3154 struct mips_extra_func_info
*e
=
3155 ((struct mips_extra_func_info
*)
3156 obstack_alloc (¤t_objfile
->symbol_obstack
,
3157 sizeof (struct mips_extra_func_info
)));
3158 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3160 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
3161 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3162 SYMBOL_CLASS (s
) = LOC_CONST
;
3163 SYMBOL_TYPE (s
) = builtin_type_void
;
3164 SYMBOL_VALUE (s
) = (long) e
;
3165 e
->pdr
.framereg
= -1;
3166 add_symbol_to_list (s
, &local_symbols
);
3169 else if (sh
.st
== stLabel
)
3171 if (sh
.index
== indexNil
)
3173 /* This is what the gcc2_compiled and __gnu_compiled_*
3174 show up as. So don't complain. */
3178 /* Handle encoded stab line number. */
3179 record_line (current_subfile
, sh
.index
, valu
);
3181 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3182 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3183 /* These are generated by gcc-2.x, do not complain */
3186 complain (&stab_unknown_complaint
, name
);
3188 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
3191 /* Sort the symbol table now, we are done adding symbols to it.
3192 We must do this before parse_procedure calls lookup_symbol. */
3193 sort_symtab_syms (st
);
3195 /* There used to be a call to sort_blocks here, but this should not
3196 be necessary for stabs symtabs. And as sort_blocks modifies the
3197 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3198 it did the wrong thing if the first procedure in a file was
3199 generated via asm statements. */
3201 /* Fill in procedure info next. */
3203 pdr_ptr
= ((char *) debug_info
->external_pdr
3204 + fh
->ipdFirst
* external_pdr_size
);
3205 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3206 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
3210 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
3216 parse_procedure (&pr
, st
, first_off
, pst
);
3221 /* This symbol table contains ordinary ecoff entries. */
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
);