1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
5 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 /* This module provides the function mdebug_build_psymtabs. It reads
25 ECOFF debugging information into partial symbol tables. The
26 debugging information is read from two structures. A struct
27 ecoff_debug_swap includes the sizes of each ECOFF structure and
28 swapping routines; these are fixed for a particular target. A
29 struct ecoff_debug_info points to the debugging information for a
30 particular object file.
32 ECOFF symbol tables are mostly written in the byte order of the
33 target machine. However, one section of the table (the auxiliary
34 symbol information) is written in the host byte order. There is a
35 bit in the other symbol info which describes which host byte order
36 was used. ECOFF thereby takes the trophy from Intel `b.out' for
37 the most brain-dead adaptation of a file format to byte order.
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
50 #include "stabsread.h"
51 #include "complaints.h"
53 #if !defined (SEEK_SET)
58 /* These are needed if the tm.h file does not contain the necessary
59 mips specific definitions. */
61 #ifndef MIPS_EFI_SYMBOL_NAME
62 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
{
68 } *mips_extra_func_info_t
;
75 #include <sys/types.h>
78 #include <sys/param.h>
83 #include "gdb-stabs.h"
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
93 #include "expression.h"
94 #include "language.h" /* Needed inside partial-stab.h */
96 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
97 #ifndef ECOFF_REG_TO_REGNUM
98 #define ECOFF_REG_TO_REGNUM(num) (num)
101 /* Each partial symbol table entry contains a pointer to private data
102 for the read_symtab() function to use when expanding a partial
103 symbol table entry to a full symbol table entry.
105 For mdebugread this structure contains the index of the FDR that this
106 psymtab represents and a pointer to the BFD that the psymtab was
109 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
110 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
111 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
112 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
113 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
114 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
120 const struct ecoff_debug_swap
*debug_swap
;
121 struct ecoff_debug_info
*debug_info
;
122 struct mdebug_pending
**pending_list
;
123 EXTR
*extern_tab
; /* Pointer to external symbols for this file. */
124 int extern_count
; /* Size of extern_tab. */
125 enum language pst_language
;
128 /* Things we import explicitly from other modules */
130 extern int info_verbose
;
132 /* Various complaints about symbol reading that don't abort the process */
134 static struct complaint bad_file_number_complaint
=
135 {"bad file number %d", 0, 0};
137 static struct complaint index_complaint
=
138 {"bad aux index at symbol %s", 0, 0};
140 static struct complaint aux_index_complaint
=
141 {"bad proc end in aux found from symbol %s", 0, 0};
143 static struct complaint block_index_complaint
=
144 {"bad aux index at block symbol %s", 0, 0};
146 static struct complaint unknown_ext_complaint
=
147 {"unknown external symbol %s", 0, 0};
149 static struct complaint unknown_sym_complaint
=
150 {"unknown local symbol %s", 0, 0};
152 static struct complaint unknown_st_complaint
=
153 {"with type %d", 0, 0};
155 static struct complaint block_overflow_complaint
=
156 {"block containing %s overfilled", 0, 0};
158 static struct complaint basic_type_complaint
=
159 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
161 static struct complaint unknown_type_qual_complaint
=
162 {"unknown type qualifier 0x%x", 0, 0};
164 static struct complaint array_index_type_complaint
=
165 {"illegal array index type for %s, assuming int", 0, 0};
167 static struct complaint bad_tag_guess_complaint
=
168 {"guessed tag type of %s incorrectly", 0, 0};
170 static struct complaint block_member_complaint
=
171 {"declaration block contains unhandled symbol type %d", 0, 0};
173 static struct complaint stEnd_complaint
=
174 {"stEnd with storage class %d not handled", 0, 0};
176 static struct complaint unknown_mdebug_symtype_complaint
=
177 {"unknown symbol type 0x%x", 0, 0};
179 static struct complaint stab_unknown_complaint
=
180 {"unknown stabs symbol %s", 0, 0};
182 static struct complaint pdr_for_nonsymbol_complaint
=
183 {"PDR for %s, but no symbol", 0, 0};
185 static struct complaint pdr_static_symbol_complaint
=
186 {"can't handle PDR for static proc at 0x%lx", 0, 0};
188 static struct complaint bad_setjmp_pdr_complaint
=
189 {"fixing bad setjmp PDR from libc", 0, 0};
191 static struct complaint bad_fbitfield_complaint
=
192 {"can't handle TIR fBitfield for %s", 0, 0};
194 static struct complaint bad_continued_complaint
=
195 {"illegal TIR continued for %s", 0, 0};
197 static struct complaint bad_rfd_entry_complaint
=
198 {"bad rfd entry for %s: file %d, index %d", 0, 0};
200 static struct complaint unexpected_type_code_complaint
=
201 {"unexpected type code for %s", 0, 0};
203 static struct complaint unable_to_cross_ref_complaint
=
204 {"unable to cross ref btTypedef for %s", 0, 0};
206 static struct complaint illegal_forward_tq0_complaint
=
207 {"illegal tq0 in forward typedef for %s", 0, 0};
209 static struct complaint illegal_forward_bt_complaint
=
210 {"illegal bt %d in forward typedef for %s", 0, 0};
212 static struct complaint bad_linetable_guess_complaint
=
213 {"guessed size of linetable for %s incorrectly", 0, 0};
215 static struct complaint bad_ext_ifd_complaint
=
216 {"bad ifd for external symbol: %d (max %d)", 0, 0};
218 static struct complaint bad_ext_iss_complaint
=
219 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
221 /* Macros and extra defs */
223 /* Puns: hard to find whether -g was used and how */
225 #define MIN_GLEVEL GLEVEL_0
226 #define compare_glevel(a,b) \
227 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
228 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
230 /* Things that really are local to this module */
232 /* Remember what we deduced to be the source language of this psymtab. */
234 static enum language psymtab_language
= language_unknown
;
240 /* How to parse debugging information for CUR_BFD. */
242 static const struct ecoff_debug_swap
*debug_swap
;
244 /* Pointers to debugging information for CUR_BFD. */
246 static struct ecoff_debug_info
*debug_info
;
248 /* Pointer to current file decriptor record, and its index */
253 /* Index of current symbol */
257 /* Note how much "debuggable" this image is. We would like
258 to see at least one FDR with full symbols */
263 /* When examining .o files, report on undefined symbols */
265 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
267 /* Pseudo symbol to use when putting stabs into the symbol table. */
269 static char stabs_symbol
[] = STABS_SYMBOL
;
271 /* Types corresponding to btComplex, btDComplex, etc. These are here
272 rather than in gdbtypes.c or some such, because the meaning of codes
273 like btComplex is specific to the mdebug debug format. FIXME: We should
274 be using our own types thoughout this file, instead of sometimes using
277 static struct type
*mdebug_type_fixed_dec
;
278 static struct type
*mdebug_type_float_dec
;
279 static struct type
*mdebug_type_string
;
281 /* Forward declarations */
284 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
287 parse_partial_symbols
PARAMS ((struct objfile
*,
288 struct section_offsets
*));
291 *get_rfd
PARAMS ((int, int));
294 has_opaque_xref
PARAMS ((FDR
*, SYMR
*));
297 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
298 char **, int, char *));
300 static struct symbol
*
301 new_symbol
PARAMS ((char *));
304 new_type
PARAMS ((char *));
306 static struct block
*
307 new_block
PARAMS ((int));
309 static struct symtab
*
310 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
312 static struct linetable
*
313 new_linetable
PARAMS ((int));
315 static struct blockvector
*
316 new_bvect
PARAMS ((int));
319 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int, struct section_offsets
*));
322 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
324 static struct symbol
*
325 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
326 enum address_class
));
328 static struct block
*
329 shrink_block
PARAMS ((struct block
*, struct symtab
*));
332 xzalloc
PARAMS ((unsigned int));
335 sort_blocks
PARAMS ((struct symtab
*));
338 compare_blocks
PARAMS ((const void *, const void *));
340 static struct partial_symtab
*
341 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
344 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
347 add_block
PARAMS ((struct block
*, struct symtab
*));
350 add_symbol
PARAMS ((struct symbol
*, struct block
*));
353 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
355 static struct linetable
*
356 shrink_linetable
PARAMS ((struct linetable
*));
359 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int));
362 mdebug_next_symbol_text
PARAMS ((void));
364 /* Address bounds for the signal trampoline in inferior, if any */
366 CORE_ADDR sigtramp_address
, sigtramp_end
;
368 /* Allocate zeroed memory */
374 PTR p
= xmalloc (size
);
380 /* Exported procedure: Builds a symtab from the PST partial one.
381 Restores the environment in effect when PST was created, delegates
382 most of the work to an ancillary procedure, and sorts
383 and reorders the symtab list at the end */
386 mdebug_psymtab_to_symtab (pst
)
387 struct partial_symtab
*pst
;
395 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
396 gdb_flush (gdb_stdout
);
399 next_symbol_text_func
= mdebug_next_symbol_text
;
401 psymtab_to_symtab_1 (pst
, pst
->filename
);
403 /* Match with global symbols. This only needs to be done once,
404 after all of the symtabs and dependencies have been read in. */
405 scan_file_globals (pst
->objfile
);
408 printf_filtered ("done.\n");
411 /* File-level interface functions */
413 /* Find a file descriptor given its index RF relative to a file CF */
423 fdrs
= debug_info
->fdr
;
425 /* Object files do not have the RFD table, all refs are absolute */
428 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
429 ((char *) debug_info
->external_rfd
431 * debug_swap
->external_rfd_size
)),
436 /* Return a safer print NAME for a file descriptor */
443 return "<stripped file>";
446 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
450 /* Read in and parse the symtab of the file OBJFILE. Symbols from
451 different sections are relocated via the SECTION_OFFSETS. */
454 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
455 struct objfile
*objfile
;
456 const struct ecoff_debug_swap
*swap
;
457 struct ecoff_debug_info
*info
;
458 struct section_offsets
*section_offsets
;
460 cur_bfd
= objfile
->obfd
;
464 /* Make sure all the FDR information is swapped in. */
465 if (info
->fdr
== (FDR
*) NULL
)
471 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
472 (info
->symbolic_header
.ifdMax
474 fdr_src
= info
->external_fdr
;
476 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
478 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
479 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
482 parse_partial_symbols (objfile
, section_offsets
);
485 /* Check to make sure file was compiled with -g. If not, warn the
486 user of this limitation. */
487 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
489 if (max_gdbinfo
== 0)
490 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
492 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
493 gdb_flush (gdb_stdout
);
498 /* Local utilities */
500 /* Map of FDR indexes to partial symtabs */
504 struct partial_symtab
*pst
; /* the psymtab proper */
505 long n_globals
; /* exported globals (external symbols) */
506 long globals_offset
; /* cumulative */
510 /* Utility stack, used to nest procedures and blocks properly.
511 It is a doubly linked list, to avoid too many alloc/free.
512 Since we might need it quite a few times it is NOT deallocated
515 static struct parse_stack
517 struct parse_stack
*next
, *prev
;
518 struct symtab
*cur_st
; /* Current symtab. */
519 struct block
*cur_block
; /* Block in it. */
521 /* What are we parsing. stFile, or stBlock are for files and
522 blocks. stProc or stStaticProc means we have seen the start of a
523 procedure, but not the start of the block within in. When we see
524 the start of that block, we change it to stNil, without pushing a
525 new block, i.e. stNil means both a procedure and a block. */
529 int maxsyms
; /* Max symbols in this block. */
530 struct type
*cur_type
; /* Type we parse fields for. */
531 int cur_field
; /* Field number in cur_type. */
532 CORE_ADDR procadr
; /* Start addres of this procedure */
533 int numargs
; /* Its argument count */
536 *top_stack
; /* Top stack ptr */
539 /* Enter a new lexical context */
544 struct parse_stack
*new;
546 /* Reuse frames if possible */
547 if (top_stack
&& top_stack
->prev
)
548 new = top_stack
->prev
;
550 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
551 /* Initialize new frame with previous content */
554 register struct parse_stack
*prev
= new->prev
;
557 top_stack
->prev
= new;
559 new->next
= top_stack
;
564 /* Exit a lexical context */
572 top_stack
= top_stack
->next
;
576 /* Cross-references might be to things we haven't looked at
577 yet, e.g. type references. To avoid too many type
578 duplications we keep a quick fixup table, an array
579 of lists of references indexed by file descriptor */
581 struct mdebug_pending
583 struct mdebug_pending
*next
; /* link */
584 char *s
; /* the unswapped symbol */
585 struct type
*t
; /* its partial type descriptor */
589 /* The pending information is kept for an entire object file, and used
590 to be in the sym_private field. I took it out when I split
591 mdebugread from mipsread, because this might not be the only type
592 of symbols read from an object file. Instead, we allocate the
593 pending information table when we create the partial symbols, and
594 we store a pointer to the single table in each psymtab. */
596 static struct mdebug_pending
**pending_list
;
598 /* Check whether we already saw symbol SH in file FH */
600 static struct mdebug_pending
*
601 is_pending_symbol (fh
, sh
)
605 int f_idx
= fh
- debug_info
->fdr
;
606 register struct mdebug_pending
*p
;
608 /* Linear search is ok, list is typically no more than 10 deep */
609 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
615 /* Add a new symbol SH of type T */
618 add_pending (fh
, sh
, t
)
623 int f_idx
= fh
- debug_info
->fdr
;
624 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
626 /* Make sure we do not make duplicates */
629 p
= ((struct mdebug_pending
*)
630 obstack_alloc (¤t_objfile
->psymbol_obstack
,
631 sizeof (struct mdebug_pending
)));
634 p
->next
= pending_list
[f_idx
];
635 pending_list
[f_idx
] = p
;
640 /* Parsing Routines proper. */
642 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
643 For blocks, procedures and types we open a new lexical context.
644 This is basically just a big switch on the symbol's type. Argument
645 AX is the base pointer of aux symbols for this file (fh->iauxBase).
646 EXT_SH points to the unswapped symbol, which is needed for struct,
647 union, etc., types; it is NULL for an EXTR. BIGEND says whether
648 aux symbols are big-endian or little-endian. Return count of
649 SYMR's handled (normally one). */
652 parse_symbol (sh
, ax
, ext_sh
, bigend
, section_offsets
)
657 struct section_offsets
*section_offsets
;
659 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
660 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
661 debug_swap
->swap_sym_in
;
665 struct mdebug_pending
*pend
;
669 enum address_class
class;
671 long svalue
= sh
->value
;
674 if (ext_sh
== (char *) NULL
)
675 name
= debug_info
->ssext
+ sh
->iss
;
677 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
682 /* The value of a stEnd symbol is the displacement from the
683 corresponding start symbol value, do not relocate it. */
685 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
692 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
696 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
705 case stGlobal
: /* external symbol, goes into global block */
707 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
709 s
= new_symbol (name
);
710 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
713 case stStatic
: /* static data, goes into current block. */
715 b
= top_stack
->cur_block
;
716 s
= new_symbol (name
);
717 if (sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
719 /* It is a FORTRAN common block. At least for SGI Fortran the
720 address is not in the symbol; we need to fix it later in
721 scan_file_globals. */
722 int bucket
= hashname (SYMBOL_NAME (s
));
723 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
724 global_sym_chain
[bucket
] = s
;
727 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
730 case stLocal
: /* local variable, goes into current block */
731 if (sh
->sc
== scRegister
)
733 class = LOC_REGISTER
;
734 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
738 b
= top_stack
->cur_block
;
739 s
= new_symbol (name
);
740 SYMBOL_VALUE (s
) = svalue
;
742 data
: /* Common code for symbols describing data */
743 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
744 SYMBOL_CLASS (s
) = class;
747 /* Type could be missing in a number of cases */
748 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
749 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
751 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
752 /* Value of a data symbol is its memory address */
755 case stParam
: /* arg to procedure, goes into current block */
757 top_stack
->numargs
++;
759 /* Special GNU C++ name. */
760 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
761 name
= "this"; /* FIXME, not alloc'd in obstack */
762 s
= new_symbol (name
);
764 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
768 /* Pass by value in register. */
769 SYMBOL_CLASS(s
) = LOC_REGPARM
;
770 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
773 /* Pass by reference on stack. */
774 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
777 /* Pass by reference in register. */
778 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
779 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
782 /* Pass by value on stack. */
783 SYMBOL_CLASS(s
) = LOC_ARG
;
786 SYMBOL_VALUE (s
) = svalue
;
787 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
788 add_symbol (s
, top_stack
->cur_block
);
791 case stLabel
: /* label, goes into current block */
792 s
= new_symbol (name
);
793 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
794 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
795 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
796 SYMBOL_TYPE (s
) = builtin_type_int
;
797 add_symbol (s
, top_stack
->cur_block
);
800 case stProc
: /* Procedure, usually goes into global block */
801 case stStaticProc
: /* Static procedure, goes into current block */
802 s
= new_symbol (name
);
803 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
804 SYMBOL_CLASS (s
) = LOC_BLOCK
;
805 /* Type of the return value */
806 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
807 t
= builtin_type_int
;
809 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
810 b
= top_stack
->cur_block
;
811 if (sh
->st
== stProc
)
813 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
814 /* The next test should normally be true, but provides a
815 hook for nested functions (which we don't want to make
817 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
818 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
819 /* Irix 5 sometimes has duplicate names for the same
820 function. We want to add such names up at the global
821 level, not as a nested function. */
822 else if (sh
->value
== top_stack
->procadr
)
823 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
827 /* Make a type for the procedure itself */
828 SYMBOL_TYPE (s
) = lookup_function_type (t
);
830 /* Create and enter a new lexical context */
831 b
= new_block (top_stack
->maxsyms
);
832 SYMBOL_BLOCK_VALUE (s
) = b
;
833 BLOCK_FUNCTION (b
) = s
;
834 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
835 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
836 add_block (b
, top_stack
->cur_st
);
838 /* Not if we only have partial info */
839 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
843 top_stack
->cur_block
= b
;
844 top_stack
->blocktype
= sh
->st
;
845 top_stack
->cur_type
= SYMBOL_TYPE (s
);
846 top_stack
->cur_field
= -1;
847 top_stack
->procadr
= sh
->value
;
848 top_stack
->numargs
= 0;
851 /* Beginning of code for structure, union, and enum definitions.
852 They all share a common set of local variables, defined here. */
854 enum type_code type_code
;
860 case stStruct
: /* Start a block defining a struct type */
861 type_code
= TYPE_CODE_STRUCT
;
862 goto structured_common
;
864 case stUnion
: /* Start a block defining a union type */
865 type_code
= TYPE_CODE_UNION
;
866 goto structured_common
;
868 case stEnum
: /* Start a block defining an enum type */
869 type_code
= TYPE_CODE_ENUM
;
870 goto structured_common
;
872 case stBlock
: /* Either a lexical block, or some type */
873 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
874 goto case_stBlock_code
; /* Lexical block */
876 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
878 /* Common code for handling struct, union, enum, and/or as-yet-
879 unknown-type blocks of info about structured data. `type_code'
880 has been set to the proper TYPE_CODE, if we know it. */
883 top_stack
->blocktype
= stBlock
;
885 /* First count the number of fields and the highest value. */
888 for (ext_tsym
= ext_sh
+ external_sym_size
;
890 ext_tsym
+= external_sym_size
)
894 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
902 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
903 /* If the type of the member is Nil (or Void),
904 without qualifiers, assume the tag is an
906 if (tsym
.index
== indexNil
)
907 type_code
= TYPE_CODE_ENUM
;
910 (*debug_swap
->swap_tir_in
) (bigend
,
911 &ax
[tsym
.index
].a_ti
,
913 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
915 type_code
= TYPE_CODE_ENUM
;
918 if (tsym
.value
> max_value
)
919 max_value
= tsym
.value
;
928 /* This is a no-op; is it trying to tell us something
929 we should be checking? */
930 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
934 /* This is something like a struct within a
935 struct. Skip over the fields of the inner
936 struct. The -1 is because the for loop will
937 increment ext_tsym. */
938 ext_tsym
= ((char *) debug_info
->external_sym
939 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
940 * external_sym_size
));
946 /* mips cc puts out a typedef for struct x if it is not yet
947 defined when it encounters
948 struct y { struct x *xp; };
953 /* Irix5 cc puts out a stIndirect for struct x if it is not
954 yet defined when it encounters
955 struct y { struct x *xp; };
960 complain (&block_member_complaint
, tsym
.st
);
965 /* In an stBlock, there is no way to distinguish structs,
966 unions, and enums at this point. This is a bug in the
967 original design (that has been fixed with the recent
968 addition of the stStruct, stUnion, and stEnum symbol
969 types.) The way you can tell is if/when you see a variable
970 or field of that type. In that case the variable's type
971 (in the AUX table) says if the type is struct, union, or
972 enum, and points back to the stBlock here. So you can
973 patch the tag kind up later - but only if there actually is
974 a variable or field of that type.
976 So until we know for sure, we will guess at this point.
978 If the first member has index==indexNil or a void type,
979 assume we have an enumeration.
980 Otherwise, if there is more than one member, and all
981 the members have offset 0, assume we have a union.
982 Otherwise, assume we have a struct.
984 The heuristic could guess wrong in the case of of an
985 enumeration with no members or a union with one (or zero)
986 members, or when all except the last field of a struct have
987 width zero. These are uncommon and/or illegal situations,
988 and in any case guessing wrong probably doesn't matter
991 But if we later do find out we were wrong, we fixup the tag
992 kind. Members of an enumeration must be handled
993 differently from struct/union fields, and that is harder to
994 patch up, but luckily we shouldn't need to. (If there are
995 any enumeration members, we can tell for sure it's an enum
998 if (type_code
== TYPE_CODE_UNDEF
)
999 if (nfields
> 1 && max_value
== 0)
1000 type_code
= TYPE_CODE_UNION
;
1002 type_code
= TYPE_CODE_STRUCT
;
1004 /* Create a new type or use the pending type. */
1005 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1006 if (pend
== (struct mdebug_pending
*) NULL
)
1008 t
= new_type (NULL
);
1009 add_pending (cur_fdr
, ext_sh
, t
);
1014 /* Do not set the tag name if it is a compiler generated tag name
1015 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1016 Alpha cc puts out an sh->iss of zero for those. */
1017 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1018 TYPE_TAG_NAME (t
) = NULL
;
1020 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1023 TYPE_CODE (t
) = type_code
;
1024 TYPE_LENGTH (t
) = sh
->value
;
1025 TYPE_NFIELDS (t
) = nfields
;
1026 TYPE_FIELDS (t
) = f
= ((struct field
*)
1028 nfields
* sizeof (struct field
)));
1030 if (type_code
== TYPE_CODE_ENUM
)
1032 /* This is a non-empty enum. */
1034 /* DEC c89 has the number of enumerators in the sh.value field,
1035 not the type length, so we have to compensate for that
1036 incompatibility quirk.
1037 This might do the wrong thing for an enum with one or two
1038 enumerators and gcc -gcoff -fshort-enums, but these cases
1039 are hopefully rare enough. */
1040 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1041 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1042 for (ext_tsym
= ext_sh
+ external_sym_size
;
1044 ext_tsym
+= external_sym_size
)
1047 struct symbol
*enum_sym
;
1049 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1051 if (tsym
.st
!= stMember
)
1054 f
->bitpos
= tsym
.value
;
1056 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1059 enum_sym
= ((struct symbol
*)
1060 obstack_alloc (¤t_objfile
->symbol_obstack
,
1061 sizeof (struct symbol
)));
1062 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1063 SYMBOL_NAME (enum_sym
) = f
->name
;
1064 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1065 SYMBOL_TYPE (enum_sym
) = t
;
1066 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1067 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1068 add_symbol (enum_sym
, top_stack
->cur_block
);
1070 /* Skip the stMembers that we've handled. */
1075 /* make this the current type */
1076 top_stack
->cur_type
= t
;
1077 top_stack
->cur_field
= 0;
1079 /* Do not create a symbol for alpha cc unnamed structs. */
1083 /* gcc puts out an empty struct for an opaque struct definitions,
1084 do not create a symbol for it either. */
1085 if (TYPE_NFIELDS (t
) == 0)
1087 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1091 s
= new_symbol (name
);
1092 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1093 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1094 SYMBOL_VALUE (s
) = 0;
1095 SYMBOL_TYPE (s
) = t
;
1096 add_symbol (s
, top_stack
->cur_block
);
1099 /* End of local variables shared by struct, union, enum, and
1100 block (as yet unknown struct/union/enum) processing. */
1104 /* beginnning of (code) block. Value of symbol
1105 is the displacement from procedure start */
1106 push_parse_stack ();
1108 /* Do not start a new block if this is the outermost block of a
1109 procedure. This allows the LOC_BLOCK symbol to point to the
1110 block with the local variables, so funcname::var works. */
1111 if (top_stack
->blocktype
== stProc
1112 || top_stack
->blocktype
== stStaticProc
)
1114 top_stack
->blocktype
= stNil
;
1118 top_stack
->blocktype
= stBlock
;
1119 b
= new_block (top_stack
->maxsyms
);
1120 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1121 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1122 top_stack
->cur_block
= b
;
1123 add_block (b
, top_stack
->cur_st
);
1126 case stEnd
: /* end (of anything) */
1127 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1129 /* Finished with type */
1130 top_stack
->cur_type
= 0;
1132 else if (sh
->sc
== scText
&&
1133 (top_stack
->blocktype
== stProc
||
1134 top_stack
->blocktype
== stStaticProc
))
1136 /* Finished with procedure */
1137 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1138 struct mips_extra_func_info
*e
;
1140 struct type
*ftype
= top_stack
->cur_type
;
1143 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1145 /* Make up special symbol to contain procedure specific info */
1146 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1147 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1148 SYMBOL_CLASS (s
) = LOC_CONST
;
1149 SYMBOL_TYPE (s
) = builtin_type_void
;
1150 e
= ((struct mips_extra_func_info
*)
1151 obstack_alloc (¤t_objfile
->symbol_obstack
,
1152 sizeof (struct mips_extra_func_info
)));
1153 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
1154 SYMBOL_VALUE (s
) = (long) e
;
1155 e
->numargs
= top_stack
->numargs
;
1156 e
->pdr
.framereg
= -1;
1157 add_symbol (s
, top_stack
->cur_block
);
1159 /* Reallocate symbols, saving memory */
1160 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1162 /* f77 emits proc-level with address bounds==[0,0],
1163 So look for such child blocks, and patch them. */
1164 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1166 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1167 if (BLOCK_SUPERBLOCK (b_bad
) == b
1168 && BLOCK_START (b_bad
) == top_stack
->procadr
1169 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1171 BLOCK_START (b_bad
) = BLOCK_START (b
);
1172 BLOCK_END (b_bad
) = BLOCK_END (b
);
1176 if (TYPE_NFIELDS (ftype
) <= 0)
1178 /* No parameter type information is recorded with the function's
1179 type. Set that from the type of the parameter symbols. */
1180 int nparams
= top_stack
->numargs
;
1186 TYPE_NFIELDS (ftype
) = nparams
;
1187 TYPE_FIELDS (ftype
) = (struct field
*)
1188 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1190 for (i
= iparams
= 0; iparams
< nparams
; i
++)
1192 sym
= BLOCK_SYM (b
, i
);
1193 switch (SYMBOL_CLASS (sym
))
1198 case LOC_REGPARM_ADDR
:
1199 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1209 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1211 /* End of (code) block. The value of the symbol is the
1212 displacement from the procedure`s start address of the
1213 end of this block. */
1214 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1215 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1217 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1219 /* End of outermost block. Pop parse stack and ignore. The
1220 following stEnd of stProc will take care of the block. */
1223 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1225 /* End of file. Pop parse stack and ignore. Higher
1226 level code deals with this. */
1230 complain (&stEnd_complaint
, sh
->sc
);
1232 pop_parse_stack (); /* restore previous lexical context */
1235 case stMember
: /* member of struct or union */
1236 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1238 f
->bitpos
= sh
->value
;
1240 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1241 f
->bitsize
= bitsize
;
1244 case stIndirect
: /* forward declaration on Irix5 */
1245 /* Forward declarations from Irix5 cc are handled by cross_ref,
1249 case stTypedef
: /* type definition */
1250 /* Typedefs for forward declarations and opaque structs from alpha cc
1251 are handled by cross_ref, skip them. */
1255 /* Parse the type or use the pending type. */
1256 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1257 if (pend
== (struct mdebug_pending
*) NULL
)
1259 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1260 add_pending (cur_fdr
, ext_sh
, t
);
1265 /* mips cc puts out a typedef with the name of the struct for forward
1266 declarations. These should not go into the symbol table and
1267 TYPE_NAME should not be set for them.
1268 They can't be distinguished from an intentional typedef to
1269 the same name however:
1271 struct x { int ix; int jx; };
1275 struct xx {int ixx; int jxx; };
1276 generates a cross referencing stTypedef for x and xx.
1277 The user visible effect of this is that the type of a pointer
1278 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1279 The problem is fixed with alpha cc and Irix5 cc. */
1281 /* However if the typedef cross references to an opaque aggregate, it
1282 is safe to omit it from the symbol table. */
1284 if (has_opaque_xref (cur_fdr
, sh
))
1286 s
= new_symbol (name
);
1287 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1288 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1289 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1290 SYMBOL_TYPE (s
) = t
;
1291 add_symbol (s
, top_stack
->cur_block
);
1293 /* Incomplete definitions of structs should not get a name. */
1294 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1295 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1296 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1297 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1299 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1300 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1302 /* If we are giving a name to a type such as "pointer to
1303 foo" or "function returning foo", we better not set
1304 the TYPE_NAME. If the program contains "typedef char
1305 *caddr_t;", we don't want all variables of type char
1306 * to print as caddr_t. This is not just a
1307 consequence of GDB's type management; CC and GCC (at
1308 least through version 2.4) both output variables of
1309 either type char * or caddr_t with the type
1310 refering to the stTypedef symbol for caddr_t. If a future
1311 compiler cleans this up it GDB is not ready for it
1312 yet, but if it becomes ready we somehow need to
1313 disable this check (without breaking the PCC/GCC2.4
1318 Fortunately, this check seems not to be necessary
1319 for anything except pointers or functions. */
1322 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1326 case stFile
: /* file name */
1327 push_parse_stack ();
1328 top_stack
->blocktype
= sh
->st
;
1331 /* I`ve never seen these for C */
1333 break; /* register relocation */
1335 break; /* forwarding address */
1337 break; /* constant */
1339 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1346 /* Parse the type information provided in the raw AX entries for
1347 the symbol SH. Return the bitfield size in BS, in case.
1348 We must byte-swap the AX entries before we use them; BIGEND says whether
1349 they are big-endian or little-endian (from fh->fBigendian). */
1351 static struct type
*
1352 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1355 unsigned int aux_index
;
1360 /* Null entries in this map are treated specially */
1361 static struct type
**map_bt
[] =
1363 &builtin_type_void
, /* btNil */
1365 &builtin_type_char
, /* btChar */
1366 &builtin_type_unsigned_char
,/* btUChar */
1367 &builtin_type_short
, /* btShort */
1368 &builtin_type_unsigned_short
, /* btUShort */
1369 &builtin_type_int
, /* btInt */
1370 &builtin_type_unsigned_int
, /* btUInt */
1371 &builtin_type_long
, /* btLong */
1372 &builtin_type_unsigned_long
,/* btULong */
1373 &builtin_type_float
, /* btFloat */
1374 &builtin_type_double
, /* btDouble */
1381 &builtin_type_complex
, /* btComplex */
1382 &builtin_type_double_complex
,/* btDComplex */
1384 &mdebug_type_fixed_dec
, /* btFixedDec */
1385 &mdebug_type_float_dec
, /* btFloatDec */
1386 &mdebug_type_string
, /* btString */
1389 &builtin_type_void
, /* btVoid */
1390 0, /* DEC C++: Pointer to member */
1391 0, /* DEC C++: Virtual function table */
1392 0, /* DEC C++: Class (Record) */
1393 &builtin_type_long
, /* btLong64 */
1394 &builtin_type_unsigned_long
, /* btULong64 */
1395 &builtin_type_long_long
, /* btLongLong64 */
1396 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1397 &builtin_type_unsigned_long
, /* btAdr64 */
1398 &builtin_type_long
, /* btInt64 */
1399 &builtin_type_unsigned_long
, /* btUInt64 */
1403 struct type
*tp
= 0;
1404 enum type_code type_code
= TYPE_CODE_UNDEF
;
1406 /* Handle undefined types, they have indexNil. */
1407 if (aux_index
== indexNil
)
1408 return builtin_type_int
;
1410 /* Handle corrupt aux indices. */
1411 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1413 complain (&index_complaint
, sym_name
);
1414 return builtin_type_int
;
1418 /* Use aux as a type information record, map its basic type. */
1419 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1420 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1422 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1423 return builtin_type_int
;
1427 tp
= *map_bt
[t
->bt
];
1432 /* Cannot use builtin types -- build our own */
1436 tp
= lookup_pointer_type (builtin_type_void
);
1439 type_code
= TYPE_CODE_STRUCT
;
1442 type_code
= TYPE_CODE_UNION
;
1445 type_code
= TYPE_CODE_ENUM
;
1448 type_code
= TYPE_CODE_RANGE
;
1451 type_code
= TYPE_CODE_SET
;
1454 /* alpha cc uses this for typedefs. The true type will be
1455 obtained by crossreferencing below. */
1456 type_code
= TYPE_CODE_ERROR
;
1459 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1460 return builtin_type_int
;
1464 /* Move on to next aux */
1469 /* Inhibit core dumps with some cfront generated objects that
1471 if (bs
== (int *)NULL
)
1473 complain (&bad_fbitfield_complaint
, sym_name
);
1474 return builtin_type_int
;
1476 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1480 /* All these types really point to some (common) MIPS type
1481 definition, and only the type-qualifiers fully identify
1482 them. We'll make the same effort at sharing. */
1483 if (t
->bt
== btStruct
||
1487 /* btSet (I think) implies that the name is a tag name, not a typedef
1488 name. This apparently is a MIPS extension for C sets. */
1493 /* Try to cross reference this type, build new type on failure. */
1494 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1495 if (tp
== (struct type
*) NULL
)
1496 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1498 /* DEC c89 produces cross references to qualified aggregate types,
1499 dereference them. */
1500 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1501 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1502 tp
= tp
->target_type
;
1504 /* Make sure that TYPE_CODE(tp) has an expected type code.
1505 Any type may be returned from cross_ref if file indirect entries
1507 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1508 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1509 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1511 complain (&unexpected_type_code_complaint
, sym_name
);
1516 /* Usually, TYPE_CODE(tp) is already type_code. The main
1517 exception is if we guessed wrong re struct/union/enum.
1518 But for struct vs. union a wrong guess is harmless, so
1519 don't complain(). */
1520 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1521 && type_code
!= TYPE_CODE_ENUM
)
1522 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1523 && type_code
== TYPE_CODE_ENUM
))
1525 complain (&bad_tag_guess_complaint
, sym_name
);
1528 if (TYPE_CODE (tp
) != type_code
)
1530 TYPE_CODE (tp
) = type_code
;
1533 /* Do not set the tag name if it is a compiler generated tag name
1534 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1535 if (name
[0] == '.' || name
[0] == '\0')
1536 TYPE_TAG_NAME (tp
) = NULL
;
1537 else if (TYPE_TAG_NAME (tp
) == NULL
1538 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1539 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1540 ¤t_objfile
->type_obstack
);
1544 /* All these types really point to some (common) MIPS type
1545 definition, and only the type-qualifiers fully identify
1546 them. We'll make the same effort at sharing.
1547 FIXME: btIndirect cannot happen here as it is handled by the
1548 switch t->bt above. And we are not doing any guessing on range types. */
1549 if (t
->bt
== btIndirect
||
1554 /* Try to cross reference this type, build new type on failure. */
1555 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1556 if (tp
== (struct type
*) NULL
)
1557 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1559 /* Make sure that TYPE_CODE(tp) has an expected type code.
1560 Any type may be returned from cross_ref if file indirect entries
1562 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1564 complain (&unexpected_type_code_complaint
, sym_name
);
1568 /* Usually, TYPE_CODE(tp) is already type_code. The main
1569 exception is if we guessed wrong re struct/union/enum. */
1570 if (TYPE_CODE (tp
) != type_code
)
1572 complain (&bad_tag_guess_complaint
, sym_name
);
1573 TYPE_CODE (tp
) = type_code
;
1575 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1576 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1577 ¤t_objfile
->type_obstack
);
1580 if (t
->bt
== btTypedef
)
1584 /* Try to cross reference this type, it should succeed. */
1585 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1586 if (tp
== (struct type
*) NULL
)
1588 complain (&unable_to_cross_ref_complaint
, sym_name
);
1589 tp
= builtin_type_int
;
1593 /* Deal with range types */
1594 if (t
->bt
== btRange
)
1596 TYPE_NFIELDS (tp
) = 2;
1597 TYPE_FIELDS (tp
) = ((struct field
*)
1598 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1599 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1600 ¤t_objfile
->type_obstack
);
1601 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1603 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1604 ¤t_objfile
->type_obstack
);
1605 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1609 /* Parse all the type qualifiers now. If there are more
1610 than 6 the game will continue in the next aux */
1614 #define PARSE_TQ(tq) \
1615 if (t->tq != tqNil) \
1616 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1628 /* mips cc 2.x and gcc never put out continued aux entries. */
1632 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1636 /* Complain for illegal continuations due to corrupt aux entries. */
1638 complain (&bad_continued_complaint
, sym_name
);
1643 /* Make up a complex type from a basic one. Type is passed by
1644 reference in TPP and side-effected as necessary. The type
1645 qualifier TQ says how to handle the aux symbols at AX for
1646 the symbol SX we are currently analyzing. BIGEND says whether
1647 aux symbols are big-endian or little-endian.
1648 Returns the number of aux symbols we parsed. */
1651 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1662 /* Used in array processing */
1673 t
= lookup_pointer_type (*tpp
);
1678 t
= lookup_function_type (*tpp
);
1685 /* Determine and record the domain type (type of index) */
1686 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1692 rf
= AUX_GET_ISYM (bigend
, ax
);
1695 fh
= get_rfd (fd
, rf
);
1697 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1698 id
, (int *) NULL
, bigend
, sym_name
);
1700 /* The bounds type should be an integer type, but might be anything
1701 else due to corrupt aux entries. */
1702 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1704 complain (&array_index_type_complaint
, sym_name
);
1705 indx
= builtin_type_int
;
1708 /* Get the bounds, and create the array type. */
1710 lower
= AUX_GET_DNLOW (bigend
, ax
);
1712 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1714 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1716 range
= create_range_type ((struct type
*) NULL
, indx
,
1719 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1721 /* We used to fill in the supplied array element bitsize
1722 here if the TYPE_LENGTH of the target type was zero.
1723 This happens for a `pointer to an array of anonymous structs',
1724 but in this case the array element bitsize is also zero,
1725 so nothing is gained.
1726 And we used to check the TYPE_LENGTH of the target type against
1727 the supplied array element bitsize.
1728 gcc causes a mismatch for `pointer to array of object',
1729 since the sdb directives it uses do not have a way of
1730 specifying the bitsize, but it does no harm (the
1731 TYPE_LENGTH should be correct) and we should be able to
1732 ignore the erroneous bitsize from the auxiliary entry safely.
1733 dbx seems to ignore it too. */
1739 /* Volatile -- currently ignored */
1743 /* Const -- currently ignored */
1747 complain (&unknown_type_qual_complaint
, tq
);
1753 /* Parse a procedure descriptor record PR. Note that the procedure is
1754 parsed _after_ the local symbols, now we just insert the extra
1755 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1756 already been placed in the procedure's main block. Note also that
1757 images that have been partially stripped (ld -x) have been deprived
1758 of local symbols, and we have to cope with them here. FIRST_OFF is
1759 the offset of the first procedure for this FDR; we adjust the
1760 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1761 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1762 in question, or NULL to use top_stack->cur_block. */
1764 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long,
1765 struct partial_symtab
*));
1768 parse_procedure (pr
, search_symtab
, first_off
, pst
)
1770 struct symtab
*search_symtab
;
1771 unsigned long first_off
;
1772 struct partial_symtab
*pst
;
1774 struct symbol
*s
, *i
;
1776 struct mips_extra_func_info
*e
;
1779 /* Simple rule to find files linked "-x" */
1780 if (cur_fdr
->rss
== -1)
1784 /* Static procedure at address pr->adr. Sigh. */
1785 /* FIXME-32x64. assuming pr->adr fits in long. */
1786 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1794 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1795 ((char *) debug_info
->external_ext
1797 * debug_swap
->external_ext_size
)),
1799 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1807 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1808 ((char *) debug_info
->external_sym
1809 + ((cur_fdr
->isymBase
+ pr
->isym
)
1810 * debug_swap
->external_sym_size
)),
1812 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1815 if (search_symtab
!= NULL
)
1818 /* This loses both in the case mentioned (want a static, find a global),
1819 but also if we are looking up a non-mangled name which happens to
1820 match the name of a mangled function. */
1821 /* We have to save the cur_fdr across the call to lookup_symbol.
1822 If the pdr is for a static function and if a global function with
1823 the same name exists, lookup_symbol will eventually read in the symtab
1824 for the global function and clobber cur_fdr. */
1825 FDR
*save_cur_fdr
= cur_fdr
;
1826 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1827 cur_fdr
= save_cur_fdr
;
1831 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1837 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1838 VAR_NAMESPACE
, LOC_BLOCK
);
1842 b
= SYMBOL_BLOCK_VALUE (s
);
1846 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1850 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1851 s
= new_symbol (sh_name
);
1852 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1853 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1854 /* Donno its type, hope int is ok */
1855 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1856 add_symbol (s
, top_stack
->cur_block
);
1857 /* Wont have symbols for this one */
1859 SYMBOL_BLOCK_VALUE (s
) = b
;
1860 BLOCK_FUNCTION (b
) = s
;
1861 BLOCK_START (b
) = pr
->adr
;
1862 /* BOUND used to be the end of procedure's text, but the
1863 argument is no longer passed in. */
1864 BLOCK_END (b
) = bound
;
1865 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1866 add_block (b
, top_stack
->cur_st
);
1870 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1874 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1876 e
->pdr
.isym
= (long) s
;
1877 e
->pdr
.adr
+= pst
->textlow
- first_off
;
1879 /* Correct incorrect setjmp procedure descriptor from the library
1880 to make backtrace through setjmp work. */
1881 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1883 complain (&bad_setjmp_pdr_complaint
, 0);
1884 e
->pdr
.pcreg
= RA_REGNUM
;
1885 e
->pdr
.regmask
= 0x80000000;
1886 e
->pdr
.regoffset
= -4;
1891 /* Relocate the extra function info pointed to by the symbol table. */
1894 ecoff_relocate_efi (sym
, delta
)
1898 struct mips_extra_func_info
*e
;
1900 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
1902 e
->pdr
.adr
+= delta
;
1905 /* Parse the external symbol ES. Just call parse_symbol() after
1906 making sure we know where the aux are for it.
1907 BIGEND says whether aux entries are big-endian or little-endian.
1909 This routine clobbers top_stack->cur_block and ->cur_st. */
1911 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
1914 parse_external (es
, bigend
, section_offsets
)
1917 struct section_offsets
*section_offsets
;
1921 if (es
->ifd
!= ifdNil
)
1924 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1925 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1929 cur_fdr
= debug_info
->fdr
;
1933 /* Reading .o files */
1934 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1937 switch (es
->asym
.st
)
1940 /* These are generated for static symbols in .o files,
1961 /* FIXME: Turn this into a complaint? */
1963 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1964 what
, debug_info
->ssext
+ es
->asym
.iss
,
1965 fdr_name (cur_fdr
));
1969 switch (es
->asym
.st
)
1973 /* There is no need to parse the external procedure symbols.
1974 If they are from objects compiled without -g, their index will
1975 be indexNil, and the symbol definition from the minimal symbol
1976 is preferrable (yielding a function returning int instead of int).
1977 If the index points to a local procedure symbol, the local
1978 symbol already provides the correct type.
1979 Note that the index of the external procedure symbol points
1980 to the local procedure symbol in the local symbol table, and
1981 _not_ to the auxiliary symbol info. */
1985 /* Global common symbols are resolved by the runtime loader,
1987 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
1990 /* Note that the case of a symbol with indexNil must be handled
1991 anyways by parse_symbol(). */
1992 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
1999 /* Parse the line number info for file descriptor FH into
2000 GDB's linetable LT. MIPS' encoding requires a little bit
2001 of magic to get things out. Note also that MIPS' line
2002 numbers can go back and forth, apparently we can live
2003 with that and do not need to reorder our linetables */
2005 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
2006 struct partial_symtab
*));
2009 parse_lines (fh
, pr
, lt
, maxlines
, pst
)
2012 struct linetable
*lt
;
2014 struct partial_symtab
*pst
;
2016 unsigned char *base
;
2018 int delta
, count
, lineno
= 0;
2019 unsigned long first_off
= pr
->adr
;
2021 if (fh
->cbLine
== 0)
2024 /* Scan by procedure descriptors */
2026 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2030 unsigned char *halt
;
2032 /* No code for this one */
2033 if (pr
->iline
== ilineNil
||
2034 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2037 /* Determine start and end address of compressed line bytes for
2039 base
= debug_info
->line
+ fh
->cbLineOffset
;
2040 if (j
!= (fh
->cpd
- 1))
2041 halt
= base
+ pr
[1].cbLineOffset
;
2043 halt
= base
+ fh
->cbLine
;
2044 base
+= pr
->cbLineOffset
;
2046 adr
= pst
->textlow
+ pr
->adr
- first_off
;
2048 l
= adr
>> 2; /* in words */
2049 for (lineno
= pr
->lnLow
; base
< halt
; )
2051 count
= *base
& 0x0f;
2052 delta
= *base
++ >> 4;
2057 delta
= (base
[0] << 8) | base
[1];
2058 if (delta
>= 0x8000)
2062 lineno
+= delta
; /* first delta is 0 */
2064 /* Complain if the line table overflows. Could happen
2065 with corrupt binaries. */
2066 if (lt
->nitems
>= maxlines
)
2068 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2071 k
= add_line (lt
, lineno
, l
, k
);
2077 /* Master parsing procedure for first-pass reading of file symbols
2078 into a partial_symtab. */
2081 parse_partial_symbols (objfile
, section_offsets
)
2082 struct objfile
*objfile
;
2083 struct section_offsets
*section_offsets
;
2085 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2086 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2087 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2088 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2089 = debug_swap
->swap_ext_in
;
2090 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2091 = debug_swap
->swap_sym_in
;
2092 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2093 = debug_swap
->swap_rfd_in
;
2095 HDRR
*hdr
= &debug_info
->symbolic_header
;
2096 /* Running pointers */
2101 register EXTR
*ext_in
;
2104 struct partial_symtab
*pst
;
2106 int past_first_source_file
= 0;
2108 /* List of current psymtab's include files */
2109 char **psymtab_include_list
;
2110 int includes_allocated
;
2113 struct pst_map
*fdr_to_pst
;
2114 /* Index within current psymtab dependency list */
2115 struct partial_symtab
**dependency_list
;
2116 int dependencies_used
, dependencies_allocated
;
2117 struct cleanup
*old_chain
;
2119 enum language prev_language
;
2120 asection
*text_sect
;
2121 int relocatable
= 0;
2123 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2124 the shared libraries are prelinked at a high memory address.
2125 We have to adjust the start address of the object file for this case,
2126 by setting it to the start address of the first procedure in the file.
2127 But we should do no adjustments if we are debugging a .o file, where
2128 the text section (and fh->adr) really starts at zero. */
2129 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2130 if (text_sect
!= NULL
2131 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2134 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2135 sizeof (EXTR
) * hdr
->iextMax
);
2137 includes_allocated
= 30;
2139 psymtab_include_list
= (char **) alloca (includes_allocated
*
2141 next_symbol_text_func
= mdebug_next_symbol_text
;
2143 dependencies_allocated
= 30;
2144 dependencies_used
= 0;
2146 (struct partial_symtab
**) alloca (dependencies_allocated
*
2147 sizeof (struct partial_symtab
*));
2149 last_source_file
= NULL
;
2154 * Only parse the Local and External symbols, and the Relative FDR.
2155 * Fixup enough of the loader symtab to be able to use it.
2156 * Allocate space only for the file's portions we need to
2161 max_glevel
= MIN_GLEVEL
;
2163 /* Allocate the map FDR -> PST.
2164 Minor hack: -O3 images might claim some global data belongs
2165 to FDR -1. We`ll go along with that */
2166 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2167 old_chain
= make_cleanup (free
, fdr_to_pst
);
2170 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2171 fdr_to_pst
[-1].pst
= pst
;
2175 /* Allocate the global pending list. */
2177 ((struct mdebug_pending
**)
2178 obstack_alloc (&objfile
->psymbol_obstack
,
2179 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2180 memset ((PTR
) pending_list
, 0,
2181 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2183 /* Pass 0 over external syms: swap them in. */
2184 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2185 make_cleanup (free
, ext_block
);
2187 ext_out
= (char *) debug_info
->external_ext
;
2188 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2190 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2191 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2193 /* Pass 1 over external syms: Presize and partition the list */
2195 ext_in_end
= ext_in
+ hdr
->iextMax
;
2196 for (; ext_in
< ext_in_end
; ext_in
++)
2198 /* See calls to complain below. */
2199 if (ext_in
->ifd
>= -1
2200 && ext_in
->ifd
< hdr
->ifdMax
2201 && ext_in
->asym
.iss
>= 0
2202 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2203 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2206 /* Pass 1.5 over files: partition out global symbol space */
2208 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2210 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2211 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2212 fdr_to_pst
[f_idx
].n_globals
= 0;
2215 /* Pass 2 over external syms: fill in external symbols */
2217 ext_in_end
= ext_in
+ hdr
->iextMax
;
2218 for (; ext_in
< ext_in_end
; ext_in
++)
2220 enum minimal_symbol_type ms_type
= mst_text
;
2221 CORE_ADDR svalue
= ext_in
->asym
.value
;
2223 /* The Irix 5 native tools seem to sometimes generate bogus
2224 external symbols. */
2225 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2227 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2230 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2232 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2237 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2238 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2240 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2243 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2244 switch (ext_in
->asym
.st
)
2247 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2250 ms_type
= mst_file_text
;
2251 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2254 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2256 /* The value of a common symbol is its size, not its address.
2260 else if (ext_in
->asym
.sc
== scData
2261 || ext_in
->asym
.sc
== scSData
2262 || ext_in
->asym
.sc
== scRData
2263 || ext_in
->asym
.sc
== scPData
2264 || ext_in
->asym
.sc
== scXData
)
2267 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2272 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2276 if (ext_in
->asym
.sc
== scAbs
)
2278 else if (ext_in
->asym
.sc
== scText
2279 || ext_in
->asym
.sc
== scInit
2280 || ext_in
->asym
.sc
== scFini
)
2282 ms_type
= mst_file_text
;
2283 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2285 else if (ext_in
->asym
.sc
== scData
2286 || ext_in
->asym
.sc
== scSData
2287 || ext_in
->asym
.sc
== scRData
2288 || ext_in
->asym
.sc
== scPData
2289 || ext_in
->asym
.sc
== scXData
)
2291 ms_type
= mst_file_data
;
2292 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2296 ms_type
= mst_file_bss
;
2297 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2301 /* The alpha has the section start addresses in stLocal symbols
2302 whose name starts with a `.'. Skip those but complain for all
2303 other stLocal symbols. */
2308 ms_type
= mst_unknown
;
2309 complain (&unknown_ext_complaint
, name
);
2311 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2314 /* Pass 3 over files, over local syms: fill in static symbols */
2315 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2317 struct partial_symtab
*save_pst
;
2321 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2325 fdr_to_pst
[f_idx
].pst
= NULL
;
2329 /* Determine the start address for this object file from the
2330 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2334 if (relocatable
|| textlow
!= 0)
2335 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2339 pst
= start_psymtab_common (objfile
, section_offsets
,
2342 objfile
->global_psymbols
.next
,
2343 objfile
->static_psymbols
.next
);
2344 pst
->read_symtab_private
= ((char *)
2345 obstack_alloc (&objfile
->psymbol_obstack
,
2346 sizeof (struct symloc
)));
2347 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2350 FDR_IDX (pst
) = f_idx
;
2351 CUR_BFD (pst
) = cur_bfd
;
2352 DEBUG_SWAP (pst
) = debug_swap
;
2353 DEBUG_INFO (pst
) = debug_info
;
2354 PENDING_LIST (pst
) = pending_list
;
2356 /* The way to turn this into a symtab is to call... */
2357 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2359 /* Set up language for the pst.
2360 The language from the FDR is used if it is unambigious (e.g. cfront
2361 with native cc and g++ will set the language to C).
2362 Otherwise we have to deduce the language from the filename.
2363 Native ecoff has every header file in a separate FDR, so
2364 deduce_language_from_filename will return language_unknown for
2365 a header file, which is not what we want.
2366 But the FDRs for the header files are after the FDR for the source
2367 file, so we can assign the language of the source file to the
2368 following header files. Then we save the language in the private
2369 pst data so that we can reuse it when building symtabs. */
2370 prev_language
= psymtab_language
;
2374 case langCplusplusV2
:
2375 psymtab_language
= language_cplus
;
2378 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2381 if (psymtab_language
== language_unknown
)
2382 psymtab_language
= prev_language
;
2383 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2385 pst
->texthigh
= pst
->textlow
;
2387 /* For stabs-in-ecoff files, the second symbol must be @stab.
2388 This symbol is emitted by mips-tfile to signal that the
2389 current object file uses encapsulated stabs instead of mips
2390 ecoff for local symbols. (It is the second symbol because
2391 the first symbol is the stFile used to signal the start of a
2393 processing_gcc_compilation
= 0;
2396 (*swap_sym_in
) (cur_bfd
,
2397 ((char *) debug_info
->external_sym
2398 + (fh
->isymBase
+ 1) * external_sym_size
),
2400 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2401 processing_gcc_compilation
= 2;
2404 if (processing_gcc_compilation
!= 0)
2406 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2411 (*swap_sym_in
) (cur_bfd
,
2412 (((char *) debug_info
->external_sym
)
2413 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2415 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2416 if (!ECOFF_IS_STAB (&sh
))
2418 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2423 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2424 if (sh
.st
== stStaticProc
)
2426 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2427 prim_record_minimal_symbol_and_info (namestring
,
2434 procaddr
= sh
.value
;
2436 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2437 (debug_info
->external_aux
2440 (*swap_sym_in
) (cur_bfd
,
2441 ((char *) debug_info
->external_sym
2442 + ((fh
->isymBase
+ isym
- 1)
2443 * external_sym_size
)),
2447 long high
= procaddr
+ sh
.value
;
2449 /* Kludge for Irix 5.2 zero fh->adr. */
2451 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2452 pst
->textlow
= procaddr
;
2453 if (high
> pst
->texthigh
)
2454 pst
->texthigh
= high
;
2457 else if (sh
.st
== stStatic
)
2471 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2472 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2473 prim_record_minimal_symbol_and_info (namestring
,
2482 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2483 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2484 prim_record_minimal_symbol_and_info (namestring
,
2495 #define SET_NAMESTRING() \
2496 namestring = debug_info->ss + fh->issBase + sh.iss
2497 #define CUR_SYMBOL_TYPE type_code
2498 #define CUR_SYMBOL_VALUE sh.value
2499 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2501 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2502 #define HANDLE_RBRAC(val) \
2503 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2504 #include "partial-stab.h"
2509 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2512 enum address_class
class;
2514 (*swap_sym_in
) (cur_bfd
,
2515 ((char *) debug_info
->external_sym
2516 + ((fh
->isymBase
+ cur_sdx
)
2517 * external_sym_size
)),
2520 if (ECOFF_IS_STAB (&sh
))
2526 /* Non absolute static symbols go into the minimal table. */
2527 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2528 || (sh
.index
== indexNil
2529 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2531 /* FIXME, premature? */
2536 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2541 /* The value of a stEnd symbol is the displacement from the
2542 corresponding start symbol value, do not relocate it. */
2544 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2551 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2555 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2566 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2567 mst_file_text
, NULL
,
2568 SECT_OFF_TEXT
, objfile
);
2573 /* Usually there is a local and a global stProc symbol
2574 for a function. This means that the function name
2575 has already been entered into the mimimal symbol table
2576 while processing the global symbols in pass 2 above.
2577 One notable exception is the PROGRAM name from
2578 f77 compiled executables, it is only put out as
2579 local stProc symbol, and a global MAIN__ stProc symbol
2580 points to it. It doesn't matter though, as gdb is
2581 still able to find the PROGRAM name via the partial
2582 symbol table, and the MAIN__ symbol via the minimal
2584 if (sh
.st
== stProc
)
2585 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2586 VAR_NAMESPACE
, LOC_BLOCK
,
2587 objfile
->global_psymbols
,
2588 sh
.value
, psymtab_language
, objfile
);
2590 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2591 VAR_NAMESPACE
, LOC_BLOCK
,
2592 objfile
->static_psymbols
,
2593 sh
.value
, psymtab_language
, objfile
);
2595 /* Skip over procedure to next one. */
2596 if (sh
.index
>= hdr
->iauxMax
)
2598 /* Should not happen, but does when cross-compiling
2599 with the MIPS compiler. FIXME -- pull later. */
2600 complain (&index_complaint
, name
);
2601 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2604 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2605 (debug_info
->external_aux
2608 procaddr
= sh
.value
;
2610 if (new_sdx
<= cur_sdx
)
2612 /* This should not happen either... FIXME. */
2613 complain (&aux_index_complaint
, name
);
2614 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2618 (*swap_sym_in
) (cur_bfd
,
2619 ((char *) debug_info
->external_sym
2620 + ((fh
->isymBase
+ cur_sdx
- 1)
2621 * external_sym_size
)),
2626 /* Kludge for Irix 5.2 zero fh->adr. */
2628 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2629 pst
->textlow
= procaddr
;
2631 high
= procaddr
+ sh
.value
;
2632 if (high
> pst
->texthigh
)
2633 pst
->texthigh
= high
;
2636 case stStatic
: /* Variable */
2641 || sh
.sc
== scXData
)
2642 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2643 mst_file_data
, NULL
,
2647 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2654 case stIndirect
:/* Irix5 forward declaration */
2655 /* Skip forward declarations from Irix5 cc */
2658 case stTypedef
:/* Typedef */
2659 /* Skip typedefs for forward declarations and opaque
2660 structs from alpha and mips cc. */
2661 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2663 class = LOC_TYPEDEF
;
2666 case stConstant
: /* Constant decl */
2673 case stBlock
: /* { }, str, un, enum*/
2674 /* Do not create a partial symbol for cc unnamed aggregates
2675 and gcc empty aggregates. */
2676 if ((sh
.sc
== scInfo
2677 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2679 && sh
.index
!= cur_sdx
+ 2)
2681 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2682 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2683 objfile
->static_psymbols
,
2685 psymtab_language
, objfile
);
2687 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2689 /* Skip over the block */
2691 if (new_sdx
<= cur_sdx
)
2693 /* This happens with the Ultrix kernel. */
2694 complain (&block_index_complaint
, name
);
2695 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2700 case stFile
: /* File headers */
2701 case stLabel
: /* Labels */
2702 case stEnd
: /* Ends of files */
2705 case stLocal
: /* Local variables */
2706 /* Normally these are skipped because we skip over
2707 all blocks we see. However, these can occur
2708 as visible symbols in a .h file that contains code. */
2712 /* Both complaints are valid: one gives symbol name,
2713 the other the offending symbol type. */
2714 complain (&unknown_sym_complaint
, name
);
2715 complain (&unknown_st_complaint
, sh
.st
);
2719 /* Use this gdb symbol */
2720 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2721 VAR_NAMESPACE
, class,
2722 objfile
->static_psymbols
, sh
.value
,
2723 psymtab_language
, objfile
);
2725 cur_sdx
++; /* Go to next file symbol */
2728 /* Now do enter the external symbols. */
2729 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2730 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2731 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2732 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2733 for (; --cur_sdx
>= 0; ext_ptr
++)
2735 enum address_class
class;
2740 if (ext_ptr
->ifd
!= f_idx
)
2742 psh
= &ext_ptr
->asym
;
2744 /* Do not add undefined symbols to the partial symbol table. */
2745 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2748 svalue
= psh
->value
;
2752 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2759 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2763 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2770 /* These are generated for static symbols in .o files,
2775 /* External procedure symbols have been entered
2776 into the minimal symbol table in pass 2 above.
2777 Ignore them, as parse_external will ignore them too. */
2783 complain (&unknown_ext_complaint
,
2784 debug_info
->ssext
+ psh
->iss
);
2785 /* Fall through, pretend it's global. */
2787 /* Global common symbols are resolved by the runtime loader,
2789 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2795 name
= debug_info
->ssext
+ psh
->iss
;
2796 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2797 VAR_NAMESPACE
, class,
2798 objfile
->global_psymbols
,
2800 psymtab_language
, objfile
);
2804 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2805 empty and put on the free list. */
2806 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2807 psymtab_include_list
, includes_used
,
2808 -1, save_pst
->texthigh
,
2809 dependency_list
, dependencies_used
);
2810 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2811 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2813 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2814 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2817 /* The objfile has its functions reordered if this partial symbol
2818 table overlaps any other partial symbol table.
2819 We cannot assume a reordered objfile if a partial symbol table
2820 is contained within another partial symbol table, as partial symbol
2821 tables for include files with executable code are contained
2822 within the partial symbol table for the including source file,
2823 and we do not want to flag the objfile reordered for these cases.
2825 This strategy works well for Irix-5.2 shared libraries, but we
2826 might have to use a more elaborate (and slower) algorithm for
2828 save_pst
= fdr_to_pst
[f_idx
].pst
;
2829 if (save_pst
!= NULL
2830 && save_pst
->textlow
!= 0
2831 && !(objfile
->flags
& OBJF_REORDERED
))
2833 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
2836 && save_pst
->textlow
>= pst
->textlow
2837 && save_pst
->textlow
< pst
->texthigh
2838 && save_pst
->texthigh
> pst
->texthigh
)
2840 objfile
->flags
|= OBJF_REORDERED
;
2847 /* Now scan the FDRs for dependencies */
2848 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2850 fh
= f_idx
+ debug_info
->fdr
;
2851 pst
= fdr_to_pst
[f_idx
].pst
;
2853 if (pst
== (struct partial_symtab
*)NULL
)
2856 /* This should catch stabs-in-ecoff. */
2860 /* Skip the first file indirect entry as it is a self dependency
2861 for source files or a reverse .h -> .c dependency for header files. */
2862 pst
->number_of_dependencies
= 0;
2864 ((struct partial_symtab
**)
2865 obstack_alloc (&objfile
->psymbol_obstack
,
2867 * sizeof (struct partial_symtab
*))));
2868 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2872 (*swap_rfd_in
) (cur_bfd
,
2873 ((char *) debug_info
->external_rfd
2874 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2876 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2878 complain (&bad_file_number_complaint
, rh
);
2882 /* Skip self dependencies of header files. */
2886 /* Do not add to dependeny list if psymtab was empty. */
2887 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2889 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2893 /* Remove the dummy psymtab created for -O3 images above, if it is
2894 still empty, to enable the detection of stripped executables. */
2895 if (objfile
->psymtabs
->next
== NULL
2896 && objfile
->psymtabs
->number_of_dependencies
== 0
2897 && objfile
->psymtabs
->n_global_syms
== 0
2898 && objfile
->psymtabs
->n_static_syms
== 0)
2899 objfile
->psymtabs
= NULL
;
2900 do_cleanups (old_chain
);
2903 /* If the current psymbol has an enumerated type, we need to add
2904 all the the enum constants to the partial symbol table. */
2907 handle_psymbol_enumerators (objfile
, fh
, stype
)
2908 struct objfile
*objfile
;
2912 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2913 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2914 = debug_swap
->swap_sym_in
;
2915 char *ext_sym
= ((char *) debug_info
->external_sym
2916 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2926 /* It is an enumerated type if the next symbol entry is a stMember
2927 and its auxiliary index is indexNil or its auxiliary entry
2928 is a plain btNil or btVoid. */
2929 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2930 if (sh
.st
!= stMember
)
2933 if (sh
.index
== indexNil
)
2935 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
2936 &(debug_info
->external_aux
2937 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2939 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2951 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2952 if (sh
.st
!= stMember
)
2954 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2956 /* Note that the value doesn't matter for enum constants
2957 in psymtabs, just in symtabs. */
2958 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2959 VAR_NAMESPACE
, LOC_CONST
,
2960 objfile
->static_psymbols
, 0,
2961 psymtab_language
, objfile
);
2962 ext_sym
+= external_sym_size
;
2967 mdebug_next_symbol_text ()
2972 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2973 ((char *) debug_info
->external_sym
2974 + ((cur_fdr
->isymBase
+ cur_sdx
)
2975 * debug_swap
->external_sym_size
)),
2977 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2980 /* Ancillary function to psymtab_to_symtab(). Does all the work
2981 for turning the partial symtab PST into a symtab, recurring
2982 first on all dependent psymtabs. The argument FILENAME is
2983 only passed so we can see in debug stack traces what file
2986 This function has a split personality, based on whether the
2987 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2988 The flow of control and even the memory allocation differs. FIXME. */
2991 psymtab_to_symtab_1 (pst
, filename
)
2992 struct partial_symtab
*pst
;
2995 bfd_size_type external_sym_size
;
2996 bfd_size_type external_pdr_size
;
2997 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2998 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
3002 struct linetable
*lines
;
3008 /* Read in all partial symbtabs on which this one is dependent.
3009 NOTE that we do have circular dependencies, sigh. We solved
3010 that by setting pst->readin before this point. */
3012 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3013 if (!pst
->dependencies
[i
]->readin
)
3015 /* Inform about additional files to be read in. */
3018 fputs_filtered (" ", gdb_stdout
);
3020 fputs_filtered ("and ", gdb_stdout
);
3022 printf_filtered ("%s...",
3023 pst
->dependencies
[i
]->filename
);
3024 wrap_here (""); /* Flush output */
3025 gdb_flush (gdb_stdout
);
3027 /* We only pass the filename for debug purposes */
3028 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3029 pst
->dependencies
[i
]->filename
);
3032 /* Do nothing if this is a dummy psymtab. */
3034 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3035 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3038 /* Now read the symbols for this symtab */
3040 cur_bfd
= CUR_BFD (pst
);
3041 debug_swap
= DEBUG_SWAP (pst
);
3042 debug_info
= DEBUG_INFO (pst
);
3043 pending_list
= PENDING_LIST (pst
);
3044 external_sym_size
= debug_swap
->external_sym_size
;
3045 external_pdr_size
= debug_swap
->external_pdr_size
;
3046 swap_sym_in
= debug_swap
->swap_sym_in
;
3047 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3048 current_objfile
= pst
->objfile
;
3049 cur_fd
= FDR_IDX (pst
);
3050 fh
= ((cur_fd
== -1)
3052 : debug_info
->fdr
+ cur_fd
);
3055 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3056 processing_gcc_compilation
= 0;
3057 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3061 (*swap_sym_in
) (cur_bfd
,
3062 ((char *) debug_info
->external_sym
3063 + (fh
->isymBase
+ 1) * external_sym_size
),
3065 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3068 /* We indicate that this is a GCC compilation so that certain
3069 features will be enabled in stabsread/dbxread. */
3070 processing_gcc_compilation
= 2;
3074 if (processing_gcc_compilation
!= 0)
3079 unsigned long first_off
= 0;
3081 /* This symbol table contains stabs-in-ecoff entries. */
3083 /* Parse local symbols first */
3085 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3087 current_objfile
= NULL
;
3090 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3096 (*swap_sym_in
) (cur_bfd
,
3097 (((char *) debug_info
->external_sym
)
3098 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3100 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3102 if (ECOFF_IS_STAB (&sh
))
3104 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3106 /* We should never get non N_STAB symbols here, but they
3107 should be harmless, so keep process_one_symbol from
3108 complaining about them. */
3109 if (type_code
& N_STAB
)
3111 process_one_symbol (type_code
, 0, valu
, name
,
3112 pst
->section_offsets
, pst
->objfile
);
3114 if (type_code
== N_FUN
)
3116 /* Make up special symbol to contain
3117 procedure specific info */
3118 struct mips_extra_func_info
*e
=
3119 ((struct mips_extra_func_info
*)
3120 obstack_alloc (¤t_objfile
->symbol_obstack
,
3121 sizeof (struct mips_extra_func_info
)));
3122 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3124 memset ((PTR
) e
, 0, sizeof (struct mips_extra_func_info
));
3125 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3126 SYMBOL_CLASS (s
) = LOC_CONST
;
3127 SYMBOL_TYPE (s
) = builtin_type_void
;
3128 SYMBOL_VALUE (s
) = (long) e
;
3129 e
->pdr
.framereg
= -1;
3130 add_symbol_to_list (s
, &local_symbols
);
3133 else if (sh
.st
== stLabel
)
3135 if (sh
.index
== indexNil
)
3137 /* This is what the gcc2_compiled and __gnu_compiled_*
3138 show up as. So don't complain. */
3142 /* Handle encoded stab line number. */
3143 record_line (current_subfile
, sh
.index
, valu
);
3145 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3146 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3147 /* These are generated by gcc-2.x, do not complain */
3150 complain (&stab_unknown_complaint
, name
);
3152 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
3155 /* Sort the symbol table now, we are done adding symbols to it.
3156 We must do this before parse_procedure calls lookup_symbol. */
3157 sort_symtab_syms (st
);
3159 /* There used to be a call to sort_blocks here, but this should not
3160 be necessary for stabs symtabs. And as sort_blocks modifies the
3161 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3162 it did the wrong thing if the first procedure in a file was
3163 generated via asm statements. */
3165 /* Fill in procedure info next. */
3167 pdr_ptr
= ((char *) debug_info
->external_pdr
3168 + fh
->ipdFirst
* external_pdr_size
);
3169 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3170 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
3174 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
3180 parse_procedure (&pr
, st
, first_off
, pst
);
3185 /* This symbol table contains ordinary ecoff entries. */
3187 /* FIXME: doesn't use pst->section_offsets. */
3193 /* How many symbols will we need */
3194 /* FIXME, this does not count enum values. */
3195 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
3199 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
3203 f_max
+= fh
->csym
+ fh
->cpd
;
3204 maxlines
= 2 * fh
->cline
;
3205 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
3207 /* The proper language was already determined when building
3208 the psymtab, use it. */
3209 st
->language
= PST_PRIVATE (pst
)->pst_language
;
3212 psymtab_language
= st
->language
;
3214 lines
= LINETABLE (st
);
3216 /* Get a new lexical context */
3218 push_parse_stack ();
3219 top_stack
->cur_st
= st
;
3220 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
3222 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
3223 BLOCK_END (top_stack
->cur_block
) = 0;
3224 top_stack
->blocktype
= stFile
;
3225 top_stack
->maxsyms
= 2 * f_max
;
3226 top_stack
->cur_type
= 0;
3227 top_stack
->procadr
= 0;
3228 top_stack
->numargs
= 0;
3235 /* Parse local symbols first */
3236 sym_ptr
= ((char *) debug_info
->external_sym
3237 + fh
->isymBase
* external_sym_size
);
3238 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
3239 while (sym_ptr
< sym_end
)
3244 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
3245 c
= parse_symbol (&sh
,
3246 debug_info
->external_aux
+ fh
->iauxBase
,
3247 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3248 sym_ptr
+= c
* external_sym_size
;
3251 /* Linenumbers. At the end, check if we can save memory.
3252 parse_lines has to look ahead an arbitrary number of PDR
3253 structures, so we swap them all first. */
3257 struct cleanup
*old_chain
;
3263 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3265 old_chain
= make_cleanup (free
, pr_block
);
3267 pdr_ptr
= ((char *) debug_info
->external_pdr
3268 + fh
->ipdFirst
* external_pdr_size
);
3269 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3273 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3274 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3276 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
);
3277 if (lines
->nitems
< fh
->cline
)
3278 lines
= shrink_linetable (lines
);
3280 /* Fill in procedure info next. */
3282 pdr_in_end
= pdr_in
+ fh
->cpd
;
3283 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3284 parse_procedure (pdr_in
, 0, pr_block
->adr
, pst
);
3286 do_cleanups (old_chain
);
3290 LINETABLE (st
) = lines
;
3292 /* .. and our share of externals.
3293 XXX use the global list to speed up things here. how?
3294 FIXME, Maybe quit once we have found the right number of ext's? */
3295 top_stack
->cur_st
= st
;
3296 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3298 top_stack
->blocktype
= stFile
;
3300 = (debug_info
->symbolic_header
.isymMax
3301 + debug_info
->symbolic_header
.ipdMax
3302 + debug_info
->symbolic_header
.iextMax
);
3304 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3305 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3306 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3308 /* If there are undefined symbols, tell the user.
3309 The alpha has an undefined symbol for every symbol that is
3310 from a shared library, so tell the user only if verbose is on. */
3311 if (info_verbose
&& n_undef_symbols
)
3313 printf_filtered ("File %s contains %d unresolved references:",
3314 st
->filename
, n_undef_symbols
);
3315 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3316 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3317 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3324 /* Sort the symbol table now, we are done adding symbols to it.*/
3325 sort_symtab_syms (st
);
3330 /* Now link the psymtab and the symtab. */
3333 current_objfile
= NULL
;
3336 /* Ancillary parsing procedures. */
3338 /* Return 1 if the symbol pointed to by SH has a cross reference
3339 to an opaque aggregate type, else 0. */
3342 has_opaque_xref (fh
, sh
)
3351 if (sh
->index
== indexNil
)
3354 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
3355 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
3356 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
3360 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
3361 if (rn
->rfd
== 0xfff)
3362 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
3370 /* Lookup the type at relative index RN. Return it in TPP
3371 if found and in any event come up with its name PNAME.
3372 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3373 Return value says how many aux symbols we ate. */
3376 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3380 enum type_code type_code
; /* Use to alloc new type if none is found. */
3392 struct mdebug_pending
*pend
;
3394 *tpp
= (struct type
*)NULL
;
3396 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
3398 /* Escape index means 'the next one' */
3399 if (rn
->rfd
== 0xfff)
3402 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3409 /* mips cc uses a rf of -1 for opaque struct definitions.
3410 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3411 resolve them if the struct gets defined in another compilation unit. */
3414 *pname
= "<undefined>";
3415 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3416 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3420 /* mips cc uses an escaped rn->index of 0 for struct return types
3421 of procedures that were compiled without -g. These will always remain
3423 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3425 *pname
= "<undefined>";
3429 /* Find the relative file descriptor and the symbol in it. */
3430 fh
= get_rfd (fd
, rf
);
3431 xref_fd
= fh
- debug_info
->fdr
;
3433 if (rn
->index
>= fh
->csym
)
3435 /* File indirect entry is corrupt. */
3436 *pname
= "<illegal>";
3437 complain (&bad_rfd_entry_complaint
,
3438 sym_name
, xref_fd
, rn
->index
);
3442 /* If we have processed this symbol then we left a forwarding
3443 pointer to the type in the pending list. If not, we`ll put
3444 it in a list of pending types, to be processed later when
3445 the file will be. In any event, we collect the name for the
3448 esh
= ((char *) debug_info
->external_sym
3449 + ((fh
->isymBase
+ rn
->index
)
3450 * debug_swap
->external_sym_size
));
3451 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3453 /* Make sure that this type of cross reference can be handled. */
3454 if ((sh
.sc
!= scInfo
3455 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
3456 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3457 && sh
.st
!= stEnum
))
3458 && (sh
.st
!= stBlock
|| (sh
.sc
!= scCommon
&& sh
.sc
!= scSCommon
)))
3460 /* File indirect entry is corrupt. */
3461 *pname
= "<illegal>";
3462 complain (&bad_rfd_entry_complaint
,
3463 sym_name
, xref_fd
, rn
->index
);
3467 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3469 pend
= is_pending_symbol (fh
, esh
);
3474 /* We have not yet seen this type. */
3476 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
3480 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3482 a) forward declarations of structs/unions/enums which are not
3483 defined in this compilation unit.
3484 For these the type will be void. This is a bad design decision
3485 as cross referencing across compilation units is impossible
3486 due to the missing name.
3487 b) forward declarations of structs/unions/enums which are defined
3488 later in this file or in another file in the same compilation
3489 unit. Irix5 cc uses a stIndirect symbol for this.
3490 Simply cross reference those again to get the true type.
3491 The forward references are not entered in the pending list and
3492 in the symbol table. */
3494 (*debug_swap
->swap_tir_in
) (bigend
,
3495 &(debug_info
->external_aux
3496 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3498 if (tir
.tq0
!= tqNil
)
3499 complain (&illegal_forward_tq0_complaint
, sym_name
);
3503 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3505 *pname
= "<undefined>";
3512 (debug_info
->external_aux
3513 + fh
->iauxBase
+ sh
.index
+ 1),
3514 tpp
, type_code
, pname
,
3515 fh
->fBigendian
, sym_name
);
3519 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3520 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3526 else if (sh
.st
== stTypedef
)
3528 /* Parse the type for a normal typedef. This might recursively call
3529 cross_ref till we get a non typedef'ed type.
3530 FIXME: This is not correct behaviour, but gdb currently
3531 cannot handle typedefs without type copying. But type copying is
3532 impossible as we might have mutual forward references between
3533 two files and the copied type would not get filled in when
3534 we later parse its definition. */
3535 *tpp
= parse_type (xref_fd
,
3536 debug_info
->external_aux
+ fh
->iauxBase
,
3540 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3544 /* Cross reference to a struct/union/enum which is defined
3545 in another file in the same compilation unit but that file
3546 has not been parsed yet.
3547 Initialize the type only, it will be filled in when
3548 it's definition is parsed. */
3549 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3551 add_pending (fh
, esh
, *tpp
);
3554 /* We used one auxent normally, two if we got a "next one" rf. */
3559 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3560 keeping the symtab sorted */
3562 static struct symbol
*
3563 mylookup_symbol (name
, block
, namespace, class)
3565 register struct block
*block
;
3566 enum namespace namespace;
3567 enum address_class
class;
3569 register int bot
, top
, inc
;
3570 register struct symbol
*sym
;
3573 top
= BLOCK_NSYMS (block
);
3577 sym
= BLOCK_SYM (block
, bot
);
3578 if (SYMBOL_NAME (sym
)[0] == inc
3579 && SYMBOL_NAMESPACE (sym
) == namespace
3580 && SYMBOL_CLASS (sym
) == class
3581 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3585 block
= BLOCK_SUPERBLOCK (block
);
3587 return mylookup_symbol (name
, block
, namespace, class);
3592 /* Add a new symbol S to a block B.
3593 Infrequently, we will need to reallocate the block to make it bigger.
3594 We only detect this case when adding to top_stack->cur_block, since
3595 that's the only time we know how big the block is. FIXME. */
3602 int nsyms
= BLOCK_NSYMS (b
)++;
3603 struct block
*origb
;
3604 struct parse_stack
*stackp
;
3606 if (b
== top_stack
->cur_block
&&
3607 nsyms
>= top_stack
->maxsyms
)
3609 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3610 /* In this case shrink_block is actually grow_block, since
3611 BLOCK_NSYMS(b) is larger than its current size. */
3613 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3615 /* Now run through the stack replacing pointers to the
3616 original block. shrink_block has already done this
3617 for the blockvector and BLOCK_FUNCTION. */
3618 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3620 if (stackp
->cur_block
== origb
)
3622 stackp
->cur_block
= b
;
3623 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3627 BLOCK_SYM (b
, nsyms
) = s
;
3630 /* Add a new block B to a symtab S */
3637 struct blockvector
*bv
= BLOCKVECTOR (s
);
3639 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3640 (sizeof (struct blockvector
)
3641 + BLOCKVECTOR_NBLOCKS (bv
)
3642 * sizeof (bv
->block
)));
3643 if (bv
!= BLOCKVECTOR (s
))
3644 BLOCKVECTOR (s
) = bv
;
3646 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3649 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3650 MIPS' linenumber encoding might need more than one byte
3651 to describe it, LAST is used to detect these continuation lines.
3653 Combining lines with the same line number seems like a bad idea.
3654 E.g: There could be a line number entry with the same line number after the
3655 prologue and GDB should not ignore it (this is a better way to find
3656 a prologue than mips_skip_prologue).
3657 But due to the compressed line table format there are line number entries
3658 for the same line which are needed to bridge the gap to the next
3659 line number entry. These entries have a bogus address info with them
3660 and we are unable to tell them from intended duplicate line number
3662 This is another reason why -ggdb debugging format is preferable. */
3665 add_line (lt
, lineno
, adr
, last
)
3666 struct linetable
*lt
;
3671 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3672 Change them to something sensible. */
3676 last
= -2; /* make sure we record first line */
3678 if (last
== lineno
) /* skip continuation lines */
3681 lt
->item
[lt
->nitems
].line
= lineno
;
3682 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3686 /* Sorting and reordering procedures */
3688 /* Blocks with a smaller low bound should come first */
3691 compare_blocks (arg1
, arg2
)
3695 register int addr_diff
;
3696 struct block
**b1
= (struct block
**) arg1
;
3697 struct block
**b2
= (struct block
**) arg2
;
3699 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3701 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3705 /* Sort the blocks of a symtab S.
3706 Reorder the blocks in the blockvector by code-address,
3707 as required by some MI search routines */
3713 struct blockvector
*bv
= BLOCKVECTOR (s
);
3715 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3718 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3719 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3720 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3721 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3725 * This is very unfortunate: normally all functions are compiled in
3726 * the order they are found, but if the file is compiled -O3 things
3727 * are very different. It would be nice to find a reliable test
3728 * to detect -O3 images in advance.
3730 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3731 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3732 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3733 sizeof (struct block
*),
3737 register CORE_ADDR high
= 0;
3738 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3740 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3741 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3742 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3743 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3746 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3747 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3749 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3750 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3751 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3752 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3756 /* Constructor/restructor/destructor procedures */
3758 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3759 MAXSYMS and linenumbers MAXLINES we'll put in it */
3761 static struct symtab
*
3762 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3766 struct objfile
*objfile
;
3768 struct symtab
*s
= allocate_symtab (name
, objfile
);
3770 LINETABLE (s
) = new_linetable (maxlines
);
3772 /* All symtabs must have at least two blocks */
3773 BLOCKVECTOR (s
) = new_bvect (2);
3774 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3775 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3776 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3777 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3779 s
->free_code
= free_linetable
;
3784 /* Allocate a new partial_symtab NAME */
3786 static struct partial_symtab
*
3787 new_psymtab (name
, objfile
, section_offsets
)
3789 struct objfile
*objfile
;
3790 struct section_offsets
*section_offsets
;
3792 struct partial_symtab
*psymtab
;
3794 psymtab
= allocate_psymtab (name
, objfile
);
3795 psymtab
->section_offsets
= section_offsets
;
3797 /* Keep a backpointer to the file's symbols */
3799 psymtab
->read_symtab_private
= ((char *)
3800 obstack_alloc (&objfile
->psymbol_obstack
,
3801 sizeof (struct symloc
)));
3802 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3803 CUR_BFD (psymtab
) = cur_bfd
;
3804 DEBUG_SWAP (psymtab
) = debug_swap
;
3805 DEBUG_INFO (psymtab
) = debug_info
;
3806 PENDING_LIST (psymtab
) = pending_list
;
3808 /* The way to turn this into a symtab is to call... */
3809 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3814 /* Allocate a linetable array of the given SIZE. Since the struct
3815 already includes one item, we subtract one when calculating the
3816 proper size to allocate. */
3818 static struct linetable
*
3819 new_linetable (size
)
3822 struct linetable
*l
;
3824 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3825 l
= (struct linetable
*) xmalloc (size
);
3830 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3831 I am not so sure about the 3.4 ones.
3833 Since the struct linetable already includes one item, we subtract one when
3834 calculating the proper size to allocate. */
3836 static struct linetable
*
3837 shrink_linetable (lt
)
3838 struct linetable
*lt
;
3841 return (struct linetable
*) xrealloc ((PTR
) lt
,
3842 (sizeof (struct linetable
)
3844 * sizeof (lt
->item
))));
3847 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3849 static struct blockvector
*
3853 struct blockvector
*bv
;
3856 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3857 bv
= (struct blockvector
*) xzalloc (size
);
3859 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3864 /* Allocate and zero a new block of MAXSYMS symbols */
3866 static struct block
*
3870 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3872 return (struct block
*) xzalloc (size
);
3875 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3876 Shrink_block can also be used by add_symbol to grow a block. */
3878 static struct block
*
3884 struct blockvector
*bv
= BLOCKVECTOR (s
);
3887 /* Just reallocate it and fix references to the old one */
3889 new = (struct block
*) xrealloc ((PTR
) b
,
3890 (sizeof (struct block
)
3891 + ((BLOCK_NSYMS (b
) - 1)
3892 * sizeof (struct symbol
*))));
3894 /* Should chase pointers to old one. Fortunately, that`s just
3895 the block`s function and inferior blocks */
3896 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3897 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3898 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3899 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3900 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3901 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3902 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3906 /* Create a new symbol with printname NAME */
3908 static struct symbol
*
3912 struct symbol
*s
= ((struct symbol
*)
3913 obstack_alloc (¤t_objfile
->symbol_obstack
,
3914 sizeof (struct symbol
)));
3916 memset ((PTR
) s
, 0, sizeof (*s
));
3917 SYMBOL_NAME (s
) = name
;
3918 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3919 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3923 /* Create a new type with printname NAME */
3925 static struct type
*
3931 t
= alloc_type (current_objfile
);
3932 TYPE_NAME (t
) = name
;
3933 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3937 /* Read ECOFF debugging information from a BFD section. This is
3938 called from elfread.c. It parses the section into a
3939 ecoff_debug_info struct, and then lets the rest of the file handle
3943 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3944 struct objfile
*objfile
;
3945 const struct ecoff_debug_swap
*swap
;
3947 struct section_offsets
*section_offsets
;
3949 bfd
*abfd
= objfile
->obfd
;
3950 struct ecoff_debug_info
*info
;
3952 info
= ((struct ecoff_debug_info
*)
3953 obstack_alloc (&objfile
->psymbol_obstack
,
3954 sizeof (struct ecoff_debug_info
)));
3956 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
3957 error ("Error reading ECOFF debugging information: %s",
3958 bfd_errmsg (bfd_get_error ()));
3960 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3964 /* Things used for calling functions in the inferior.
3965 These functions are exported to our companion
3966 mips-tdep.c file and are here because they play
3967 with the symbol-table explicitly. */
3969 /* Sigtramp: make sure we have all the necessary information
3970 about the signal trampoline code. Since the official code
3971 from MIPS does not do so, we make up that information ourselves.
3972 If they fix the library (unlikely) this code will neutralize itself. */
3974 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3975 here because it calls functions defined in this file, but perhaps
3976 this could be handled in a better way. */
3983 struct block
*b
, *b0
= NULL
;
3985 sigtramp_address
= -1;
3987 /* We have to handle the following cases here:
3988 a) The Mips library has a sigtramp label within sigvec.
3989 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3990 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3993 b0
= SYMBOL_BLOCK_VALUE (s
);
3994 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3998 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3999 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
4002 /* But maybe this program uses its own version of sigvec */
4006 /* Did we or MIPSco fix the library ? */
4007 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
4009 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
4010 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
4014 sigtramp_address
= SYMBOL_VALUE (s
);
4015 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
4017 /* But what symtab does it live in ? */
4018 st
= find_pc_symtab (SYMBOL_VALUE (s
));
4021 * Ok, there goes the fix: turn it into a procedure, with all the
4022 * needed info. Note we make it a nested procedure of sigvec,
4023 * which is the way the (assembly) code is actually written.
4025 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4026 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4027 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4029 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
4031 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4033 SYMBOL_BLOCK_VALUE (s
) = b
;
4034 BLOCK_START (b
) = sigtramp_address
;
4035 BLOCK_END (b
) = sigtramp_end
;
4036 BLOCK_FUNCTION (b
) = s
;
4037 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4041 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4043 struct mips_extra_func_info
*e
=
4044 ((struct mips_extra_func_info
*)
4045 xzalloc (sizeof (struct mips_extra_func_info
)));
4047 e
->numargs
= 0; /* the kernel thinks otherwise */
4048 e
->pdr
.frameoffset
= 32;
4049 e
->pdr
.framereg
= SP_REGNUM
;
4050 /* Note that setting pcreg is no longer strictly necessary as
4051 mips_frame_saved_pc is now aware of signal handler frames. */
4052 e
->pdr
.pcreg
= PC_REGNUM
;
4053 e
->pdr
.regmask
= -2;
4054 /* Offset to saved r31, in the sigtramp case the saved registers
4055 are above the frame in the sigcontext.
4056 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4057 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4058 and 32 * 4 bytes for the floating point registers. */
4059 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4060 e
->pdr
.fregmask
= -1;
4061 /* Offset to saved f30 (first saved *double* register). */
4062 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4063 e
->pdr
.isym
= (long) s
;
4064 e
->pdr
.adr
= sigtramp_address
;
4066 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4067 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4068 SYMBOL_VALUE (s
) = (long) e
;
4069 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4070 SYMBOL_CLASS (s
) = LOC_CONST
;
4071 SYMBOL_TYPE (s
) = builtin_type_void
;
4072 current_objfile
= NULL
;
4075 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4079 _initialize_mdebugread ()
4081 /* Missing basic types */
4083 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4085 mdebug_type_string
=
4086 init_type (TYPE_CODE_STRING
,
4087 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4089 (struct objfile
*) NULL
);
4091 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4092 good? Would we be better off with TYPE_CODE_ERROR? Should
4093 TYPE_CODE_ERROR print things in hex if it knows the size? */
4094 mdebug_type_fixed_dec
=
4095 init_type (TYPE_CODE_INT
,
4096 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4098 (struct objfile
*) NULL
);
4100 mdebug_type_float_dec
=
4101 init_type (TYPE_CODE_ERROR
,
4102 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4103 0, "floating decimal",
4104 (struct objfile
*) NULL
);