1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 1997
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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"
54 /* These are needed if the tm.h file does not contain the necessary
55 mips specific definitions. */
57 #ifndef MIPS_EFI_SYMBOL_NAME
58 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
59 extern void ecoff_relocate_efi
PARAMS ((struct symbol
*, CORE_ADDR
));
61 #include "coff/symconst.h"
62 typedef struct mips_extra_func_info
{
65 } *mips_extra_func_info_t
;
72 #include <sys/types.h>
76 #include "gdb_string.h"
78 #include "gdb-stabs.h"
82 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
84 #include "libaout.h" /* Private BFD a.out information. */
85 #include "aout/aout64.h"
86 #include "aout/stab_gnu.h" /* STABS information */
88 #include "expression.h"
89 #include "language.h" /* Needed inside partial-stab.h */
91 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
92 #ifndef ECOFF_REG_TO_REGNUM
93 #define ECOFF_REG_TO_REGNUM(num) (num)
96 /* We put a pointer to this structure in the read_symtab_private field
101 /* Index of the FDR that this psymtab represents. */
103 /* The BFD that the psymtab was created from. */
105 const struct ecoff_debug_swap
*debug_swap
;
106 struct ecoff_debug_info
*debug_info
;
107 struct mdebug_pending
**pending_list
;
108 /* Pointer to external symbols for this file. */
110 /* Size of extern_tab. */
112 enum language pst_language
;
115 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
116 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
117 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
118 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
119 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
120 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
122 /* Things we import explicitly from other modules */
124 extern int info_verbose
;
126 /* Various complaints about symbol reading that don't abort the process */
128 static struct complaint bad_file_number_complaint
=
129 {"bad file number %d", 0, 0};
131 static struct complaint index_complaint
=
132 {"bad aux index at symbol %s", 0, 0};
134 static struct complaint aux_index_complaint
=
135 {"bad proc end in aux found from symbol %s", 0, 0};
137 static struct complaint block_index_complaint
=
138 {"bad aux index at block symbol %s", 0, 0};
140 static struct complaint unknown_ext_complaint
=
141 {"unknown external symbol %s", 0, 0};
143 static struct complaint unknown_sym_complaint
=
144 {"unknown local symbol %s", 0, 0};
146 static struct complaint unknown_st_complaint
=
147 {"with type %d", 0, 0};
149 static struct complaint block_overflow_complaint
=
150 {"block containing %s overfilled", 0, 0};
152 static struct complaint basic_type_complaint
=
153 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
155 static struct complaint unknown_type_qual_complaint
=
156 {"unknown type qualifier 0x%x", 0, 0};
158 static struct complaint array_index_type_complaint
=
159 {"illegal array index type for %s, assuming int", 0, 0};
161 static struct complaint bad_tag_guess_complaint
=
162 {"guessed tag type of %s incorrectly", 0, 0};
164 static struct complaint block_member_complaint
=
165 {"declaration block contains unhandled symbol type %d", 0, 0};
167 static struct complaint stEnd_complaint
=
168 {"stEnd with storage class %d not handled", 0, 0};
170 static struct complaint unknown_mdebug_symtype_complaint
=
171 {"unknown symbol type 0x%x", 0, 0};
173 static struct complaint stab_unknown_complaint
=
174 {"unknown stabs symbol %s", 0, 0};
176 static struct complaint pdr_for_nonsymbol_complaint
=
177 {"PDR for %s, but no symbol", 0, 0};
179 static struct complaint pdr_static_symbol_complaint
=
180 {"can't handle PDR for static proc at 0x%lx", 0, 0};
182 static struct complaint bad_setjmp_pdr_complaint
=
183 {"fixing bad setjmp PDR from libc", 0, 0};
185 static struct complaint bad_fbitfield_complaint
=
186 {"can't handle TIR fBitfield for %s", 0, 0};
188 static struct complaint bad_continued_complaint
=
189 {"illegal TIR continued for %s", 0, 0};
191 static struct complaint bad_rfd_entry_complaint
=
192 {"bad rfd entry for %s: file %d, index %d", 0, 0};
194 static struct complaint unexpected_type_code_complaint
=
195 {"unexpected type code for %s", 0, 0};
197 static struct complaint unable_to_cross_ref_complaint
=
198 {"unable to cross ref btTypedef for %s", 0, 0};
200 static struct complaint bad_indirect_xref_complaint
=
201 {"unable to cross ref btIndirect for %s", 0, 0};
203 static struct complaint illegal_forward_tq0_complaint
=
204 {"illegal tq0 in forward typedef for %s", 0, 0};
206 static struct complaint illegal_forward_bt_complaint
=
207 {"illegal bt %d in forward typedef for %s", 0, 0};
209 static struct complaint bad_linetable_guess_complaint
=
210 {"guessed size of linetable for %s incorrectly", 0, 0};
212 static struct complaint bad_ext_ifd_complaint
=
213 {"bad ifd for external symbol: %d (max %d)", 0, 0};
215 static struct complaint bad_ext_iss_complaint
=
216 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
218 /* Macros and extra defs */
220 /* Puns: hard to find whether -g was used and how */
222 #define MIN_GLEVEL GLEVEL_0
223 #define compare_glevel(a,b) \
224 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
225 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
227 /* Things that really are local to this module */
229 /* Remember what we deduced to be the source language of this psymtab. */
231 static enum language psymtab_language
= language_unknown
;
237 /* How to parse debugging information for CUR_BFD. */
239 static const struct ecoff_debug_swap
*debug_swap
;
241 /* Pointers to debugging information for CUR_BFD. */
243 static struct ecoff_debug_info
*debug_info
;
245 /* Pointer to current file decriptor record, and its index */
250 /* Index of current symbol */
254 /* Note how much "debuggable" this image is. We would like
255 to see at least one FDR with full symbols */
257 static int max_gdbinfo
;
258 static int max_glevel
;
260 /* When examining .o files, report on undefined symbols */
262 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
264 /* Pseudo symbol to use when putting stabs into the symbol table. */
266 static char stabs_symbol
[] = STABS_SYMBOL
;
268 /* Types corresponding to mdebug format bt* basic types. */
270 static struct type
*mdebug_type_void
;
271 static struct type
*mdebug_type_char
;
272 static struct type
*mdebug_type_short
;
273 static struct type
*mdebug_type_int_32
;
274 #define mdebug_type_int mdebug_type_int_32
275 static struct type
*mdebug_type_int_64
;
276 static struct type
*mdebug_type_long_32
;
277 static struct type
*mdebug_type_long_64
;
278 static struct type
*mdebug_type_long_long_64
;
279 static struct type
*mdebug_type_unsigned_char
;
280 static struct type
*mdebug_type_unsigned_short
;
281 static struct type
*mdebug_type_unsigned_int_32
;
282 static struct type
*mdebug_type_unsigned_int_64
;
283 static struct type
*mdebug_type_unsigned_long_32
;
284 static struct type
*mdebug_type_unsigned_long_64
;
285 static struct type
*mdebug_type_unsigned_long_long_64
;
286 static struct type
*mdebug_type_adr_32
;
287 static struct type
*mdebug_type_adr_64
;
288 static struct type
*mdebug_type_float
;
289 static struct type
*mdebug_type_double
;
290 static struct type
*mdebug_type_complex
;
291 static struct type
*mdebug_type_double_complex
;
292 static struct type
*mdebug_type_fixed_dec
;
293 static struct type
*mdebug_type_float_dec
;
294 static struct type
*mdebug_type_string
;
296 /* Types for symbols from files compiled without debugging info. */
298 static struct type
*nodebug_func_symbol_type
;
299 static struct type
*nodebug_var_symbol_type
;
301 /* Nonzero if we have seen ecoff debugging info for a file. */
303 static int found_ecoff_debugging_info
;
305 /* Forward declarations */
308 add_pending
PARAMS ((FDR
*, char *, struct type
*));
310 static struct mdebug_pending
*
311 is_pending_symbol
PARAMS ((FDR
*, char *));
314 pop_parse_stack
PARAMS ((void));
317 push_parse_stack
PARAMS ((void));
320 fdr_name
PARAMS ((FDR
*));
323 mdebug_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
326 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
329 parse_partial_symbols
PARAMS ((struct objfile
*,
330 struct section_offsets
*));
333 *get_rfd
PARAMS ((int, int));
336 has_opaque_xref
PARAMS ((FDR
*, SYMR
*));
339 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
340 char **, int, char *));
342 static struct symbol
*
343 new_symbol
PARAMS ((char *));
346 new_type
PARAMS ((char *));
348 static struct block
*
349 new_block
PARAMS ((int));
351 static struct symtab
*
352 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
354 static struct linetable
*
355 new_linetable
PARAMS ((int));
357 static struct blockvector
*
358 new_bvect
PARAMS ((int));
361 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int, struct section_offsets
*));
364 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
366 static struct symbol
*
367 mylookup_symbol
PARAMS ((char *, struct block
*, namespace_enum
,
368 enum address_class
));
370 static struct block
*
371 shrink_block
PARAMS ((struct block
*, struct symtab
*));
374 xzalloc
PARAMS ((unsigned int));
377 sort_blocks
PARAMS ((struct symtab
*));
380 compare_blocks
PARAMS ((const void *, const void *));
382 static struct partial_symtab
*
383 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
386 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
389 add_block
PARAMS ((struct block
*, struct symtab
*));
392 add_symbol
PARAMS ((struct symbol
*, struct block
*));
395 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
397 static struct linetable
*
398 shrink_linetable
PARAMS ((struct linetable
*));
401 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int, CORE_ADDR
));
404 mdebug_next_symbol_text
PARAMS ((struct objfile
*));
406 /* Address bounds for the signal trampoline in inferior, if any */
408 CORE_ADDR sigtramp_address
, sigtramp_end
;
410 /* Allocate zeroed memory */
416 PTR p
= xmalloc (size
);
422 /* Exported procedure: Builds a symtab from the PST partial one.
423 Restores the environment in effect when PST was created, delegates
424 most of the work to an ancillary procedure, and sorts
425 and reorders the symtab list at the end */
428 mdebug_psymtab_to_symtab (pst
)
429 struct partial_symtab
*pst
;
437 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
438 gdb_flush (gdb_stdout
);
441 next_symbol_text_func
= mdebug_next_symbol_text
;
443 psymtab_to_symtab_1 (pst
, pst
->filename
);
445 /* Match with global symbols. This only needs to be done once,
446 after all of the symtabs and dependencies have been read in. */
447 scan_file_globals (pst
->objfile
);
450 printf_filtered ("done.\n");
453 /* File-level interface functions */
455 /* Find a file descriptor given its index RF relative to a file CF */
465 fdrs
= debug_info
->fdr
;
467 /* Object files do not have the RFD table, all refs are absolute */
470 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
471 ((char *) debug_info
->external_rfd
473 * debug_swap
->external_rfd_size
)),
478 /* Return a safer print NAME for a file descriptor */
485 return "<stripped file>";
488 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
492 /* Read in and parse the symtab of the file OBJFILE. Symbols from
493 different sections are relocated via the SECTION_OFFSETS. */
496 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
497 struct objfile
*objfile
;
498 const struct ecoff_debug_swap
*swap
;
499 struct ecoff_debug_info
*info
;
500 struct section_offsets
*section_offsets
;
502 cur_bfd
= objfile
->obfd
;
506 /* Make sure all the FDR information is swapped in. */
507 if (info
->fdr
== (FDR
*) NULL
)
513 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
514 (info
->symbolic_header
.ifdMax
516 fdr_src
= info
->external_fdr
;
518 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
520 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
521 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
524 parse_partial_symbols (objfile
, section_offsets
);
527 /* Check to make sure file was compiled with -g. If not, warn the
528 user of this limitation. */
529 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
531 if (max_gdbinfo
== 0)
532 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
534 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
535 gdb_flush (gdb_stdout
);
540 /* Local utilities */
542 /* Map of FDR indexes to partial symtabs */
546 struct partial_symtab
*pst
; /* the psymtab proper */
547 long n_globals
; /* exported globals (external symbols) */
548 long globals_offset
; /* cumulative */
552 /* Utility stack, used to nest procedures and blocks properly.
553 It is a doubly linked list, to avoid too many alloc/free.
554 Since we might need it quite a few times it is NOT deallocated
557 static struct parse_stack
559 struct parse_stack
*next
, *prev
;
560 struct symtab
*cur_st
; /* Current symtab. */
561 struct block
*cur_block
; /* Block in it. */
563 /* What are we parsing. stFile, or stBlock are for files and
564 blocks. stProc or stStaticProc means we have seen the start of a
565 procedure, but not the start of the block within in. When we see
566 the start of that block, we change it to stNil, without pushing a
567 new block, i.e. stNil means both a procedure and a block. */
571 int maxsyms
; /* Max symbols in this block. */
572 struct type
*cur_type
; /* Type we parse fields for. */
573 int cur_field
; /* Field number in cur_type. */
574 CORE_ADDR procadr
; /* Start addres of this procedure */
575 int numargs
; /* Its argument count */
578 *top_stack
; /* Top stack ptr */
581 /* Enter a new lexical context */
586 struct parse_stack
*new;
588 /* Reuse frames if possible */
589 if (top_stack
&& top_stack
->prev
)
590 new = top_stack
->prev
;
592 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
593 /* Initialize new frame with previous content */
596 register struct parse_stack
*prev
= new->prev
;
599 top_stack
->prev
= new;
601 new->next
= top_stack
;
606 /* Exit a lexical context */
614 top_stack
= top_stack
->next
;
618 /* Cross-references might be to things we haven't looked at
619 yet, e.g. type references. To avoid too many type
620 duplications we keep a quick fixup table, an array
621 of lists of references indexed by file descriptor */
623 struct mdebug_pending
625 struct mdebug_pending
*next
; /* link */
626 char *s
; /* the unswapped symbol */
627 struct type
*t
; /* its partial type descriptor */
631 /* The pending information is kept for an entire object file, and used
632 to be in the sym_private field. I took it out when I split
633 mdebugread from mipsread, because this might not be the only type
634 of symbols read from an object file. Instead, we allocate the
635 pending information table when we create the partial symbols, and
636 we store a pointer to the single table in each psymtab. */
638 static struct mdebug_pending
**pending_list
;
640 /* Check whether we already saw symbol SH in file FH */
642 static struct mdebug_pending
*
643 is_pending_symbol (fh
, sh
)
647 int f_idx
= fh
- debug_info
->fdr
;
648 register struct mdebug_pending
*p
;
650 /* Linear search is ok, list is typically no more than 10 deep */
651 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
657 /* Add a new symbol SH of type T */
660 add_pending (fh
, sh
, t
)
665 int f_idx
= fh
- debug_info
->fdr
;
666 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
668 /* Make sure we do not make duplicates */
671 p
= ((struct mdebug_pending
*)
672 obstack_alloc (¤t_objfile
->psymbol_obstack
,
673 sizeof (struct mdebug_pending
)));
676 p
->next
= pending_list
[f_idx
];
677 pending_list
[f_idx
] = p
;
682 /* Parsing Routines proper. */
684 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
685 For blocks, procedures and types we open a new lexical context.
686 This is basically just a big switch on the symbol's type. Argument
687 AX is the base pointer of aux symbols for this file (fh->iauxBase).
688 EXT_SH points to the unswapped symbol, which is needed for struct,
689 union, etc., types; it is NULL for an EXTR. BIGEND says whether
690 aux symbols are big-endian or little-endian. Return count of
691 SYMR's handled (normally one). */
694 parse_symbol (sh
, ax
, ext_sh
, bigend
, section_offsets
)
699 struct section_offsets
*section_offsets
;
701 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
702 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
703 debug_swap
->swap_sym_in
;
707 struct mdebug_pending
*pend
;
711 enum address_class
class;
713 long svalue
= sh
->value
;
716 if (ext_sh
== (char *) NULL
)
717 name
= debug_info
->ssext
+ sh
->iss
;
719 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
725 /* Do not relocate relative values.
726 The value of a stEnd symbol is the displacement from the
727 corresponding start symbol value.
728 The value of a stBlock symbol is the displacement from the
729 procedure address. */
730 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
731 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
738 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
742 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
751 case stGlobal
: /* external symbol, goes into global block */
753 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
755 s
= new_symbol (name
);
756 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
759 case stStatic
: /* static data, goes into current block. */
761 b
= top_stack
->cur_block
;
762 s
= new_symbol (name
);
763 if (sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
765 /* It is a FORTRAN common block. At least for SGI Fortran the
766 address is not in the symbol; we need to fix it later in
767 scan_file_globals. */
768 int bucket
= hashname (SYMBOL_NAME (s
));
769 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
770 global_sym_chain
[bucket
] = s
;
773 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
776 case stLocal
: /* local variable, goes into current block */
777 if (sh
->sc
== scRegister
)
779 class = LOC_REGISTER
;
780 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
784 b
= top_stack
->cur_block
;
785 s
= new_symbol (name
);
786 SYMBOL_VALUE (s
) = svalue
;
788 data
: /* Common code for symbols describing data */
789 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
790 SYMBOL_CLASS (s
) = class;
793 /* Type could be missing if file is compiled without debugging info. */
794 if (sh
->sc
== scUndefined
|| sh
->sc
== scSUndefined
795 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
796 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
798 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
799 /* Value of a data symbol is its memory address */
802 case stParam
: /* arg to procedure, goes into current block */
804 found_ecoff_debugging_info
= 1;
805 top_stack
->numargs
++;
807 /* Special GNU C++ name. */
808 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
809 name
= "this"; /* FIXME, not alloc'd in obstack */
810 s
= new_symbol (name
);
812 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
816 /* Pass by value in register. */
817 SYMBOL_CLASS(s
) = LOC_REGPARM
;
818 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
821 /* Pass by reference on stack. */
822 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
825 /* Pass by reference in register. */
826 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
827 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
830 /* Pass by value on stack. */
831 SYMBOL_CLASS(s
) = LOC_ARG
;
834 SYMBOL_VALUE (s
) = svalue
;
835 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
836 add_symbol (s
, top_stack
->cur_block
);
839 case stLabel
: /* label, goes into current block */
840 s
= new_symbol (name
);
841 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
842 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
843 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
844 SYMBOL_TYPE (s
) = mdebug_type_int
;
845 add_symbol (s
, top_stack
->cur_block
);
848 case stProc
: /* Procedure, usually goes into global block */
849 case stStaticProc
: /* Static procedure, goes into current block */
850 s
= new_symbol (name
);
851 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
852 SYMBOL_CLASS (s
) = LOC_BLOCK
;
853 /* Type of the return value */
854 if (sh
->sc
== scUndefined
|| sh
->sc
== scSUndefined
|| sh
->sc
== scNil
)
858 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
859 if (STREQ(name
, "malloc") && t
->code
== TYPE_CODE_VOID
)
861 /* I don't know why, but, at least under Linux/Alpha,
862 when linking against a malloc without debugging
863 symbols, its read as a function returning void---this
864 is bad because it means we cannot call functions with
865 string arguments interactively; i.e., "call
866 printf("howdy\n")" would fail with the error message
867 "program has no memory available". To avoid this, we
868 patch up the type and make it void*
869 instead. (davidm@azstarnet.com)
871 t
= make_pointer_type (t
, NULL
);
874 b
= top_stack
->cur_block
;
875 if (sh
->st
== stProc
)
877 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
878 /* The next test should normally be true, but provides a
879 hook for nested functions (which we don't want to make
881 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
882 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
883 /* Irix 5 sometimes has duplicate names for the same
884 function. We want to add such names up at the global
885 level, not as a nested function. */
886 else if (sh
->value
== top_stack
->procadr
)
887 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
891 /* Make a type for the procedure itself */
892 SYMBOL_TYPE (s
) = lookup_function_type (t
);
894 /* Create and enter a new lexical context */
895 b
= new_block (top_stack
->maxsyms
);
896 SYMBOL_BLOCK_VALUE (s
) = b
;
897 BLOCK_FUNCTION (b
) = s
;
898 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
899 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
900 add_block (b
, top_stack
->cur_st
);
902 /* Not if we only have partial info */
903 if (sh
->sc
== scUndefined
|| sh
->sc
== scSUndefined
|| sh
->sc
== scNil
)
907 top_stack
->cur_block
= b
;
908 top_stack
->blocktype
= sh
->st
;
909 top_stack
->cur_type
= SYMBOL_TYPE (s
);
910 top_stack
->cur_field
= -1;
911 top_stack
->procadr
= sh
->value
;
912 top_stack
->numargs
= 0;
915 /* Beginning of code for structure, union, and enum definitions.
916 They all share a common set of local variables, defined here. */
918 enum type_code type_code
;
924 case stStruct
: /* Start a block defining a struct type */
925 type_code
= TYPE_CODE_STRUCT
;
926 goto structured_common
;
928 case stUnion
: /* Start a block defining a union type */
929 type_code
= TYPE_CODE_UNION
;
930 goto structured_common
;
932 case stEnum
: /* Start a block defining an enum type */
933 type_code
= TYPE_CODE_ENUM
;
934 goto structured_common
;
936 case stBlock
: /* Either a lexical block, or some type */
937 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
938 goto case_stBlock_code
; /* Lexical block */
940 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
942 /* Common code for handling struct, union, enum, and/or as-yet-
943 unknown-type blocks of info about structured data. `type_code'
944 has been set to the proper TYPE_CODE, if we know it. */
946 found_ecoff_debugging_info
= 1;
948 top_stack
->blocktype
= stBlock
;
950 /* First count the number of fields and the highest value. */
953 for (ext_tsym
= ext_sh
+ external_sym_size
;
955 ext_tsym
+= external_sym_size
)
959 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
967 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
968 /* If the type of the member is Nil (or Void),
969 without qualifiers, assume the tag is an
971 Alpha cc -migrate enums are recognized by a zero
972 index and a zero symbol value.
973 DU 4.0 cc enums are recognized by a member type of
974 btEnum without qualifiers and a zero symbol value. */
975 if (tsym
.index
== indexNil
976 || (tsym
.index
== 0 && sh
->value
== 0))
977 type_code
= TYPE_CODE_ENUM
;
980 (*debug_swap
->swap_tir_in
) (bigend
,
981 &ax
[tsym
.index
].a_ti
,
983 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
984 || (tir
.bt
== btEnum
&& sh
->value
== 0))
986 type_code
= TYPE_CODE_ENUM
;
989 if (tsym
.value
> max_value
)
990 max_value
= tsym
.value
;
999 /* This is a no-op; is it trying to tell us something
1000 we should be checking? */
1001 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
1003 if (tsym
.index
!= 0)
1005 /* This is something like a struct within a
1006 struct. Skip over the fields of the inner
1007 struct. The -1 is because the for loop will
1008 increment ext_tsym. */
1009 ext_tsym
= ((char *) debug_info
->external_sym
1010 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
1011 * external_sym_size
));
1017 /* mips cc puts out a typedef for struct x if it is not yet
1018 defined when it encounters
1019 struct y { struct x *xp; };
1024 /* Irix5 cc puts out a stIndirect for struct x if it is not
1025 yet defined when it encounters
1026 struct y { struct x *xp; };
1031 complain (&block_member_complaint
, tsym
.st
);
1036 /* In an stBlock, there is no way to distinguish structs,
1037 unions, and enums at this point. This is a bug in the
1038 original design (that has been fixed with the recent
1039 addition of the stStruct, stUnion, and stEnum symbol
1040 types.) The way you can tell is if/when you see a variable
1041 or field of that type. In that case the variable's type
1042 (in the AUX table) says if the type is struct, union, or
1043 enum, and points back to the stBlock here. So you can
1044 patch the tag kind up later - but only if there actually is
1045 a variable or field of that type.
1047 So until we know for sure, we will guess at this point.
1049 If the first member has index==indexNil or a void type,
1050 assume we have an enumeration.
1051 Otherwise, if there is more than one member, and all
1052 the members have offset 0, assume we have a union.
1053 Otherwise, assume we have a struct.
1055 The heuristic could guess wrong in the case of of an
1056 enumeration with no members or a union with one (or zero)
1057 members, or when all except the last field of a struct have
1058 width zero. These are uncommon and/or illegal situations,
1059 and in any case guessing wrong probably doesn't matter
1062 But if we later do find out we were wrong, we fixup the tag
1063 kind. Members of an enumeration must be handled
1064 differently from struct/union fields, and that is harder to
1065 patch up, but luckily we shouldn't need to. (If there are
1066 any enumeration members, we can tell for sure it's an enum
1069 if (type_code
== TYPE_CODE_UNDEF
)
1070 if (nfields
> 1 && max_value
== 0)
1071 type_code
= TYPE_CODE_UNION
;
1073 type_code
= TYPE_CODE_STRUCT
;
1075 /* Create a new type or use the pending type. */
1076 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1077 if (pend
== (struct mdebug_pending
*) NULL
)
1079 t
= new_type (NULL
);
1080 add_pending (cur_fdr
, ext_sh
, t
);
1085 /* Do not set the tag name if it is a compiler generated tag name
1086 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1087 Alpha cc puts out an sh->iss of zero for those. */
1088 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1089 TYPE_TAG_NAME (t
) = NULL
;
1091 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1094 TYPE_CODE (t
) = type_code
;
1095 TYPE_LENGTH (t
) = sh
->value
;
1096 TYPE_NFIELDS (t
) = nfields
;
1097 TYPE_FIELDS (t
) = f
= ((struct field
*)
1099 nfields
* sizeof (struct field
)));
1101 if (type_code
== TYPE_CODE_ENUM
)
1103 int unsigned_enum
= 1;
1105 /* This is a non-empty enum. */
1107 /* DEC c89 has the number of enumerators in the sh.value field,
1108 not the type length, so we have to compensate for that
1109 incompatibility quirk.
1110 This might do the wrong thing for an enum with one or two
1111 enumerators and gcc -gcoff -fshort-enums, but these cases
1112 are hopefully rare enough.
1113 Alpha cc -migrate has a sh.value field of zero, we adjust
1115 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1116 || TYPE_LENGTH (t
) == 0)
1117 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1118 for (ext_tsym
= ext_sh
+ external_sym_size
;
1120 ext_tsym
+= external_sym_size
)
1123 struct symbol
*enum_sym
;
1125 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1127 if (tsym
.st
!= stMember
)
1130 FIELD_BITPOS (*f
) = tsym
.value
;
1131 FIELD_TYPE (*f
) = t
;
1132 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1133 FIELD_BITSIZE (*f
) = 0;
1135 enum_sym
= ((struct symbol
*)
1136 obstack_alloc (¤t_objfile
->symbol_obstack
,
1137 sizeof (struct symbol
)));
1138 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1139 SYMBOL_NAME (enum_sym
) =
1140 obsavestring (f
->name
, strlen (f
->name
),
1141 ¤t_objfile
->symbol_obstack
);
1142 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1143 SYMBOL_TYPE (enum_sym
) = t
;
1144 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1145 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1146 if (SYMBOL_VALUE (enum_sym
) < 0)
1148 add_symbol (enum_sym
, top_stack
->cur_block
);
1150 /* Skip the stMembers that we've handled. */
1155 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1157 /* make this the current type */
1158 top_stack
->cur_type
= t
;
1159 top_stack
->cur_field
= 0;
1161 /* Do not create a symbol for alpha cc unnamed structs. */
1165 /* gcc puts out an empty struct for an opaque struct definitions,
1166 do not create a symbol for it either. */
1167 if (TYPE_NFIELDS (t
) == 0)
1169 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1173 s
= new_symbol (name
);
1174 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1175 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1176 SYMBOL_VALUE (s
) = 0;
1177 SYMBOL_TYPE (s
) = t
;
1178 add_symbol (s
, top_stack
->cur_block
);
1181 /* End of local variables shared by struct, union, enum, and
1182 block (as yet unknown struct/union/enum) processing. */
1186 found_ecoff_debugging_info
= 1;
1187 /* beginnning of (code) block. Value of symbol
1188 is the displacement from procedure start */
1189 push_parse_stack ();
1191 /* Do not start a new block if this is the outermost block of a
1192 procedure. This allows the LOC_BLOCK symbol to point to the
1193 block with the local variables, so funcname::var works. */
1194 if (top_stack
->blocktype
== stProc
1195 || top_stack
->blocktype
== stStaticProc
)
1197 top_stack
->blocktype
= stNil
;
1201 top_stack
->blocktype
= stBlock
;
1202 b
= new_block (top_stack
->maxsyms
);
1203 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1204 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1205 top_stack
->cur_block
= b
;
1206 add_block (b
, top_stack
->cur_st
);
1209 case stEnd
: /* end (of anything) */
1210 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1212 /* Finished with type */
1213 top_stack
->cur_type
= 0;
1215 else if (sh
->sc
== scText
&&
1216 (top_stack
->blocktype
== stProc
||
1217 top_stack
->blocktype
== stStaticProc
))
1219 /* Finished with procedure */
1220 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1221 struct mips_extra_func_info
*e
;
1223 struct type
*ftype
= top_stack
->cur_type
;
1226 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1228 /* Make up special symbol to contain procedure specific info */
1229 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1230 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1231 SYMBOL_CLASS (s
) = LOC_CONST
;
1232 SYMBOL_TYPE (s
) = mdebug_type_void
;
1233 e
= ((struct mips_extra_func_info
*)
1234 obstack_alloc (¤t_objfile
->symbol_obstack
,
1235 sizeof (struct mips_extra_func_info
)));
1236 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
1237 SYMBOL_VALUE (s
) = (long) e
;
1238 e
->numargs
= top_stack
->numargs
;
1239 e
->pdr
.framereg
= -1;
1240 add_symbol (s
, top_stack
->cur_block
);
1242 /* Reallocate symbols, saving memory */
1243 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1245 /* f77 emits proc-level with address bounds==[0,0],
1246 So look for such child blocks, and patch them. */
1247 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1249 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1250 if (BLOCK_SUPERBLOCK (b_bad
) == b
1251 && BLOCK_START (b_bad
) == top_stack
->procadr
1252 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1254 BLOCK_START (b_bad
) = BLOCK_START (b
);
1255 BLOCK_END (b_bad
) = BLOCK_END (b
);
1259 if (TYPE_NFIELDS (ftype
) <= 0)
1261 /* No parameter type information is recorded with the function's
1262 type. Set that from the type of the parameter symbols. */
1263 int nparams
= top_stack
->numargs
;
1269 TYPE_NFIELDS (ftype
) = nparams
;
1270 TYPE_FIELDS (ftype
) = (struct field
*)
1271 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1273 for (i
= iparams
= 0; iparams
< nparams
; i
++)
1275 sym
= BLOCK_SYM (b
, i
);
1276 switch (SYMBOL_CLASS (sym
))
1281 case LOC_REGPARM_ADDR
:
1282 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1292 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1294 /* End of (code) block. The value of the symbol is the
1295 displacement from the procedure`s start address of the
1296 end of this block. */
1297 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1298 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1300 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1302 /* End of outermost block. Pop parse stack and ignore. The
1303 following stEnd of stProc will take care of the block. */
1306 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1308 /* End of file. Pop parse stack and ignore. Higher
1309 level code deals with this. */
1313 complain (&stEnd_complaint
, sh
->sc
);
1315 pop_parse_stack (); /* restore previous lexical context */
1318 case stMember
: /* member of struct or union */
1319 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1320 FIELD_NAME (*f
) = name
;
1321 FIELD_BITPOS (*f
) = sh
->value
;
1323 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1324 FIELD_BITSIZE (*f
) = bitsize
;
1327 case stIndirect
: /* forward declaration on Irix5 */
1328 /* Forward declarations from Irix5 cc are handled by cross_ref,
1332 case stTypedef
: /* type definition */
1333 found_ecoff_debugging_info
= 1;
1335 /* Typedefs for forward declarations and opaque structs from alpha cc
1336 are handled by cross_ref, skip them. */
1340 /* Parse the type or use the pending type. */
1341 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1342 if (pend
== (struct mdebug_pending
*) NULL
)
1344 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1345 add_pending (cur_fdr
, ext_sh
, t
);
1350 /* mips cc puts out a typedef with the name of the struct for forward
1351 declarations. These should not go into the symbol table and
1352 TYPE_NAME should not be set for them.
1353 They can't be distinguished from an intentional typedef to
1354 the same name however:
1356 struct x { int ix; int jx; };
1360 struct xx {int ixx; int jxx; };
1361 generates a cross referencing stTypedef for x and xx.
1362 The user visible effect of this is that the type of a pointer
1363 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1364 The problem is fixed with alpha cc and Irix5 cc. */
1366 /* However if the typedef cross references to an opaque aggregate, it
1367 is safe to omit it from the symbol table. */
1369 if (has_opaque_xref (cur_fdr
, sh
))
1371 s
= new_symbol (name
);
1372 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1373 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1374 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1375 SYMBOL_TYPE (s
) = t
;
1376 add_symbol (s
, top_stack
->cur_block
);
1378 /* Incomplete definitions of structs should not get a name. */
1379 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1380 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1381 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1382 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1384 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1385 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1387 /* If we are giving a name to a type such as "pointer to
1388 foo" or "function returning foo", we better not set
1389 the TYPE_NAME. If the program contains "typedef char
1390 *caddr_t;", we don't want all variables of type char
1391 * to print as caddr_t. This is not just a
1392 consequence of GDB's type management; CC and GCC (at
1393 least through version 2.4) both output variables of
1394 either type char * or caddr_t with the type
1395 refering to the stTypedef symbol for caddr_t. If a future
1396 compiler cleans this up it GDB is not ready for it
1397 yet, but if it becomes ready we somehow need to
1398 disable this check (without breaking the PCC/GCC2.4
1403 Fortunately, this check seems not to be necessary
1404 for anything except pointers or functions. */
1407 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1411 case stFile
: /* file name */
1412 push_parse_stack ();
1413 top_stack
->blocktype
= sh
->st
;
1416 /* I`ve never seen these for C */
1418 break; /* register relocation */
1420 break; /* forwarding address */
1422 break; /* constant */
1424 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1431 /* Parse the type information provided in the raw AX entries for
1432 the symbol SH. Return the bitfield size in BS, in case.
1433 We must byte-swap the AX entries before we use them; BIGEND says whether
1434 they are big-endian or little-endian (from fh->fBigendian). */
1436 static struct type
*
1437 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1440 unsigned int aux_index
;
1445 /* Null entries in this map are treated specially */
1446 static struct type
**map_bt
[] =
1448 &mdebug_type_void
, /* btNil */
1449 &mdebug_type_adr_32
, /* btAdr */
1450 &mdebug_type_char
, /* btChar */
1451 &mdebug_type_unsigned_char
, /* btUChar */
1452 &mdebug_type_short
, /* btShort */
1453 &mdebug_type_unsigned_short
, /* btUShort */
1454 &mdebug_type_int_32
, /* btInt */
1455 &mdebug_type_unsigned_int_32
, /* btUInt */
1456 &mdebug_type_long_32
, /* btLong */
1457 &mdebug_type_unsigned_long_32
, /* btULong */
1458 &mdebug_type_float
, /* btFloat */
1459 &mdebug_type_double
, /* btDouble */
1466 &mdebug_type_complex
, /* btComplex */
1467 &mdebug_type_double_complex
, /* btDComplex */
1469 &mdebug_type_fixed_dec
, /* btFixedDec */
1470 &mdebug_type_float_dec
, /* btFloatDec */
1471 &mdebug_type_string
, /* btString */
1474 &mdebug_type_void
, /* btVoid */
1475 0, /* DEC C++: Pointer to member */
1476 0, /* DEC C++: Virtual function table */
1477 0, /* DEC C++: Class (Record) */
1478 &mdebug_type_long_64
, /* btLong64 */
1479 &mdebug_type_unsigned_long_64
, /* btULong64 */
1480 &mdebug_type_long_long_64
, /* btLongLong64 */
1481 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1482 &mdebug_type_adr_64
, /* btAdr64 */
1483 &mdebug_type_int_64
, /* btInt64 */
1484 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1488 struct type
*tp
= 0;
1489 enum type_code type_code
= TYPE_CODE_UNDEF
;
1491 /* Handle undefined types, they have indexNil. */
1492 if (aux_index
== indexNil
)
1493 return mdebug_type_int
;
1495 /* Handle corrupt aux indices. */
1496 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1498 complain (&index_complaint
, sym_name
);
1499 return mdebug_type_int
;
1503 /* Use aux as a type information record, map its basic type. */
1504 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1505 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1507 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1508 return mdebug_type_int
;
1512 tp
= *map_bt
[t
->bt
];
1517 /* Cannot use builtin types -- build our own */
1521 type_code
= TYPE_CODE_STRUCT
;
1524 type_code
= TYPE_CODE_UNION
;
1527 type_code
= TYPE_CODE_ENUM
;
1530 type_code
= TYPE_CODE_RANGE
;
1533 type_code
= TYPE_CODE_SET
;
1536 /* alpha cc -migrate uses this for typedefs. The true type will
1537 be obtained by crossreferencing below. */
1538 type_code
= TYPE_CODE_ERROR
;
1541 /* alpha cc uses this for typedefs. The true type will be
1542 obtained by crossreferencing below. */
1543 type_code
= TYPE_CODE_ERROR
;
1546 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1547 return mdebug_type_int
;
1551 /* Move on to next aux */
1556 int width
= AUX_GET_WIDTH (bigend
, ax
);
1558 /* Inhibit core dumps with some cfront generated objects that
1560 if (bs
== (int *)NULL
)
1562 /* Alpha cc -migrate encodes char and unsigned char types
1563 as short and unsigned short types with a field width of 8.
1564 Enum types also have a field width which we ignore for now. */
1565 if (t
->bt
== btShort
&& width
== 8)
1566 tp
= mdebug_type_char
;
1567 else if (t
->bt
== btUShort
&& width
== 8)
1568 tp
= mdebug_type_unsigned_char
;
1569 else if (t
->bt
== btEnum
)
1572 complain (&bad_fbitfield_complaint
, sym_name
);
1579 /* A btIndirect entry cross references to an aux entry containing
1581 if (t
->bt
== btIndirect
)
1588 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1590 if (rn
->rfd
== 0xfff)
1592 rf
= AUX_GET_ISYM (bigend
, ax
);
1600 complain (&bad_indirect_xref_complaint
, sym_name
);
1601 return mdebug_type_int
;
1603 xref_fh
= get_rfd (fd
, rf
);
1604 xref_fd
= xref_fh
- debug_info
->fdr
;
1605 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1606 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1609 /* All these types really point to some (common) MIPS type
1610 definition, and only the type-qualifiers fully identify
1611 them. We'll make the same effort at sharing. */
1612 if (t
->bt
== btStruct
||
1616 /* btSet (I think) implies that the name is a tag name, not a typedef
1617 name. This apparently is a MIPS extension for C sets. */
1622 /* Try to cross reference this type, build new type on failure. */
1623 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1624 if (tp
== (struct type
*) NULL
)
1625 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1627 /* DEC c89 produces cross references to qualified aggregate types,
1628 dereference them. */
1629 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1630 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1631 tp
= tp
->target_type
;
1633 /* Make sure that TYPE_CODE(tp) has an expected type code.
1634 Any type may be returned from cross_ref if file indirect entries
1636 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1637 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1638 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1640 complain (&unexpected_type_code_complaint
, sym_name
);
1645 /* Usually, TYPE_CODE(tp) is already type_code. The main
1646 exception is if we guessed wrong re struct/union/enum.
1647 But for struct vs. union a wrong guess is harmless, so
1648 don't complain(). */
1649 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1650 && type_code
!= TYPE_CODE_ENUM
)
1651 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1652 && type_code
== TYPE_CODE_ENUM
))
1654 complain (&bad_tag_guess_complaint
, sym_name
);
1657 if (TYPE_CODE (tp
) != type_code
)
1659 TYPE_CODE (tp
) = type_code
;
1662 /* Do not set the tag name if it is a compiler generated tag name
1663 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1664 if (name
[0] == '.' || name
[0] == '\0')
1665 TYPE_TAG_NAME (tp
) = NULL
;
1666 else if (TYPE_TAG_NAME (tp
) == NULL
1667 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1668 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1669 ¤t_objfile
->type_obstack
);
1673 /* All these types really point to some (common) MIPS type
1674 definition, and only the type-qualifiers fully identify
1675 them. We'll make the same effort at sharing.
1676 FIXME: We are not doing any guessing on range types. */
1677 if (t
->bt
== btRange
)
1681 /* Try to cross reference this type, build new type on failure. */
1682 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1683 if (tp
== (struct type
*) NULL
)
1684 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1686 /* Make sure that TYPE_CODE(tp) has an expected type code.
1687 Any type may be returned from cross_ref if file indirect entries
1689 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1691 complain (&unexpected_type_code_complaint
, sym_name
);
1695 /* Usually, TYPE_CODE(tp) is already type_code. The main
1696 exception is if we guessed wrong re struct/union/enum. */
1697 if (TYPE_CODE (tp
) != type_code
)
1699 complain (&bad_tag_guess_complaint
, sym_name
);
1700 TYPE_CODE (tp
) = type_code
;
1702 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1703 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1704 ¤t_objfile
->type_obstack
);
1707 if (t
->bt
== btTypedef
)
1711 /* Try to cross reference this type, it should succeed. */
1712 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1713 if (tp
== (struct type
*) NULL
)
1715 complain (&unable_to_cross_ref_complaint
, sym_name
);
1716 tp
= mdebug_type_int
;
1720 /* Deal with range types */
1721 if (t
->bt
== btRange
)
1723 TYPE_NFIELDS (tp
) = 2;
1724 TYPE_FIELDS (tp
) = ((struct field
*)
1725 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1726 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1727 ¤t_objfile
->type_obstack
);
1728 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1730 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1731 ¤t_objfile
->type_obstack
);
1732 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1736 /* Parse all the type qualifiers now. If there are more
1737 than 6 the game will continue in the next aux */
1741 #define PARSE_TQ(tq) \
1742 if (t->tq != tqNil) \
1743 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1755 /* mips cc 2.x and gcc never put out continued aux entries. */
1759 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1763 /* Complain for illegal continuations due to corrupt aux entries. */
1765 complain (&bad_continued_complaint
, sym_name
);
1770 /* Make up a complex type from a basic one. Type is passed by
1771 reference in TPP and side-effected as necessary. The type
1772 qualifier TQ says how to handle the aux symbols at AX for
1773 the symbol SX we are currently analyzing. BIGEND says whether
1774 aux symbols are big-endian or little-endian.
1775 Returns the number of aux symbols we parsed. */
1778 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1789 /* Used in array processing */
1800 t
= lookup_pointer_type (*tpp
);
1805 t
= lookup_function_type (*tpp
);
1812 /* Determine and record the domain type (type of index) */
1813 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1819 rf
= AUX_GET_ISYM (bigend
, ax
);
1822 fh
= get_rfd (fd
, rf
);
1824 indx
= parse_type (fh
- debug_info
->fdr
,
1825 debug_info
->external_aux
+ fh
->iauxBase
,
1826 id
, (int *) NULL
, bigend
, sym_name
);
1828 /* The bounds type should be an integer type, but might be anything
1829 else due to corrupt aux entries. */
1830 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1832 complain (&array_index_type_complaint
, sym_name
);
1833 indx
= mdebug_type_int
;
1836 /* Get the bounds, and create the array type. */
1838 lower
= AUX_GET_DNLOW (bigend
, ax
);
1840 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1842 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1844 range
= create_range_type ((struct type
*) NULL
, indx
,
1847 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1849 /* We used to fill in the supplied array element bitsize
1850 here if the TYPE_LENGTH of the target type was zero.
1851 This happens for a `pointer to an array of anonymous structs',
1852 but in this case the array element bitsize is also zero,
1853 so nothing is gained.
1854 And we used to check the TYPE_LENGTH of the target type against
1855 the supplied array element bitsize.
1856 gcc causes a mismatch for `pointer to array of object',
1857 since the sdb directives it uses do not have a way of
1858 specifying the bitsize, but it does no harm (the
1859 TYPE_LENGTH should be correct) and we should be able to
1860 ignore the erroneous bitsize from the auxiliary entry safely.
1861 dbx seems to ignore it too. */
1863 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1865 if (TYPE_LENGTH (*tpp
) == 0)
1867 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1874 /* Volatile -- currently ignored */
1878 /* Const -- currently ignored */
1882 complain (&unknown_type_qual_complaint
, tq
);
1888 /* Parse a procedure descriptor record PR. Note that the procedure is
1889 parsed _after_ the local symbols, now we just insert the extra
1890 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1891 already been placed in the procedure's main block. Note also that
1892 images that have been partially stripped (ld -x) have been deprived
1893 of local symbols, and we have to cope with them here. FIRST_OFF is
1894 the offset of the first procedure for this FDR; we adjust the
1895 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1896 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1897 in question, or NULL to use top_stack->cur_block. */
1899 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*,
1900 struct partial_symtab
*));
1903 parse_procedure (pr
, search_symtab
, pst
)
1905 struct symtab
*search_symtab
;
1906 struct partial_symtab
*pst
;
1908 struct symbol
*s
, *i
;
1910 struct mips_extra_func_info
*e
;
1913 /* Simple rule to find files linked "-x" */
1914 if (cur_fdr
->rss
== -1)
1918 /* Static procedure at address pr->adr. Sigh. */
1919 /* FIXME-32x64. assuming pr->adr fits in long. */
1920 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1928 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1929 ((char *) debug_info
->external_ext
1931 * debug_swap
->external_ext_size
)),
1933 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1941 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1942 ((char *) debug_info
->external_sym
1943 + ((cur_fdr
->isymBase
+ pr
->isym
)
1944 * debug_swap
->external_sym_size
)),
1946 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1949 if (search_symtab
!= NULL
)
1952 /* This loses both in the case mentioned (want a static, find a global),
1953 but also if we are looking up a non-mangled name which happens to
1954 match the name of a mangled function. */
1955 /* We have to save the cur_fdr across the call to lookup_symbol.
1956 If the pdr is for a static function and if a global function with
1957 the same name exists, lookup_symbol will eventually read in the symtab
1958 for the global function and clobber cur_fdr. */
1959 FDR
*save_cur_fdr
= cur_fdr
;
1960 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1961 cur_fdr
= save_cur_fdr
;
1965 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1971 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1972 VAR_NAMESPACE
, LOC_BLOCK
);
1976 b
= SYMBOL_BLOCK_VALUE (s
);
1980 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1984 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1985 s
= new_symbol (sh_name
);
1986 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1987 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1988 /* Donno its type, hope int is ok */
1989 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1990 add_symbol (s
, top_stack
->cur_block
);
1991 /* Wont have symbols for this one */
1993 SYMBOL_BLOCK_VALUE (s
) = b
;
1994 BLOCK_FUNCTION (b
) = s
;
1995 BLOCK_START (b
) = pr
->adr
;
1996 /* BOUND used to be the end of procedure's text, but the
1997 argument is no longer passed in. */
1998 BLOCK_END (b
) = bound
;
1999 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
2000 add_block (b
, top_stack
->cur_st
);
2004 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
2008 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
2010 e
->pdr
.isym
= (long) s
;
2012 /* GDB expects the absolute function start address for the
2013 procedure descriptor in e->pdr.adr.
2014 As the address in the procedure descriptor is usually relative,
2015 we would have to relocate e->pdr.adr with cur_fdr->adr and
2016 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT).
2017 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2018 in shared libraries on some systems, and on other systems
2019 e->pdr.adr is sometimes offset by a bogus value.
2020 To work around these problems, we replace e->pdr.adr with
2021 the start address of the function. */
2022 e
->pdr
.adr
= BLOCK_START (b
);
2024 /* Correct incorrect setjmp procedure descriptor from the library
2025 to make backtrace through setjmp work. */
2026 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
2028 complain (&bad_setjmp_pdr_complaint
, 0);
2029 e
->pdr
.pcreg
= RA_REGNUM
;
2030 e
->pdr
.regmask
= 0x80000000;
2031 e
->pdr
.regoffset
= -4;
2035 /* It would be reasonable that functions that have been compiled
2036 without debugging info have a btNil type for their return value,
2037 and functions that are void and are compiled with debugging info
2039 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2040 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2042 The glevel field in cur_fdr could be used to determine the presence
2043 of debugging info, but GCC doesn't always pass the -g switch settings
2044 to the assembler and GAS doesn't set the glevel field from the -g switch
2046 To work around these problems, the return value type of a TYPE_CODE_VOID
2047 function is adjusted accordingly if no debugging info was found in the
2048 compilation unit. */
2050 if (processing_gcc_compilation
== 0
2051 && found_ecoff_debugging_info
== 0
2052 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2053 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
2056 /* Relocate the extra function info pointed to by the symbol table. */
2059 ecoff_relocate_efi (sym
, delta
)
2063 struct mips_extra_func_info
*e
;
2065 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
2067 e
->pdr
.adr
+= delta
;
2070 /* Parse the external symbol ES. Just call parse_symbol() after
2071 making sure we know where the aux are for it.
2072 BIGEND says whether aux entries are big-endian or little-endian.
2074 This routine clobbers top_stack->cur_block and ->cur_st. */
2076 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
2079 parse_external (es
, bigend
, section_offsets
)
2082 struct section_offsets
*section_offsets
;
2086 if (es
->ifd
!= ifdNil
)
2089 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2090 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2094 cur_fdr
= debug_info
->fdr
;
2098 /* Reading .o files */
2099 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scSUndefined
2100 || es
->asym
.sc
== scNil
)
2103 switch (es
->asym
.st
)
2106 /* These are generated for static symbols in .o files,
2127 /* FIXME: Turn this into a complaint? */
2129 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2130 what
, debug_info
->ssext
+ es
->asym
.iss
,
2131 fdr_name (cur_fdr
));
2135 switch (es
->asym
.st
)
2139 /* There is no need to parse the external procedure symbols.
2140 If they are from objects compiled without -g, their index will
2141 be indexNil, and the symbol definition from the minimal symbol
2142 is preferrable (yielding a function returning int instead of int).
2143 If the index points to a local procedure symbol, the local
2144 symbol already provides the correct type.
2145 Note that the index of the external procedure symbol points
2146 to the local procedure symbol in the local symbol table, and
2147 _not_ to the auxiliary symbol info. */
2151 /* Global common symbols are resolved by the runtime loader,
2153 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
2156 /* Note that the case of a symbol with indexNil must be handled
2157 anyways by parse_symbol(). */
2158 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
2165 /* Parse the line number info for file descriptor FH into
2166 GDB's linetable LT. MIPS' encoding requires a little bit
2167 of magic to get things out. Note also that MIPS' line
2168 numbers can go back and forth, apparently we can live
2169 with that and do not need to reorder our linetables */
2171 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
2172 struct partial_symtab
*, CORE_ADDR
));
2175 parse_lines (fh
, pr
, lt
, maxlines
, pst
, lowest_pdr_addr
)
2178 struct linetable
*lt
;
2180 struct partial_symtab
*pst
;
2181 CORE_ADDR lowest_pdr_addr
;
2183 unsigned char *base
;
2185 int delta
, count
, lineno
= 0;
2187 if (fh
->cbLine
== 0)
2190 /* Scan by procedure descriptors */
2192 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2196 unsigned char *halt
;
2198 /* No code for this one */
2199 if (pr
->iline
== ilineNil
||
2200 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2203 /* Determine start and end address of compressed line bytes for
2205 base
= debug_info
->line
+ fh
->cbLineOffset
;
2206 if (j
!= (fh
->cpd
- 1))
2207 halt
= base
+ pr
[1].cbLineOffset
;
2209 halt
= base
+ fh
->cbLine
;
2210 base
+= pr
->cbLineOffset
;
2212 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2214 l
= adr
>> 2; /* in words */
2215 for (lineno
= pr
->lnLow
; base
< halt
; )
2217 count
= *base
& 0x0f;
2218 delta
= *base
++ >> 4;
2223 delta
= (base
[0] << 8) | base
[1];
2224 if (delta
>= 0x8000)
2228 lineno
+= delta
; /* first delta is 0 */
2230 /* Complain if the line table overflows. Could happen
2231 with corrupt binaries. */
2232 if (lt
->nitems
>= maxlines
)
2234 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2237 k
= add_line (lt
, lineno
, l
, k
);
2243 /* Master parsing procedure for first-pass reading of file symbols
2244 into a partial_symtab. */
2247 parse_partial_symbols (objfile
, section_offsets
)
2248 struct objfile
*objfile
;
2249 struct section_offsets
*section_offsets
;
2251 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2252 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2253 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2254 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2255 = debug_swap
->swap_ext_in
;
2256 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2257 = debug_swap
->swap_sym_in
;
2258 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2259 = debug_swap
->swap_rfd_in
;
2261 HDRR
*hdr
= &debug_info
->symbolic_header
;
2262 /* Running pointers */
2267 register EXTR
*ext_in
;
2270 struct partial_symtab
*pst
;
2271 int textlow_not_set
= 1;
2272 int past_first_source_file
= 0;
2274 /* List of current psymtab's include files */
2275 char **psymtab_include_list
;
2276 int includes_allocated
;
2279 struct pst_map
*fdr_to_pst
;
2280 /* Index within current psymtab dependency list */
2281 struct partial_symtab
**dependency_list
;
2282 int dependencies_used
, dependencies_allocated
;
2283 struct cleanup
*old_chain
;
2285 enum language prev_language
;
2286 asection
*text_sect
;
2287 int relocatable
= 0;
2289 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2290 the shared libraries are prelinked at a high memory address.
2291 We have to adjust the start address of the object file for this case,
2292 by setting it to the start address of the first procedure in the file.
2293 But we should do no adjustments if we are debugging a .o file, where
2294 the text section (and fh->adr) really starts at zero. */
2295 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2296 if (text_sect
!= NULL
2297 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2300 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2301 sizeof (EXTR
) * hdr
->iextMax
);
2303 includes_allocated
= 30;
2305 psymtab_include_list
= (char **) alloca (includes_allocated
*
2307 next_symbol_text_func
= mdebug_next_symbol_text
;
2309 dependencies_allocated
= 30;
2310 dependencies_used
= 0;
2312 (struct partial_symtab
**) alloca (dependencies_allocated
*
2313 sizeof (struct partial_symtab
*));
2315 last_source_file
= NULL
;
2320 * Only parse the Local and External symbols, and the Relative FDR.
2321 * Fixup enough of the loader symtab to be able to use it.
2322 * Allocate space only for the file's portions we need to
2327 max_glevel
= MIN_GLEVEL
;
2329 /* Allocate the map FDR -> PST.
2330 Minor hack: -O3 images might claim some global data belongs
2331 to FDR -1. We`ll go along with that */
2332 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2333 old_chain
= make_cleanup (free
, fdr_to_pst
);
2336 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2337 fdr_to_pst
[-1].pst
= pst
;
2341 /* Allocate the global pending list. */
2343 ((struct mdebug_pending
**)
2344 obstack_alloc (&objfile
->psymbol_obstack
,
2345 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2346 memset ((PTR
) pending_list
, 0,
2347 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2349 /* Pass 0 over external syms: swap them in. */
2350 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2351 make_cleanup (free
, ext_block
);
2353 ext_out
= (char *) debug_info
->external_ext
;
2354 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2356 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2357 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2359 /* Pass 1 over external syms: Presize and partition the list */
2361 ext_in_end
= ext_in
+ hdr
->iextMax
;
2362 for (; ext_in
< ext_in_end
; ext_in
++)
2364 /* See calls to complain below. */
2365 if (ext_in
->ifd
>= -1
2366 && ext_in
->ifd
< hdr
->ifdMax
2367 && ext_in
->asym
.iss
>= 0
2368 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2369 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2372 /* Pass 1.5 over files: partition out global symbol space */
2374 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2376 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2377 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2378 fdr_to_pst
[f_idx
].n_globals
= 0;
2381 /* Pass 2 over external syms: fill in external symbols */
2383 ext_in_end
= ext_in
+ hdr
->iextMax
;
2384 for (; ext_in
< ext_in_end
; ext_in
++)
2386 enum minimal_symbol_type ms_type
= mst_text
;
2387 CORE_ADDR svalue
= ext_in
->asym
.value
;
2389 /* The Irix 5 native tools seem to sometimes generate bogus
2390 external symbols. */
2391 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2393 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2396 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2398 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2403 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2404 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2406 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scSUndefined
2407 || ext_in
->asym
.sc
== scNil
)
2410 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2411 switch (ext_in
->asym
.st
)
2414 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2417 ms_type
= mst_file_text
;
2418 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2421 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2423 /* The value of a common symbol is its size, not its address.
2427 else if (ext_in
->asym
.sc
== scData
2428 || ext_in
->asym
.sc
== scSData
2429 || ext_in
->asym
.sc
== scRData
2430 || ext_in
->asym
.sc
== scPData
2431 || ext_in
->asym
.sc
== scXData
)
2434 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2439 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2443 if (ext_in
->asym
.sc
== scAbs
)
2445 else if (ext_in
->asym
.sc
== scText
2446 || ext_in
->asym
.sc
== scInit
2447 || ext_in
->asym
.sc
== scFini
)
2449 ms_type
= mst_file_text
;
2450 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2452 else if (ext_in
->asym
.sc
== scData
2453 || ext_in
->asym
.sc
== scSData
2454 || ext_in
->asym
.sc
== scRData
2455 || ext_in
->asym
.sc
== scPData
2456 || ext_in
->asym
.sc
== scXData
)
2458 ms_type
= mst_file_data
;
2459 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2463 ms_type
= mst_file_bss
;
2464 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2469 /* The alpha has the section start addresses in stLocal symbols
2470 whose name starts with a `.'. Skip those but complain for all
2471 other stLocal symbols.
2472 Irix6 puts the section start addresses in stNil symbols, skip
2478 ms_type
= mst_unknown
;
2479 complain (&unknown_ext_complaint
, name
);
2481 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2484 /* Pass 3 over files, over local syms: fill in static symbols */
2485 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2487 struct partial_symtab
*save_pst
;
2491 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2493 /* If a partial symbol table has already been read for this file,
2494 don't make another one. This works around a problem with some
2495 compilers that emit both DWARF and mdebug sections for a single
2497 if (lookup_partial_symtab (fdr_name (fh
)))
2502 fdr_to_pst
[f_idx
].pst
= NULL
;
2506 /* Determine the start address for this object file from the
2507 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2511 if (relocatable
|| textlow
!= 0)
2512 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2516 pst
= start_psymtab_common (objfile
, section_offsets
,
2519 objfile
->global_psymbols
.next
,
2520 objfile
->static_psymbols
.next
);
2521 pst
->read_symtab_private
= ((char *)
2522 obstack_alloc (&objfile
->psymbol_obstack
,
2523 sizeof (struct symloc
)));
2524 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2527 FDR_IDX (pst
) = f_idx
;
2528 CUR_BFD (pst
) = cur_bfd
;
2529 DEBUG_SWAP (pst
) = debug_swap
;
2530 DEBUG_INFO (pst
) = debug_info
;
2531 PENDING_LIST (pst
) = pending_list
;
2533 /* The way to turn this into a symtab is to call... */
2534 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2536 /* Set up language for the pst.
2537 The language from the FDR is used if it is unambigious (e.g. cfront
2538 with native cc and g++ will set the language to C).
2539 Otherwise we have to deduce the language from the filename.
2540 Native ecoff has every header file in a separate FDR, so
2541 deduce_language_from_filename will return language_unknown for
2542 a header file, which is not what we want.
2543 But the FDRs for the header files are after the FDR for the source
2544 file, so we can assign the language of the source file to the
2545 following header files. Then we save the language in the private
2546 pst data so that we can reuse it when building symtabs. */
2547 prev_language
= psymtab_language
;
2551 case langCplusplusV2
:
2552 psymtab_language
= language_cplus
;
2555 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2558 if (psymtab_language
== language_unknown
)
2559 psymtab_language
= prev_language
;
2560 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2562 pst
->texthigh
= pst
->textlow
;
2564 /* For stabs-in-ecoff files, the second symbol must be @stab.
2565 This symbol is emitted by mips-tfile to signal that the
2566 current object file uses encapsulated stabs instead of mips
2567 ecoff for local symbols. (It is the second symbol because
2568 the first symbol is the stFile used to signal the start of a
2570 processing_gcc_compilation
= 0;
2573 (*swap_sym_in
) (cur_bfd
,
2574 ((char *) debug_info
->external_sym
2575 + (fh
->isymBase
+ 1) * external_sym_size
),
2577 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2578 processing_gcc_compilation
= 2;
2581 if (processing_gcc_compilation
!= 0)
2583 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2588 (*swap_sym_in
) (cur_bfd
,
2589 (((char *) debug_info
->external_sym
)
2590 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2592 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2593 if (!ECOFF_IS_STAB (&sh
))
2595 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2600 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2601 if (sh
.st
== stStaticProc
)
2603 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2604 prim_record_minimal_symbol_and_info (namestring
,
2612 procaddr
= sh
.value
;
2614 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2615 (debug_info
->external_aux
2618 (*swap_sym_in
) (cur_bfd
,
2619 ((char *) debug_info
->external_sym
2620 + ((fh
->isymBase
+ isym
- 1)
2621 * external_sym_size
)),
2625 CORE_ADDR high
= procaddr
+ sh
.value
;
2627 /* Kludge for Irix 5.2 zero fh->adr. */
2629 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2630 pst
->textlow
= procaddr
;
2631 if (high
> pst
->texthigh
)
2632 pst
->texthigh
= high
;
2635 else if (sh
.st
== stStatic
)
2650 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2651 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2652 prim_record_minimal_symbol_and_info (namestring
,
2662 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2663 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2664 prim_record_minimal_symbol_and_info (namestring
,
2676 #define SET_NAMESTRING() \
2677 namestring = debug_info->ss + fh->issBase + sh.iss
2678 #define CUR_SYMBOL_TYPE type_code
2679 #define CUR_SYMBOL_VALUE sh.value
2680 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2682 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set) (void)0
2683 #define HANDLE_RBRAC(val) \
2684 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2685 #include "partial-stab.h"
2690 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2693 enum address_class
class;
2695 (*swap_sym_in
) (cur_bfd
,
2696 ((char *) debug_info
->external_sym
2697 + ((fh
->isymBase
+ cur_sdx
)
2698 * external_sym_size
)),
2701 if (ECOFF_IS_STAB (&sh
))
2707 /* Non absolute static symbols go into the minimal table. */
2708 if (sh
.sc
== scUndefined
|| sh
.sc
== scSUndefined
2710 || (sh
.index
== indexNil
2711 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2713 /* FIXME, premature? */
2718 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2724 /* The value of a stEnd symbol is the displacement from the
2725 corresponding start symbol value, do not relocate it. */
2727 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2734 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2738 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2749 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2750 mst_file_text
, NULL
,
2751 SECT_OFF_TEXT
, NULL
,
2757 /* Usually there is a local and a global stProc symbol
2758 for a function. This means that the function name
2759 has already been entered into the mimimal symbol table
2760 while processing the global symbols in pass 2 above.
2761 One notable exception is the PROGRAM name from
2762 f77 compiled executables, it is only put out as
2763 local stProc symbol, and a global MAIN__ stProc symbol
2764 points to it. It doesn't matter though, as gdb is
2765 still able to find the PROGRAM name via the partial
2766 symbol table, and the MAIN__ symbol via the minimal
2768 if (sh
.st
== stProc
)
2769 add_psymbol_to_list (name
, strlen (name
),
2770 VAR_NAMESPACE
, LOC_BLOCK
,
2771 &objfile
->global_psymbols
,
2772 0, sh
.value
, psymtab_language
, objfile
);
2774 add_psymbol_to_list (name
, strlen (name
),
2775 VAR_NAMESPACE
, LOC_BLOCK
,
2776 &objfile
->static_psymbols
,
2777 0, sh
.value
, psymtab_language
, objfile
);
2779 /* Skip over procedure to next one. */
2780 if (sh
.index
>= hdr
->iauxMax
)
2782 /* Should not happen, but does when cross-compiling
2783 with the MIPS compiler. FIXME -- pull later. */
2784 complain (&index_complaint
, name
);
2785 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2788 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2789 (debug_info
->external_aux
2792 procaddr
= sh
.value
;
2794 if (new_sdx
<= cur_sdx
)
2796 /* This should not happen either... FIXME. */
2797 complain (&aux_index_complaint
, name
);
2798 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2802 (*swap_sym_in
) (cur_bfd
,
2803 ((char *) debug_info
->external_sym
2804 + ((fh
->isymBase
+ cur_sdx
- 1)
2805 * external_sym_size
)),
2810 /* Kludge for Irix 5.2 zero fh->adr. */
2812 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2813 pst
->textlow
= procaddr
;
2815 high
= procaddr
+ sh
.value
;
2816 if (high
> pst
->texthigh
)
2817 pst
->texthigh
= high
;
2820 case stStatic
: /* Variable */
2825 || sh
.sc
== scXData
)
2826 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2827 mst_file_data
, NULL
,
2832 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2840 case stIndirect
:/* Irix5 forward declaration */
2841 /* Skip forward declarations from Irix5 cc */
2844 case stTypedef
:/* Typedef */
2845 /* Skip typedefs for forward declarations and opaque
2846 structs from alpha and mips cc. */
2847 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2849 class = LOC_TYPEDEF
;
2852 case stConstant
: /* Constant decl */
2859 case stBlock
: /* { }, str, un, enum*/
2860 /* Do not create a partial symbol for cc unnamed aggregates
2861 and gcc empty aggregates. */
2862 if ((sh
.sc
== scInfo
2863 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2865 && sh
.index
!= cur_sdx
+ 2)
2867 add_psymbol_to_list (name
, strlen (name
),
2868 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2869 &objfile
->static_psymbols
,
2871 psymtab_language
, objfile
);
2873 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
2875 /* Skip over the block */
2877 if (new_sdx
<= cur_sdx
)
2879 /* This happens with the Ultrix kernel. */
2880 complain (&block_index_complaint
, name
);
2881 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2886 case stFile
: /* File headers */
2887 case stLabel
: /* Labels */
2888 case stEnd
: /* Ends of files */
2891 case stLocal
: /* Local variables */
2892 /* Normally these are skipped because we skip over
2893 all blocks we see. However, these can occur
2894 as visible symbols in a .h file that contains code. */
2898 /* Both complaints are valid: one gives symbol name,
2899 the other the offending symbol type. */
2900 complain (&unknown_sym_complaint
, name
);
2901 complain (&unknown_st_complaint
, sh
.st
);
2905 /* Use this gdb symbol */
2906 add_psymbol_to_list (name
, strlen (name
),
2907 VAR_NAMESPACE
, class,
2908 &objfile
->static_psymbols
,
2909 0, sh
.value
, psymtab_language
, objfile
);
2911 cur_sdx
++; /* Go to next file symbol */
2914 /* Now do enter the external symbols. */
2915 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2916 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2917 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2918 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2919 for (; --cur_sdx
>= 0; ext_ptr
++)
2921 enum address_class
class;
2926 if (ext_ptr
->ifd
!= f_idx
)
2928 psh
= &ext_ptr
->asym
;
2930 /* Do not add undefined symbols to the partial symbol table. */
2931 if (psh
->sc
== scUndefined
|| psh
->sc
== scSUndefined
2932 || psh
->sc
== scNil
)
2935 svalue
= psh
->value
;
2940 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2947 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2951 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2958 /* These are generated for static symbols in .o files,
2963 /* External procedure symbols have been entered
2964 into the minimal symbol table in pass 2 above.
2965 Ignore them, as parse_external will ignore them too. */
2971 complain (&unknown_ext_complaint
,
2972 debug_info
->ssext
+ psh
->iss
);
2973 /* Fall through, pretend it's global. */
2975 /* Global common symbols are resolved by the runtime loader,
2977 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2983 name
= debug_info
->ssext
+ psh
->iss
;
2984 add_psymbol_to_list (name
, strlen (name
),
2985 VAR_NAMESPACE
, class,
2986 &objfile
->global_psymbols
,
2988 psymtab_language
, objfile
);
2992 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2993 empty and put on the free list. */
2994 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2995 psymtab_include_list
, includes_used
,
2996 -1, save_pst
->texthigh
,
2997 dependency_list
, dependencies_used
, textlow_not_set
);
2999 dependencies_used
= 0;
3001 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
3002 objfile
->ei
.entry_point
< save_pst
->texthigh
)
3004 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
3005 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
3008 /* The objfile has its functions reordered if this partial symbol
3009 table overlaps any other partial symbol table.
3010 We cannot assume a reordered objfile if a partial symbol table
3011 is contained within another partial symbol table, as partial symbol
3012 tables for include files with executable code are contained
3013 within the partial symbol table for the including source file,
3014 and we do not want to flag the objfile reordered for these cases.
3016 This strategy works well for Irix-5.2 shared libraries, but we
3017 might have to use a more elaborate (and slower) algorithm for
3019 save_pst
= fdr_to_pst
[f_idx
].pst
;
3020 if (save_pst
!= NULL
3021 && save_pst
->textlow
!= 0
3022 && !(objfile
->flags
& OBJF_REORDERED
))
3024 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3027 && save_pst
->textlow
>= pst
->textlow
3028 && save_pst
->textlow
< pst
->texthigh
3029 && save_pst
->texthigh
> pst
->texthigh
)
3031 objfile
->flags
|= OBJF_REORDERED
;
3038 /* Now scan the FDRs for dependencies */
3039 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3041 fh
= f_idx
+ debug_info
->fdr
;
3042 pst
= fdr_to_pst
[f_idx
].pst
;
3044 if (pst
== (struct partial_symtab
*)NULL
)
3047 /* This should catch stabs-in-ecoff. */
3051 /* Skip the first file indirect entry as it is a self dependency
3052 for source files or a reverse .h -> .c dependency for header files. */
3053 pst
->number_of_dependencies
= 0;
3055 ((struct partial_symtab
**)
3056 obstack_alloc (&objfile
->psymbol_obstack
,
3058 * sizeof (struct partial_symtab
*))));
3059 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3063 (*swap_rfd_in
) (cur_bfd
,
3064 ((char *) debug_info
->external_rfd
3065 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3067 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3069 complain (&bad_file_number_complaint
, rh
);
3073 /* Skip self dependencies of header files. */
3077 /* Do not add to dependeny list if psymtab was empty. */
3078 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
3080 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3084 /* Remove the dummy psymtab created for -O3 images above, if it is
3085 still empty, to enable the detection of stripped executables. */
3086 if (objfile
->psymtabs
->next
== NULL
3087 && objfile
->psymtabs
->number_of_dependencies
== 0
3088 && objfile
->psymtabs
->n_global_syms
== 0
3089 && objfile
->psymtabs
->n_static_syms
== 0)
3090 objfile
->psymtabs
= NULL
;
3091 do_cleanups (old_chain
);
3094 /* If the current psymbol has an enumerated type, we need to add
3095 all the the enum constants to the partial symbol table. */
3098 handle_psymbol_enumerators (objfile
, fh
, stype
, svalue
)
3099 struct objfile
*objfile
;
3104 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3105 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
3106 = debug_swap
->swap_sym_in
;
3107 char *ext_sym
= ((char *) debug_info
->external_sym
3108 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3118 /* It is an enumerated type if the next symbol entry is a stMember
3119 and its auxiliary index is indexNil or its auxiliary entry
3120 is a plain btNil or btVoid.
3121 Alpha cc -migrate enums are recognized by a zero index and
3122 a zero symbol value.
3123 DU 4.0 cc enums are recognized by a member type of btEnum without
3124 qualifiers and a zero symbol value. */
3125 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3126 if (sh
.st
!= stMember
)
3129 if (sh
.index
== indexNil
3130 || (sh
.index
== 0 && svalue
== 0))
3132 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3133 &(debug_info
->external_aux
3134 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3136 if ((tir
.bt
!= btNil
3138 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3139 || tir
.tq0
!= tqNil
)
3151 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3152 if (sh
.st
!= stMember
)
3154 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3156 /* Note that the value doesn't matter for enum constants
3157 in psymtabs, just in symtabs. */
3158 add_psymbol_to_list (name
, strlen (name
),
3159 VAR_NAMESPACE
, LOC_CONST
,
3160 &objfile
->static_psymbols
, 0,
3161 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3162 ext_sym
+= external_sym_size
;
3167 mdebug_next_symbol_text (objfile
)
3168 struct objfile
*objfile
; /* argument objfile is currently unused */
3173 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3174 ((char *) debug_info
->external_sym
3175 + ((cur_fdr
->isymBase
+ cur_sdx
)
3176 * debug_swap
->external_sym_size
)),
3178 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3181 /* Ancillary function to psymtab_to_symtab(). Does all the work
3182 for turning the partial symtab PST into a symtab, recurring
3183 first on all dependent psymtabs. The argument FILENAME is
3184 only passed so we can see in debug stack traces what file
3187 This function has a split personality, based on whether the
3188 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3189 The flow of control and even the memory allocation differs. FIXME. */
3192 psymtab_to_symtab_1 (pst
, filename
)
3193 struct partial_symtab
*pst
;
3196 bfd_size_type external_sym_size
;
3197 bfd_size_type external_pdr_size
;
3198 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
3199 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
3203 struct linetable
*lines
;
3204 CORE_ADDR lowest_pdr_addr
= 0;
3210 /* Read in all partial symbtabs on which this one is dependent.
3211 NOTE that we do have circular dependencies, sigh. We solved
3212 that by setting pst->readin before this point. */
3214 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3215 if (!pst
->dependencies
[i
]->readin
)
3217 /* Inform about additional files to be read in. */
3220 fputs_filtered (" ", gdb_stdout
);
3222 fputs_filtered ("and ", gdb_stdout
);
3224 printf_filtered ("%s...",
3225 pst
->dependencies
[i
]->filename
);
3226 wrap_here (""); /* Flush output */
3227 gdb_flush (gdb_stdout
);
3229 /* We only pass the filename for debug purposes */
3230 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3231 pst
->dependencies
[i
]->filename
);
3234 /* Do nothing if this is a dummy psymtab. */
3236 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3237 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3240 /* Now read the symbols for this symtab */
3242 cur_bfd
= CUR_BFD (pst
);
3243 debug_swap
= DEBUG_SWAP (pst
);
3244 debug_info
= DEBUG_INFO (pst
);
3245 pending_list
= PENDING_LIST (pst
);
3246 external_sym_size
= debug_swap
->external_sym_size
;
3247 external_pdr_size
= debug_swap
->external_pdr_size
;
3248 swap_sym_in
= debug_swap
->swap_sym_in
;
3249 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3250 current_objfile
= pst
->objfile
;
3251 cur_fd
= FDR_IDX (pst
);
3252 fh
= ((cur_fd
== -1)
3254 : debug_info
->fdr
+ cur_fd
);
3257 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3258 processing_gcc_compilation
= 0;
3259 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3263 (*swap_sym_in
) (cur_bfd
,
3264 ((char *) debug_info
->external_sym
3265 + (fh
->isymBase
+ 1) * external_sym_size
),
3267 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3270 /* We indicate that this is a GCC compilation so that certain
3271 features will be enabled in stabsread/dbxread. */
3272 processing_gcc_compilation
= 2;
3276 if (processing_gcc_compilation
!= 0)
3279 /* This symbol table contains stabs-in-ecoff entries. */
3281 /* Parse local symbols first */
3283 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3285 current_objfile
= NULL
;
3288 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3294 (*swap_sym_in
) (cur_bfd
,
3295 (((char *) debug_info
->external_sym
)
3296 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3298 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3300 if (ECOFF_IS_STAB (&sh
))
3302 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3304 /* We should never get non N_STAB symbols here, but they
3305 should be harmless, so keep process_one_symbol from
3306 complaining about them. */
3307 if (type_code
& N_STAB
)
3309 process_one_symbol (type_code
, 0, valu
, name
,
3310 pst
->section_offsets
, pst
->objfile
);
3312 if (type_code
== N_FUN
)
3314 /* Make up special symbol to contain
3315 procedure specific info */
3316 struct mips_extra_func_info
*e
=
3317 ((struct mips_extra_func_info
*)
3318 obstack_alloc (¤t_objfile
->symbol_obstack
,
3319 sizeof (struct mips_extra_func_info
)));
3320 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3322 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
3323 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3324 SYMBOL_CLASS (s
) = LOC_CONST
;
3325 SYMBOL_TYPE (s
) = mdebug_type_void
;
3326 SYMBOL_VALUE (s
) = (long) e
;
3327 e
->pdr
.framereg
= -1;
3328 add_symbol_to_list (s
, &local_symbols
);
3331 else if (sh
.st
== stLabel
)
3333 if (sh
.index
== indexNil
)
3335 /* This is what the gcc2_compiled and __gnu_compiled_*
3336 show up as. So don't complain. */
3341 /* Handle encoded stab line number. */
3342 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT
);
3343 record_line (current_subfile
, sh
.index
, valu
);
3346 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3347 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3348 /* These are generated by gcc-2.x, do not complain */
3351 complain (&stab_unknown_complaint
, name
);
3353 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT
);
3356 /* Sort the symbol table now, we are done adding symbols to it.
3357 We must do this before parse_procedure calls lookup_symbol. */
3358 sort_symtab_syms (st
);
3360 /* There used to be a call to sort_blocks here, but this should not
3361 be necessary for stabs symtabs. And as sort_blocks modifies the
3362 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3363 it did the wrong thing if the first procedure in a file was
3364 generated via asm statements. */
3366 /* Fill in procedure info next. */
3370 struct cleanup
*old_chain
;
3376 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3377 old_chain
= make_cleanup (free
, pr_block
);
3379 pdr_ptr
= ((char *) debug_info
->external_pdr
3380 + fh
->ipdFirst
* external_pdr_size
);
3381 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3385 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3387 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3389 /* Determine lowest PDR address, the PDRs are not always
3391 if (pdr_in
== pr_block
)
3392 lowest_pdr_addr
= pdr_in
->adr
;
3393 else if (pdr_in
->adr
< lowest_pdr_addr
)
3394 lowest_pdr_addr
= pdr_in
->adr
;
3398 pdr_in_end
= pdr_in
+ fh
->cpd
;
3399 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3400 parse_procedure (pdr_in
, st
, pst
);
3402 do_cleanups (old_chain
);
3407 /* This symbol table contains ordinary ecoff entries. */
3413 /* How many symbols will we need */
3414 /* FIXME, this does not count enum values. */
3415 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
3419 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
3423 f_max
+= fh
->csym
+ fh
->cpd
;
3424 maxlines
= 2 * fh
->cline
;
3425 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
3427 /* The proper language was already determined when building
3428 the psymtab, use it. */
3429 st
->language
= PST_PRIVATE (pst
)->pst_language
;
3432 psymtab_language
= st
->language
;
3434 lines
= LINETABLE (st
);
3436 /* Get a new lexical context */
3438 push_parse_stack ();
3439 top_stack
->cur_st
= st
;
3440 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
3442 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
3443 BLOCK_END (top_stack
->cur_block
) = 0;
3444 top_stack
->blocktype
= stFile
;
3445 top_stack
->maxsyms
= 2 * f_max
;
3446 top_stack
->cur_type
= 0;
3447 top_stack
->procadr
= 0;
3448 top_stack
->numargs
= 0;
3449 found_ecoff_debugging_info
= 0;
3456 /* Parse local symbols first */
3457 sym_ptr
= ((char *) debug_info
->external_sym
3458 + fh
->isymBase
* external_sym_size
);
3459 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
3460 while (sym_ptr
< sym_end
)
3465 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
3466 c
= parse_symbol (&sh
,
3467 debug_info
->external_aux
+ fh
->iauxBase
,
3468 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3469 sym_ptr
+= c
* external_sym_size
;
3472 /* Linenumbers. At the end, check if we can save memory.
3473 parse_lines has to look ahead an arbitrary number of PDR
3474 structures, so we swap them all first. */
3478 struct cleanup
*old_chain
;
3484 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3486 old_chain
= make_cleanup (free
, pr_block
);
3488 pdr_ptr
= ((char *) debug_info
->external_pdr
3489 + fh
->ipdFirst
* external_pdr_size
);
3490 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3494 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3496 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3498 /* Determine lowest PDR address, the PDRs are not always
3500 if (pdr_in
== pr_block
)
3501 lowest_pdr_addr
= pdr_in
->adr
;
3502 else if (pdr_in
->adr
< lowest_pdr_addr
)
3503 lowest_pdr_addr
= pdr_in
->adr
;
3506 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
3507 if (lines
->nitems
< fh
->cline
)
3508 lines
= shrink_linetable (lines
);
3510 /* Fill in procedure info next. */
3512 pdr_in_end
= pdr_in
+ fh
->cpd
;
3513 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3514 parse_procedure (pdr_in
, 0, pst
);
3516 do_cleanups (old_chain
);
3520 LINETABLE (st
) = lines
;
3522 /* .. and our share of externals.
3523 XXX use the global list to speed up things here. how?
3524 FIXME, Maybe quit once we have found the right number of ext's? */
3525 top_stack
->cur_st
= st
;
3526 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3528 top_stack
->blocktype
= stFile
;
3530 = (debug_info
->symbolic_header
.isymMax
3531 + debug_info
->symbolic_header
.ipdMax
3532 + debug_info
->symbolic_header
.iextMax
);
3534 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3535 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3536 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3538 /* If there are undefined symbols, tell the user.
3539 The alpha has an undefined symbol for every symbol that is
3540 from a shared library, so tell the user only if verbose is on. */
3541 if (info_verbose
&& n_undef_symbols
)
3543 printf_filtered ("File %s contains %d unresolved references:",
3544 st
->filename
, n_undef_symbols
);
3545 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3546 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3547 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3554 /* Sort the symbol table now, we are done adding symbols to it.*/
3555 sort_symtab_syms (st
);
3560 /* Now link the psymtab and the symtab. */
3563 current_objfile
= NULL
;
3566 /* Ancillary parsing procedures. */
3568 /* Return 1 if the symbol pointed to by SH has a cross reference
3569 to an opaque aggregate type, else 0. */
3572 has_opaque_xref (fh
, sh
)
3581 if (sh
->index
== indexNil
)
3584 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
3585 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
3586 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
3590 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
3591 if (rn
->rfd
== 0xfff)
3592 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
3600 /* Lookup the type at relative index RN. Return it in TPP
3601 if found and in any event come up with its name PNAME.
3602 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3603 Return value says how many aux symbols we ate. */
3606 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3610 enum type_code type_code
; /* Use to alloc new type if none is found. */
3622 struct mdebug_pending
*pend
;
3624 *tpp
= (struct type
*)NULL
;
3626 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
3628 /* Escape index means 'the next one' */
3629 if (rn
->rfd
== 0xfff)
3632 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3639 /* mips cc uses a rf of -1 for opaque struct definitions.
3640 Set TYPE_FLAG_STUB for these types so that check_typedef will
3641 resolve them if the struct gets defined in another compilation unit. */
3644 *pname
= "<undefined>";
3645 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3646 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3650 /* mips cc uses an escaped rn->index of 0 for struct return types
3651 of procedures that were compiled without -g. These will always remain
3653 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3655 *pname
= "<undefined>";
3659 /* Find the relative file descriptor and the symbol in it. */
3660 fh
= get_rfd (fd
, rf
);
3661 xref_fd
= fh
- debug_info
->fdr
;
3663 if (rn
->index
>= fh
->csym
)
3665 /* File indirect entry is corrupt. */
3666 *pname
= "<illegal>";
3667 complain (&bad_rfd_entry_complaint
,
3668 sym_name
, xref_fd
, rn
->index
);
3672 /* If we have processed this symbol then we left a forwarding
3673 pointer to the type in the pending list. If not, we`ll put
3674 it in a list of pending types, to be processed later when
3675 the file will be. In any event, we collect the name for the
3678 esh
= ((char *) debug_info
->external_sym
3679 + ((fh
->isymBase
+ rn
->index
)
3680 * debug_swap
->external_sym_size
));
3681 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3683 /* Make sure that this type of cross reference can be handled. */
3684 if ((sh
.sc
!= scInfo
3685 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
3686 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3687 && sh
.st
!= stEnum
))
3688 && (sh
.st
!= stBlock
|| (sh
.sc
!= scCommon
&& sh
.sc
!= scSCommon
)))
3690 /* File indirect entry is corrupt. */
3691 *pname
= "<illegal>";
3692 complain (&bad_rfd_entry_complaint
,
3693 sym_name
, xref_fd
, rn
->index
);
3697 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3699 pend
= is_pending_symbol (fh
, esh
);
3704 /* We have not yet seen this type. */
3706 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
3710 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3712 a) forward declarations of structs/unions/enums which are not
3713 defined in this compilation unit.
3714 For these the type will be void. This is a bad design decision
3715 as cross referencing across compilation units is impossible
3716 due to the missing name.
3717 b) forward declarations of structs/unions/enums/typedefs which
3718 are defined later in this file or in another file in the same
3719 compilation unit. Irix5 cc uses a stIndirect symbol for this.
3720 Simply cross reference those again to get the true type.
3721 The forward references are not entered in the pending list and
3722 in the symbol table. */
3724 (*debug_swap
->swap_tir_in
) (bigend
,
3725 &(debug_info
->external_aux
3726 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3728 if (tir
.tq0
!= tqNil
)
3729 complain (&illegal_forward_tq0_complaint
, sym_name
);
3733 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3735 *pname
= "<undefined>";
3742 (debug_info
->external_aux
3743 + fh
->iauxBase
+ sh
.index
+ 1),
3744 tpp
, type_code
, pname
,
3745 fh
->fBigendian
, sym_name
);
3749 /* Follow a forward typedef. This might recursively
3750 call cross_ref till we get a non typedef'ed type.
3751 FIXME: This is not correct behaviour, but gdb currently
3752 cannot handle typedefs without type copying. Type
3753 copying is impossible as we might have mutual forward
3754 references between two files and the copied type would not
3755 get filled in when we later parse its definition. */
3756 *tpp
= parse_type (xref_fd
,
3757 debug_info
->external_aux
+ fh
->iauxBase
,
3761 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3762 add_pending (fh
, esh
, *tpp
);
3766 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3767 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3773 else if (sh
.st
== stTypedef
)
3775 /* Parse the type for a normal typedef. This might recursively call
3776 cross_ref till we get a non typedef'ed type.
3777 FIXME: This is not correct behaviour, but gdb currently
3778 cannot handle typedefs without type copying. But type copying is
3779 impossible as we might have mutual forward references between
3780 two files and the copied type would not get filled in when
3781 we later parse its definition. */
3782 *tpp
= parse_type (xref_fd
,
3783 debug_info
->external_aux
+ fh
->iauxBase
,
3787 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3791 /* Cross reference to a struct/union/enum which is defined
3792 in another file in the same compilation unit but that file
3793 has not been parsed yet.
3794 Initialize the type only, it will be filled in when
3795 it's definition is parsed. */
3796 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3798 add_pending (fh
, esh
, *tpp
);
3801 /* We used one auxent normally, two if we got a "next one" rf. */
3806 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3807 keeping the symtab sorted */
3809 static struct symbol
*
3810 mylookup_symbol (name
, block
, namespace, class)
3812 register struct block
*block
;
3813 namespace_enum
namespace;
3814 enum address_class
class;
3816 register int bot
, top
, inc
;
3817 register struct symbol
*sym
;
3820 top
= BLOCK_NSYMS (block
);
3824 sym
= BLOCK_SYM (block
, bot
);
3825 if (SYMBOL_NAME (sym
)[0] == inc
3826 && SYMBOL_NAMESPACE (sym
) == namespace
3827 && SYMBOL_CLASS (sym
) == class
3828 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3832 block
= BLOCK_SUPERBLOCK (block
);
3834 return mylookup_symbol (name
, block
, namespace, class);
3839 /* Add a new symbol S to a block B.
3840 Infrequently, we will need to reallocate the block to make it bigger.
3841 We only detect this case when adding to top_stack->cur_block, since
3842 that's the only time we know how big the block is. FIXME. */
3849 int nsyms
= BLOCK_NSYMS (b
)++;
3850 struct block
*origb
;
3851 struct parse_stack
*stackp
;
3853 if (b
== top_stack
->cur_block
&&
3854 nsyms
>= top_stack
->maxsyms
)
3856 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3857 /* In this case shrink_block is actually grow_block, since
3858 BLOCK_NSYMS(b) is larger than its current size. */
3860 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3862 /* Now run through the stack replacing pointers to the
3863 original block. shrink_block has already done this
3864 for the blockvector and BLOCK_FUNCTION. */
3865 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3867 if (stackp
->cur_block
== origb
)
3869 stackp
->cur_block
= b
;
3870 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3874 BLOCK_SYM (b
, nsyms
) = s
;
3877 /* Add a new block B to a symtab S */
3884 struct blockvector
*bv
= BLOCKVECTOR (s
);
3886 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3887 (sizeof (struct blockvector
)
3888 + BLOCKVECTOR_NBLOCKS (bv
)
3889 * sizeof (bv
->block
)));
3890 if (bv
!= BLOCKVECTOR (s
))
3891 BLOCKVECTOR (s
) = bv
;
3893 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3896 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3897 MIPS' linenumber encoding might need more than one byte
3898 to describe it, LAST is used to detect these continuation lines.
3900 Combining lines with the same line number seems like a bad idea.
3901 E.g: There could be a line number entry with the same line number after the
3902 prologue and GDB should not ignore it (this is a better way to find
3903 a prologue than mips_skip_prologue).
3904 But due to the compressed line table format there are line number entries
3905 for the same line which are needed to bridge the gap to the next
3906 line number entry. These entries have a bogus address info with them
3907 and we are unable to tell them from intended duplicate line number
3909 This is another reason why -ggdb debugging format is preferable. */
3912 add_line (lt
, lineno
, adr
, last
)
3913 struct linetable
*lt
;
3918 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3919 Change them to something sensible. */
3923 last
= -2; /* make sure we record first line */
3925 if (last
== lineno
) /* skip continuation lines */
3928 lt
->item
[lt
->nitems
].line
= lineno
;
3929 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3933 /* Sorting and reordering procedures */
3935 /* Blocks with a smaller low bound should come first */
3938 compare_blocks (arg1
, arg2
)
3942 register int addr_diff
;
3943 struct block
**b1
= (struct block
**) arg1
;
3944 struct block
**b2
= (struct block
**) arg2
;
3946 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3948 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3952 /* Sort the blocks of a symtab S.
3953 Reorder the blocks in the blockvector by code-address,
3954 as required by some MI search routines */
3960 struct blockvector
*bv
= BLOCKVECTOR (s
);
3962 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3965 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3966 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3967 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3968 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3972 * This is very unfortunate: normally all functions are compiled in
3973 * the order they are found, but if the file is compiled -O3 things
3974 * are very different. It would be nice to find a reliable test
3975 * to detect -O3 images in advance.
3977 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3978 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3979 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3980 sizeof (struct block
*),
3984 register CORE_ADDR high
= 0;
3985 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3987 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3988 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3989 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3990 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3993 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3994 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3996 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3997 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3998 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3999 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4003 /* Constructor/restructor/destructor procedures */
4005 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
4006 MAXSYMS and linenumbers MAXLINES we'll put in it */
4008 static struct symtab
*
4009 new_symtab (name
, maxsyms
, maxlines
, objfile
)
4013 struct objfile
*objfile
;
4015 struct symtab
*s
= allocate_symtab (name
, objfile
);
4017 LINETABLE (s
) = new_linetable (maxlines
);
4019 /* All symtabs must have at least two blocks */
4020 BLOCKVECTOR (s
) = new_bvect (2);
4021 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
4022 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
4023 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4024 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4026 s
->free_code
= free_linetable
;
4027 s
->debugformat
= obsavestring ("ECOFF", 5,
4028 &objfile
-> symbol_obstack
);
4032 /* Allocate a new partial_symtab NAME */
4034 static struct partial_symtab
*
4035 new_psymtab (name
, objfile
, section_offsets
)
4037 struct objfile
*objfile
;
4038 struct section_offsets
*section_offsets
;
4040 struct partial_symtab
*psymtab
;
4042 psymtab
= allocate_psymtab (name
, objfile
);
4043 psymtab
->section_offsets
= section_offsets
;
4045 /* Keep a backpointer to the file's symbols */
4047 psymtab
->read_symtab_private
= ((char *)
4048 obstack_alloc (&objfile
->psymbol_obstack
,
4049 sizeof (struct symloc
)));
4050 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4051 CUR_BFD (psymtab
) = cur_bfd
;
4052 DEBUG_SWAP (psymtab
) = debug_swap
;
4053 DEBUG_INFO (psymtab
) = debug_info
;
4054 PENDING_LIST (psymtab
) = pending_list
;
4056 /* The way to turn this into a symtab is to call... */
4057 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4062 /* Allocate a linetable array of the given SIZE. Since the struct
4063 already includes one item, we subtract one when calculating the
4064 proper size to allocate. */
4066 static struct linetable
*
4067 new_linetable (size
)
4070 struct linetable
*l
;
4072 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4073 l
= (struct linetable
*) xmalloc (size
);
4078 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4079 I am not so sure about the 3.4 ones.
4081 Since the struct linetable already includes one item, we subtract one when
4082 calculating the proper size to allocate. */
4084 static struct linetable
*
4085 shrink_linetable (lt
)
4086 struct linetable
*lt
;
4089 return (struct linetable
*) xrealloc ((PTR
) lt
,
4090 (sizeof (struct linetable
)
4092 * sizeof (lt
->item
))));
4095 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4097 static struct blockvector
*
4101 struct blockvector
*bv
;
4104 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4105 bv
= (struct blockvector
*) xzalloc (size
);
4107 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4112 /* Allocate and zero a new block of MAXSYMS symbols */
4114 static struct block
*
4118 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
4120 return (struct block
*) xzalloc (size
);
4123 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
4124 Shrink_block can also be used by add_symbol to grow a block. */
4126 static struct block
*
4132 struct blockvector
*bv
= BLOCKVECTOR (s
);
4135 /* Just reallocate it and fix references to the old one */
4137 new = (struct block
*) xrealloc ((PTR
) b
,
4138 (sizeof (struct block
)
4139 + ((BLOCK_NSYMS (b
) - 1)
4140 * sizeof (struct symbol
*))));
4142 /* Should chase pointers to old one. Fortunately, that`s just
4143 the block`s function and inferior blocks */
4144 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
4145 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
4146 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
4147 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
4148 BLOCKVECTOR_BLOCK (bv
, i
) = new;
4149 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
4150 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
4154 /* Create a new symbol with printname NAME */
4156 static struct symbol
*
4160 struct symbol
*s
= ((struct symbol
*)
4161 obstack_alloc (¤t_objfile
->symbol_obstack
,
4162 sizeof (struct symbol
)));
4164 memset ((PTR
) s
, 0, sizeof (*s
));
4165 SYMBOL_NAME (s
) = obsavestring (name
, strlen (name
),
4166 ¤t_objfile
->symbol_obstack
);
4167 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4168 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
4172 /* Create a new type with printname NAME */
4174 static struct type
*
4180 t
= alloc_type (current_objfile
);
4181 TYPE_NAME (t
) = name
;
4182 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4186 /* Read ECOFF debugging information from a BFD section. This is
4187 called from elfread.c. It parses the section into a
4188 ecoff_debug_info struct, and then lets the rest of the file handle
4192 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
4193 struct objfile
*objfile
;
4194 const struct ecoff_debug_swap
*swap
;
4196 struct section_offsets
*section_offsets
;
4198 bfd
*abfd
= objfile
->obfd
;
4199 struct ecoff_debug_info
*info
;
4201 info
= ((struct ecoff_debug_info
*)
4202 obstack_alloc (&objfile
->psymbol_obstack
,
4203 sizeof (struct ecoff_debug_info
)));
4205 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4206 error ("Error reading ECOFF debugging information: %s",
4207 bfd_errmsg (bfd_get_error ()));
4209 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
4213 /* Things used for calling functions in the inferior.
4214 These functions are exported to our companion
4215 mips-tdep.c file and are here because they play
4216 with the symbol-table explicitly. */
4218 /* Sigtramp: make sure we have all the necessary information
4219 about the signal trampoline code. Since the official code
4220 from MIPS does not do so, we make up that information ourselves.
4221 If they fix the library (unlikely) this code will neutralize itself. */
4223 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4224 here because it calls functions defined in this file, but perhaps
4225 this could be handled in a better way. Only compile it in when
4226 tm-mips.h is included. */
4235 struct block
*b
, *b0
= NULL
;
4237 sigtramp_address
= -1;
4239 /* We have to handle the following cases here:
4240 a) The Mips library has a sigtramp label within sigvec.
4241 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4242 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
4245 b0
= SYMBOL_BLOCK_VALUE (s
);
4246 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
4250 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4251 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
4254 /* But maybe this program uses its own version of sigvec */
4258 /* Did we or MIPSco fix the library ? */
4259 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
4261 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
4262 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
4266 sigtramp_address
= SYMBOL_VALUE (s
);
4267 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
4269 /* But what symtab does it live in ? */
4270 st
= find_pc_symtab (SYMBOL_VALUE (s
));
4273 * Ok, there goes the fix: turn it into a procedure, with all the
4274 * needed info. Note we make it a nested procedure of sigvec,
4275 * which is the way the (assembly) code is actually written.
4277 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4278 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4279 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4281 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = mdebug_type_void
;
4283 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4285 SYMBOL_BLOCK_VALUE (s
) = b
;
4286 BLOCK_START (b
) = sigtramp_address
;
4287 BLOCK_END (b
) = sigtramp_end
;
4288 BLOCK_FUNCTION (b
) = s
;
4289 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4293 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4295 struct mips_extra_func_info
*e
=
4296 ((struct mips_extra_func_info
*)
4297 xzalloc (sizeof (struct mips_extra_func_info
)));
4299 e
->numargs
= 0; /* the kernel thinks otherwise */
4300 e
->pdr
.frameoffset
= 32;
4301 e
->pdr
.framereg
= SP_REGNUM
;
4302 /* Note that setting pcreg is no longer strictly necessary as
4303 mips_frame_saved_pc is now aware of signal handler frames. */
4304 e
->pdr
.pcreg
= PC_REGNUM
;
4305 e
->pdr
.regmask
= -2;
4306 /* Offset to saved r31, in the sigtramp case the saved registers
4307 are above the frame in the sigcontext.
4308 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4309 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4310 and 32 * 4 bytes for the floating point registers. */
4311 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4312 e
->pdr
.fregmask
= -1;
4313 /* Offset to saved f30 (first saved *double* register). */
4314 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4315 e
->pdr
.isym
= (long) s
;
4316 e
->pdr
.adr
= sigtramp_address
;
4318 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4319 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4320 SYMBOL_VALUE (s
) = (long) e
;
4321 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4322 SYMBOL_CLASS (s
) = LOC_CONST
;
4323 SYMBOL_TYPE (s
) = mdebug_type_void
;
4324 current_objfile
= NULL
;
4327 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4330 #endif /* TM_MIPS_H */
4333 _initialize_mdebugread ()
4336 init_type (TYPE_CODE_VOID
, 1,
4338 "void", (struct objfile
*) NULL
);
4340 init_type (TYPE_CODE_INT
, 1,
4342 "char", (struct objfile
*) NULL
);
4343 mdebug_type_unsigned_char
=
4344 init_type (TYPE_CODE_INT
, 1,
4346 "unsigned char", (struct objfile
*) NULL
);
4348 init_type (TYPE_CODE_INT
, 2,
4350 "short", (struct objfile
*) NULL
);
4351 mdebug_type_unsigned_short
=
4352 init_type (TYPE_CODE_INT
, 2,
4354 "unsigned short", (struct objfile
*) NULL
);
4355 mdebug_type_int_32
=
4356 init_type (TYPE_CODE_INT
, 4,
4358 "int", (struct objfile
*) NULL
);
4359 mdebug_type_unsigned_int_32
=
4360 init_type (TYPE_CODE_INT
, 4,
4362 "unsigned int", (struct objfile
*) NULL
);
4363 mdebug_type_int_64
=
4364 init_type (TYPE_CODE_INT
, 8,
4366 "int", (struct objfile
*) NULL
);
4367 mdebug_type_unsigned_int_64
=
4368 init_type (TYPE_CODE_INT
, 8,
4370 "unsigned int", (struct objfile
*) NULL
);
4371 mdebug_type_long_32
=
4372 init_type (TYPE_CODE_INT
, 4,
4374 "long", (struct objfile
*) NULL
);
4375 mdebug_type_unsigned_long_32
=
4376 init_type (TYPE_CODE_INT
, 4,
4378 "unsigned long", (struct objfile
*) NULL
);
4379 mdebug_type_long_64
=
4380 init_type (TYPE_CODE_INT
, 8,
4382 "long", (struct objfile
*) NULL
);
4383 mdebug_type_unsigned_long_64
=
4384 init_type (TYPE_CODE_INT
, 8,
4386 "unsigned long", (struct objfile
*) NULL
);
4387 mdebug_type_long_long_64
=
4388 init_type (TYPE_CODE_INT
, 8,
4390 "long long", (struct objfile
*) NULL
);
4391 mdebug_type_unsigned_long_long_64
=
4392 init_type (TYPE_CODE_INT
, 8,
4394 "unsigned long long", (struct objfile
*) NULL
);
4395 mdebug_type_adr_32
=
4396 init_type (TYPE_CODE_PTR
, 4,
4398 "adr_32", (struct objfile
*) NULL
);
4399 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4400 mdebug_type_adr_64
=
4401 init_type (TYPE_CODE_PTR
, 8,
4403 "adr_64", (struct objfile
*) NULL
);
4404 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4406 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4408 "float", (struct objfile
*) NULL
);
4409 mdebug_type_double
=
4410 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4412 "double", (struct objfile
*) NULL
);
4413 mdebug_type_complex
=
4414 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4416 "complex", (struct objfile
*) NULL
);
4417 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4418 mdebug_type_double_complex
=
4419 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4421 "double complex", (struct objfile
*) NULL
);
4422 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4424 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4426 mdebug_type_string
=
4427 init_type (TYPE_CODE_STRING
,
4428 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4430 (struct objfile
*) NULL
);
4432 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4433 good? Would we be better off with TYPE_CODE_ERROR? Should
4434 TYPE_CODE_ERROR print things in hex if it knows the size? */
4435 mdebug_type_fixed_dec
=
4436 init_type (TYPE_CODE_INT
,
4437 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4439 (struct objfile
*) NULL
);
4441 mdebug_type_float_dec
=
4442 init_type (TYPE_CODE_ERROR
,
4443 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4444 0, "floating decimal",
4445 (struct objfile
*) NULL
);
4447 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
4448 "<function, no debug info>", NULL
);
4449 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = mdebug_type_int
;
4450 nodebug_var_symbol_type
=
4451 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4452 "<variable, no debug info>", NULL
);