1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
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
);
790 /* FIXME: This has not been tested. See dbxread.c */
791 /* Add the type of this parameter to the function/procedure
792 type of this block. */
793 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
797 case stLabel
: /* label, goes into current block */
798 s
= new_symbol (name
);
799 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
800 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
801 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
802 SYMBOL_TYPE (s
) = builtin_type_int
;
803 add_symbol (s
, top_stack
->cur_block
);
806 case stProc
: /* Procedure, usually goes into global block */
807 case stStaticProc
: /* Static procedure, goes into current block */
808 s
= new_symbol (name
);
809 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
810 SYMBOL_CLASS (s
) = LOC_BLOCK
;
811 /* Type of the return value */
812 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
813 t
= builtin_type_int
;
815 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
816 b
= top_stack
->cur_block
;
817 if (sh
->st
== stProc
)
819 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
820 /* The next test should normally be true, but provides a
821 hook for nested functions (which we don't want to make
823 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
824 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
825 /* Irix 5 sometimes has duplicate names for the same
826 function. We want to add such names up at the global
827 level, not as a nested function. */
828 else if (sh
->value
== top_stack
->procadr
)
829 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
833 /* Make a type for the procedure itself */
835 /* FIXME: This has not been tested yet! See dbxread.c */
836 /* Generate a template for the type of this function. The
837 types of the arguments will be added as we read the symbol
839 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
841 SYMBOL_TYPE (s
) = lookup_function_type (t
);
844 /* Create and enter a new lexical context */
845 b
= new_block (top_stack
->maxsyms
);
846 SYMBOL_BLOCK_VALUE (s
) = b
;
847 BLOCK_FUNCTION (b
) = s
;
848 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
849 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
850 add_block (b
, top_stack
->cur_st
);
852 /* Not if we only have partial info */
853 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
857 top_stack
->cur_block
= b
;
858 top_stack
->blocktype
= sh
->st
;
859 top_stack
->cur_type
= SYMBOL_TYPE (s
);
860 top_stack
->cur_field
= -1;
861 top_stack
->procadr
= sh
->value
;
862 top_stack
->numargs
= 0;
865 /* Beginning of code for structure, union, and enum definitions.
866 They all share a common set of local variables, defined here. */
868 enum type_code type_code
;
874 case stStruct
: /* Start a block defining a struct type */
875 type_code
= TYPE_CODE_STRUCT
;
876 goto structured_common
;
878 case stUnion
: /* Start a block defining a union type */
879 type_code
= TYPE_CODE_UNION
;
880 goto structured_common
;
882 case stEnum
: /* Start a block defining an enum type */
883 type_code
= TYPE_CODE_ENUM
;
884 goto structured_common
;
886 case stBlock
: /* Either a lexical block, or some type */
887 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
888 goto case_stBlock_code
; /* Lexical block */
890 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
892 /* Common code for handling struct, union, enum, and/or as-yet-
893 unknown-type blocks of info about structured data. `type_code'
894 has been set to the proper TYPE_CODE, if we know it. */
897 top_stack
->blocktype
= stBlock
;
899 /* First count the number of fields and the highest value. */
902 for (ext_tsym
= ext_sh
+ external_sym_size
;
904 ext_tsym
+= external_sym_size
)
908 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
916 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
917 /* If the type of the member is Nil (or Void),
918 without qualifiers, assume the tag is an
920 if (tsym
.index
== indexNil
)
921 type_code
= TYPE_CODE_ENUM
;
924 (*debug_swap
->swap_tir_in
) (bigend
,
925 &ax
[tsym
.index
].a_ti
,
927 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
929 type_code
= TYPE_CODE_ENUM
;
932 if (tsym
.value
> max_value
)
933 max_value
= tsym
.value
;
942 /* This is a no-op; is it trying to tell us something
943 we should be checking? */
944 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
948 /* This is something like a struct within a
949 struct. Skip over the fields of the inner
950 struct. The -1 is because the for loop will
951 increment ext_tsym. */
952 ext_tsym
= ((char *) debug_info
->external_sym
953 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
954 * external_sym_size
));
960 /* mips cc puts out a typedef for struct x if it is not yet
961 defined when it encounters
962 struct y { struct x *xp; };
967 /* Irix5 cc puts out a stIndirect for struct x if it is not
968 yet defined when it encounters
969 struct y { struct x *xp; };
974 complain (&block_member_complaint
, tsym
.st
);
979 /* In an stBlock, there is no way to distinguish structs,
980 unions, and enums at this point. This is a bug in the
981 original design (that has been fixed with the recent
982 addition of the stStruct, stUnion, and stEnum symbol
983 types.) The way you can tell is if/when you see a variable
984 or field of that type. In that case the variable's type
985 (in the AUX table) says if the type is struct, union, or
986 enum, and points back to the stBlock here. So you can
987 patch the tag kind up later - but only if there actually is
988 a variable or field of that type.
990 So until we know for sure, we will guess at this point.
992 If the first member has index==indexNil or a void type,
993 assume we have an enumeration.
994 Otherwise, if there is more than one member, and all
995 the members have offset 0, assume we have a union.
996 Otherwise, assume we have a struct.
998 The heuristic could guess wrong in the case of of an
999 enumeration with no members or a union with one (or zero)
1000 members, or when all except the last field of a struct have
1001 width zero. These are uncommon and/or illegal situations,
1002 and in any case guessing wrong probably doesn't matter
1005 But if we later do find out we were wrong, we fixup the tag
1006 kind. Members of an enumeration must be handled
1007 differently from struct/union fields, and that is harder to
1008 patch up, but luckily we shouldn't need to. (If there are
1009 any enumeration members, we can tell for sure it's an enum
1012 if (type_code
== TYPE_CODE_UNDEF
)
1013 if (nfields
> 1 && max_value
== 0)
1014 type_code
= TYPE_CODE_UNION
;
1016 type_code
= TYPE_CODE_STRUCT
;
1018 /* Create a new type or use the pending type. */
1019 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1020 if (pend
== (struct mdebug_pending
*) NULL
)
1022 t
= new_type (NULL
);
1023 add_pending (cur_fdr
, ext_sh
, t
);
1028 /* Do not set the tag name if it is a compiler generated tag name
1029 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1030 Alpha cc puts out an sh->iss of zero for those. */
1031 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1032 TYPE_TAG_NAME (t
) = NULL
;
1034 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1037 TYPE_CODE (t
) = type_code
;
1038 TYPE_LENGTH (t
) = sh
->value
;
1039 TYPE_NFIELDS (t
) = nfields
;
1040 TYPE_FIELDS (t
) = f
= ((struct field
*)
1042 nfields
* sizeof (struct field
)));
1044 if (type_code
== TYPE_CODE_ENUM
)
1046 /* This is a non-empty enum. */
1048 /* DEC c89 has the number of enumerators in the sh.value field,
1049 not the type length, so we have to compensate for that
1050 incompatibility quirk.
1051 This might do the wrong thing for an enum with one or two
1052 enumerators and gcc -gcoff -fshort-enums, but these cases
1053 are hopefully rare enough. */
1054 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1055 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1056 for (ext_tsym
= ext_sh
+ external_sym_size
;
1058 ext_tsym
+= external_sym_size
)
1061 struct symbol
*enum_sym
;
1063 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1065 if (tsym
.st
!= stMember
)
1068 f
->bitpos
= tsym
.value
;
1070 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1073 enum_sym
= ((struct symbol
*)
1074 obstack_alloc (¤t_objfile
->symbol_obstack
,
1075 sizeof (struct symbol
)));
1076 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1077 SYMBOL_NAME (enum_sym
) = f
->name
;
1078 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1079 SYMBOL_TYPE (enum_sym
) = t
;
1080 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1081 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1082 add_symbol (enum_sym
, top_stack
->cur_block
);
1084 /* Skip the stMembers that we've handled. */
1089 /* make this the current type */
1090 top_stack
->cur_type
= t
;
1091 top_stack
->cur_field
= 0;
1093 /* Do not create a symbol for alpha cc unnamed structs. */
1097 /* gcc puts out an empty struct for an opaque struct definitions,
1098 do not create a symbol for it either. */
1099 if (TYPE_NFIELDS (t
) == 0)
1101 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1105 s
= new_symbol (name
);
1106 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1107 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1108 SYMBOL_VALUE (s
) = 0;
1109 SYMBOL_TYPE (s
) = t
;
1110 add_symbol (s
, top_stack
->cur_block
);
1113 /* End of local variables shared by struct, union, enum, and
1114 block (as yet unknown struct/union/enum) processing. */
1118 /* beginnning of (code) block. Value of symbol
1119 is the displacement from procedure start */
1120 push_parse_stack ();
1122 /* Do not start a new block if this is the outermost block of a
1123 procedure. This allows the LOC_BLOCK symbol to point to the
1124 block with the local variables, so funcname::var works. */
1125 if (top_stack
->blocktype
== stProc
1126 || top_stack
->blocktype
== stStaticProc
)
1128 top_stack
->blocktype
= stNil
;
1132 top_stack
->blocktype
= stBlock
;
1133 b
= new_block (top_stack
->maxsyms
);
1134 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1135 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1136 top_stack
->cur_block
= b
;
1137 add_block (b
, top_stack
->cur_st
);
1140 case stEnd
: /* end (of anything) */
1141 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1143 /* Finished with type */
1144 top_stack
->cur_type
= 0;
1146 else if (sh
->sc
== scText
&&
1147 (top_stack
->blocktype
== stProc
||
1148 top_stack
->blocktype
== stStaticProc
))
1150 /* Finished with procedure */
1151 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1152 struct mips_extra_func_info
*e
;
1156 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1158 /* Make up special symbol to contain procedure specific info */
1159 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1160 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1161 SYMBOL_CLASS (s
) = LOC_CONST
;
1162 SYMBOL_TYPE (s
) = builtin_type_void
;
1163 e
= ((struct mips_extra_func_info
*)
1164 obstack_alloc (¤t_objfile
->symbol_obstack
,
1165 sizeof (struct mips_extra_func_info
)));
1166 SYMBOL_VALUE (s
) = (long) e
;
1167 e
->numargs
= top_stack
->numargs
;
1168 add_symbol (s
, top_stack
->cur_block
);
1170 /* Reallocate symbols, saving memory */
1171 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1173 /* f77 emits proc-level with address bounds==[0,0],
1174 So look for such child blocks, and patch them. */
1175 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1177 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1178 if (BLOCK_SUPERBLOCK (b_bad
) == b
1179 && BLOCK_START (b_bad
) == top_stack
->procadr
1180 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1182 BLOCK_START (b_bad
) = BLOCK_START (b
);
1183 BLOCK_END (b_bad
) = BLOCK_END (b
);
1187 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1189 /* End of (code) block. The value of the symbol is the
1190 displacement from the procedure`s start address of the
1191 end of this block. */
1192 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1193 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1195 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1197 /* End of outermost block. Pop parse stack and ignore. The
1198 following stEnd of stProc will take care of the block. */
1201 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1203 /* End of file. Pop parse stack and ignore. Higher
1204 level code deals with this. */
1208 complain (&stEnd_complaint
, sh
->sc
);
1210 pop_parse_stack (); /* restore previous lexical context */
1213 case stMember
: /* member of struct or union */
1214 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1216 f
->bitpos
= sh
->value
;
1218 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1219 f
->bitsize
= bitsize
;
1222 case stIndirect
: /* forward declaration on Irix5 */
1223 /* Forward declarations from Irix5 cc are handled by cross_ref,
1227 case stTypedef
: /* type definition */
1228 /* Typedefs for forward declarations and opaque structs from alpha cc
1229 are handled by cross_ref, skip them. */
1233 /* Parse the type or use the pending type. */
1234 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1235 if (pend
== (struct mdebug_pending
*) NULL
)
1237 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1238 add_pending (cur_fdr
, ext_sh
, t
);
1243 /* mips cc puts out a typedef with the name of the struct for forward
1244 declarations. These should not go into the symbol table and
1245 TYPE_NAME should not be set for them.
1246 They can't be distinguished from an intentional typedef to
1247 the same name however:
1249 struct x { int ix; int jx; };
1253 struct xx {int ixx; int jxx; };
1254 generates a cross referencing stTypedef for x and xx.
1255 The user visible effect of this is that the type of a pointer
1256 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1257 The problem is fixed with alpha cc and Irix5 cc. */
1259 /* However if the typedef cross references to an opaque aggregate, it
1260 is safe to omit it from the symbol table. */
1262 if (has_opaque_xref (cur_fdr
, sh
))
1264 s
= new_symbol (name
);
1265 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1266 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1267 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1268 SYMBOL_TYPE (s
) = t
;
1269 add_symbol (s
, top_stack
->cur_block
);
1271 /* Incomplete definitions of structs should not get a name. */
1272 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1273 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1274 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1275 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1277 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1278 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1280 /* If we are giving a name to a type such as "pointer to
1281 foo" or "function returning foo", we better not set
1282 the TYPE_NAME. If the program contains "typedef char
1283 *caddr_t;", we don't want all variables of type char
1284 * to print as caddr_t. This is not just a
1285 consequence of GDB's type management; CC and GCC (at
1286 least through version 2.4) both output variables of
1287 either type char * or caddr_t with the type
1288 refering to the stTypedef symbol for caddr_t. If a future
1289 compiler cleans this up it GDB is not ready for it
1290 yet, but if it becomes ready we somehow need to
1291 disable this check (without breaking the PCC/GCC2.4
1296 Fortunately, this check seems not to be necessary
1297 for anything except pointers or functions. */
1300 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1304 case stFile
: /* file name */
1305 push_parse_stack ();
1306 top_stack
->blocktype
= sh
->st
;
1309 /* I`ve never seen these for C */
1311 break; /* register relocation */
1313 break; /* forwarding address */
1315 break; /* constant */
1317 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1324 /* Parse the type information provided in the raw AX entries for
1325 the symbol SH. Return the bitfield size in BS, in case.
1326 We must byte-swap the AX entries before we use them; BIGEND says whether
1327 they are big-endian or little-endian (from fh->fBigendian). */
1329 static struct type
*
1330 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1333 unsigned int aux_index
;
1338 /* Null entries in this map are treated specially */
1339 static struct type
**map_bt
[] =
1341 &builtin_type_void
, /* btNil */
1343 &builtin_type_char
, /* btChar */
1344 &builtin_type_unsigned_char
,/* btUChar */
1345 &builtin_type_short
, /* btShort */
1346 &builtin_type_unsigned_short
, /* btUShort */
1347 &builtin_type_int
, /* btInt */
1348 &builtin_type_unsigned_int
, /* btUInt */
1349 &builtin_type_long
, /* btLong */
1350 &builtin_type_unsigned_long
,/* btULong */
1351 &builtin_type_float
, /* btFloat */
1352 &builtin_type_double
, /* btDouble */
1359 &builtin_type_complex
, /* btComplex */
1360 &builtin_type_double_complex
,/* btDComplex */
1362 &mdebug_type_fixed_dec
, /* btFixedDec */
1363 &mdebug_type_float_dec
, /* btFloatDec */
1364 &mdebug_type_string
, /* btString */
1367 &builtin_type_void
, /* btVoid */
1368 0, /* DEC C++: Pointer to member */
1369 0, /* DEC C++: Virtual function table */
1370 0, /* DEC C++: Class (Record) */
1371 &builtin_type_long
, /* btLong64 */
1372 &builtin_type_unsigned_long
, /* btULong64 */
1373 &builtin_type_long_long
, /* btLongLong64 */
1374 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1375 &builtin_type_unsigned_long
, /* btAdr64 */
1376 &builtin_type_long
, /* btInt64 */
1377 &builtin_type_unsigned_long
, /* btUInt64 */
1381 struct type
*tp
= 0;
1382 enum type_code type_code
= TYPE_CODE_UNDEF
;
1384 /* Handle undefined types, they have indexNil. */
1385 if (aux_index
== indexNil
)
1386 return builtin_type_int
;
1388 /* Handle corrupt aux indices. */
1389 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1391 complain (&index_complaint
, sym_name
);
1392 return builtin_type_int
;
1396 /* Use aux as a type information record, map its basic type. */
1397 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1398 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1400 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1401 return builtin_type_int
;
1405 tp
= *map_bt
[t
->bt
];
1410 /* Cannot use builtin types -- build our own */
1414 tp
= lookup_pointer_type (builtin_type_void
);
1417 type_code
= TYPE_CODE_STRUCT
;
1420 type_code
= TYPE_CODE_UNION
;
1423 type_code
= TYPE_CODE_ENUM
;
1426 type_code
= TYPE_CODE_RANGE
;
1429 type_code
= TYPE_CODE_SET
;
1432 /* alpha cc uses this for typedefs. The true type will be
1433 obtained by crossreferencing below. */
1434 type_code
= TYPE_CODE_ERROR
;
1437 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1438 return builtin_type_int
;
1442 /* Move on to next aux */
1447 /* Inhibit core dumps with some cfront generated objects that
1449 if (bs
== (int *)NULL
)
1451 complain (&bad_fbitfield_complaint
, sym_name
);
1452 return builtin_type_int
;
1454 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1458 /* All these types really point to some (common) MIPS type
1459 definition, and only the type-qualifiers fully identify
1460 them. We'll make the same effort at sharing. */
1461 if (t
->bt
== btStruct
||
1465 /* btSet (I think) implies that the name is a tag name, not a typedef
1466 name. This apparently is a MIPS extension for C sets. */
1471 /* Try to cross reference this type, build new type on failure. */
1472 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1473 if (tp
== (struct type
*) NULL
)
1474 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1476 /* DEC c89 produces cross references to qualified aggregate types,
1477 dereference them. */
1478 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1479 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1480 tp
= tp
->target_type
;
1482 /* Make sure that TYPE_CODE(tp) has an expected type code.
1483 Any type may be returned from cross_ref if file indirect entries
1485 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1486 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1487 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1489 complain (&unexpected_type_code_complaint
, sym_name
);
1494 /* Usually, TYPE_CODE(tp) is already type_code. The main
1495 exception is if we guessed wrong re struct/union/enum.
1496 But for struct vs. union a wrong guess is harmless, so
1497 don't complain(). */
1498 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1499 && type_code
!= TYPE_CODE_ENUM
)
1500 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1501 && type_code
== TYPE_CODE_ENUM
))
1503 complain (&bad_tag_guess_complaint
, sym_name
);
1506 if (TYPE_CODE (tp
) != type_code
)
1508 TYPE_CODE (tp
) = type_code
;
1511 /* Do not set the tag name if it is a compiler generated tag name
1512 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1513 if (name
[0] == '.' || name
[0] == '\0')
1514 TYPE_TAG_NAME (tp
) = NULL
;
1515 else if (TYPE_TAG_NAME (tp
) == NULL
1516 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1517 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1518 ¤t_objfile
->type_obstack
);
1522 /* All these types really point to some (common) MIPS type
1523 definition, and only the type-qualifiers fully identify
1524 them. We'll make the same effort at sharing.
1525 FIXME: btIndirect cannot happen here as it is handled by the
1526 switch t->bt above. And we are not doing any guessing on range types. */
1527 if (t
->bt
== btIndirect
||
1532 /* Try to cross reference this type, build new type on failure. */
1533 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1534 if (tp
== (struct type
*) NULL
)
1535 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1537 /* Make sure that TYPE_CODE(tp) has an expected type code.
1538 Any type may be returned from cross_ref if file indirect entries
1540 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1542 complain (&unexpected_type_code_complaint
, sym_name
);
1546 /* Usually, TYPE_CODE(tp) is already type_code. The main
1547 exception is if we guessed wrong re struct/union/enum. */
1548 if (TYPE_CODE (tp
) != type_code
)
1550 complain (&bad_tag_guess_complaint
, sym_name
);
1551 TYPE_CODE (tp
) = type_code
;
1553 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1554 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1555 ¤t_objfile
->type_obstack
);
1558 if (t
->bt
== btTypedef
)
1562 /* Try to cross reference this type, it should succeed. */
1563 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1564 if (tp
== (struct type
*) NULL
)
1566 complain (&unable_to_cross_ref_complaint
, sym_name
);
1567 tp
= builtin_type_int
;
1571 /* Deal with range types */
1572 if (t
->bt
== btRange
)
1574 TYPE_NFIELDS (tp
) = 2;
1575 TYPE_FIELDS (tp
) = ((struct field
*)
1576 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1577 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1578 ¤t_objfile
->type_obstack
);
1579 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1581 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1582 ¤t_objfile
->type_obstack
);
1583 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1587 /* Parse all the type qualifiers now. If there are more
1588 than 6 the game will continue in the next aux */
1592 #define PARSE_TQ(tq) \
1593 if (t->tq != tqNil) \
1594 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1606 /* mips cc 2.x and gcc never put out continued aux entries. */
1610 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1614 /* Complain for illegal continuations due to corrupt aux entries. */
1616 complain (&bad_continued_complaint
, sym_name
);
1621 /* Make up a complex type from a basic one. Type is passed by
1622 reference in TPP and side-effected as necessary. The type
1623 qualifier TQ says how to handle the aux symbols at AX for
1624 the symbol SX we are currently analyzing. BIGEND says whether
1625 aux symbols are big-endian or little-endian.
1626 Returns the number of aux symbols we parsed. */
1629 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1640 /* Used in array processing */
1651 t
= lookup_pointer_type (*tpp
);
1656 t
= lookup_function_type (*tpp
);
1663 /* Determine and record the domain type (type of index) */
1664 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1670 rf
= AUX_GET_ISYM (bigend
, ax
);
1673 fh
= get_rfd (fd
, rf
);
1675 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1676 id
, (int *) NULL
, bigend
, sym_name
);
1678 /* The bounds type should be an integer type, but might be anything
1679 else due to corrupt aux entries. */
1680 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1682 complain (&array_index_type_complaint
, sym_name
);
1683 indx
= builtin_type_int
;
1686 /* Get the bounds, and create the array type. */
1688 lower
= AUX_GET_DNLOW (bigend
, ax
);
1690 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1692 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1694 range
= create_range_type ((struct type
*) NULL
, indx
,
1697 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1699 /* We used to fill in the supplied array element bitsize
1700 here if the TYPE_LENGTH of the target type was zero.
1701 This happens for a `pointer to an array of anonymous structs',
1702 but in this case the array element bitsize is also zero,
1703 so nothing is gained.
1704 And we used to check the TYPE_LENGTH of the target type against
1705 the supplied array element bitsize.
1706 gcc causes a mismatch for `pointer to array of object',
1707 since the sdb directives it uses do not have a way of
1708 specifying the bitsize, but it does no harm (the
1709 TYPE_LENGTH should be correct) and we should be able to
1710 ignore the erroneous bitsize from the auxiliary entry safely.
1711 dbx seems to ignore it too. */
1717 /* Volatile -- currently ignored */
1721 /* Const -- currently ignored */
1725 complain (&unknown_type_qual_complaint
, tq
);
1731 /* Parse a procedure descriptor record PR. Note that the procedure is
1732 parsed _after_ the local symbols, now we just insert the extra
1733 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1734 already been placed in the procedure's main block. Note also that
1735 images that have been partially stripped (ld -x) have been deprived
1736 of local symbols, and we have to cope with them here. FIRST_OFF is
1737 the offset of the first procedure for this FDR; we adjust the
1738 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1739 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1740 in question, or NULL to use top_stack->cur_block. */
1742 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long,
1743 struct partial_symtab
*));
1746 parse_procedure (pr
, search_symtab
, first_off
, pst
)
1748 struct symtab
*search_symtab
;
1749 unsigned long first_off
;
1750 struct partial_symtab
*pst
;
1752 struct symbol
*s
, *i
;
1754 struct mips_extra_func_info
*e
;
1757 /* Simple rule to find files linked "-x" */
1758 if (cur_fdr
->rss
== -1)
1762 /* Static procedure at address pr->adr. Sigh. */
1763 /* FIXME-32x64. assuming pr->adr fits in long. */
1764 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1772 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1773 ((char *) debug_info
->external_ext
1775 * debug_swap
->external_ext_size
)),
1777 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1785 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1786 ((char *) debug_info
->external_sym
1787 + ((cur_fdr
->isymBase
+ pr
->isym
)
1788 * debug_swap
->external_sym_size
)),
1790 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1793 if (search_symtab
!= NULL
)
1796 /* This loses both in the case mentioned (want a static, find a global),
1797 but also if we are looking up a non-mangled name which happens to
1798 match the name of a mangled function. */
1799 /* We have to save the cur_fdr across the call to lookup_symbol.
1800 If the pdr is for a static function and if a global function with
1801 the same name exists, lookup_symbol will eventually read in the symtab
1802 for the global function and clobber cur_fdr. */
1803 FDR
*save_cur_fdr
= cur_fdr
;
1804 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1805 cur_fdr
= save_cur_fdr
;
1809 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1815 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1816 VAR_NAMESPACE
, LOC_BLOCK
);
1820 b
= SYMBOL_BLOCK_VALUE (s
);
1824 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1828 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1829 s
= new_symbol (sh_name
);
1830 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1831 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1832 /* Donno its type, hope int is ok */
1833 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1834 add_symbol (s
, top_stack
->cur_block
);
1835 /* Wont have symbols for this one */
1837 SYMBOL_BLOCK_VALUE (s
) = b
;
1838 BLOCK_FUNCTION (b
) = s
;
1839 BLOCK_START (b
) = pr
->adr
;
1840 /* BOUND used to be the end of procedure's text, but the
1841 argument is no longer passed in. */
1842 BLOCK_END (b
) = bound
;
1843 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1844 add_block (b
, top_stack
->cur_st
);
1848 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1852 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1854 e
->pdr
.isym
= (long) s
;
1855 e
->pdr
.adr
+= pst
->textlow
- first_off
;
1857 /* Correct incorrect setjmp procedure descriptor from the library
1858 to make backtrace through setjmp work. */
1859 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1861 complain (&bad_setjmp_pdr_complaint
, 0);
1862 e
->pdr
.pcreg
= RA_REGNUM
;
1863 e
->pdr
.regmask
= 0x80000000;
1864 e
->pdr
.regoffset
= -4;
1869 /* Relocate the extra function info pointed to by the symbol table. */
1872 ecoff_relocate_efi (sym
, delta
)
1876 struct mips_extra_func_info
*e
;
1878 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
1880 e
->pdr
.adr
+= delta
;
1883 /* Parse the external symbol ES. Just call parse_symbol() after
1884 making sure we know where the aux are for it.
1885 BIGEND says whether aux entries are big-endian or little-endian.
1887 This routine clobbers top_stack->cur_block and ->cur_st. */
1889 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
1892 parse_external (es
, bigend
, section_offsets
)
1895 struct section_offsets
*section_offsets
;
1899 if (es
->ifd
!= ifdNil
)
1902 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1903 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1907 cur_fdr
= debug_info
->fdr
;
1911 /* Reading .o files */
1912 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1915 switch (es
->asym
.st
)
1918 /* These are generated for static symbols in .o files,
1939 /* FIXME: Turn this into a complaint? */
1941 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1942 what
, debug_info
->ssext
+ es
->asym
.iss
,
1943 fdr_name (cur_fdr
));
1947 switch (es
->asym
.st
)
1951 /* There is no need to parse the external procedure symbols.
1952 If they are from objects compiled without -g, their index will
1953 be indexNil, and the symbol definition from the minimal symbol
1954 is preferrable (yielding a function returning int instead of int).
1955 If the index points to a local procedure symbol, the local
1956 symbol already provides the correct type.
1957 Note that the index of the external procedure symbol points
1958 to the local procedure symbol in the local symbol table, and
1959 _not_ to the auxiliary symbol info. */
1963 /* Global common symbols are resolved by the runtime loader,
1965 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
1968 /* Note that the case of a symbol with indexNil must be handled
1969 anyways by parse_symbol(). */
1970 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
1977 /* Parse the line number info for file descriptor FH into
1978 GDB's linetable LT. MIPS' encoding requires a little bit
1979 of magic to get things out. Note also that MIPS' line
1980 numbers can go back and forth, apparently we can live
1981 with that and do not need to reorder our linetables */
1983 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
1984 struct partial_symtab
*));
1987 parse_lines (fh
, pr
, lt
, maxlines
, pst
)
1990 struct linetable
*lt
;
1992 struct partial_symtab
*pst
;
1994 unsigned char *base
;
1996 int delta
, count
, lineno
= 0;
1997 unsigned long first_off
= pr
->adr
;
1999 if (fh
->cbLine
== 0)
2002 /* Scan by procedure descriptors */
2004 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2008 unsigned char *halt
;
2010 /* No code for this one */
2011 if (pr
->iline
== ilineNil
||
2012 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2015 /* Determine start and end address of compressed line bytes for
2017 base
= debug_info
->line
+ fh
->cbLineOffset
;
2018 if (j
!= (fh
->cpd
- 1))
2019 halt
= base
+ pr
[1].cbLineOffset
;
2021 halt
= base
+ fh
->cbLine
;
2022 base
+= pr
->cbLineOffset
;
2024 adr
= pst
->textlow
+ pr
->adr
- first_off
;
2026 l
= adr
>> 2; /* in words */
2027 for (lineno
= pr
->lnLow
; base
< halt
; )
2029 count
= *base
& 0x0f;
2030 delta
= *base
++ >> 4;
2035 delta
= (base
[0] << 8) | base
[1];
2036 if (delta
>= 0x8000)
2040 lineno
+= delta
; /* first delta is 0 */
2042 /* Complain if the line table overflows. Could happen
2043 with corrupt binaries. */
2044 if (lt
->nitems
>= maxlines
)
2046 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2049 k
= add_line (lt
, lineno
, l
, k
);
2055 /* Master parsing procedure for first-pass reading of file symbols
2056 into a partial_symtab. */
2059 parse_partial_symbols (objfile
, section_offsets
)
2060 struct objfile
*objfile
;
2061 struct section_offsets
*section_offsets
;
2063 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2064 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2065 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2066 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2067 = debug_swap
->swap_ext_in
;
2068 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2069 = debug_swap
->swap_sym_in
;
2070 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2071 = debug_swap
->swap_rfd_in
;
2073 HDRR
*hdr
= &debug_info
->symbolic_header
;
2074 /* Running pointers */
2079 register EXTR
*ext_in
;
2082 struct partial_symtab
*pst
;
2084 int past_first_source_file
= 0;
2086 /* List of current psymtab's include files */
2087 char **psymtab_include_list
;
2088 int includes_allocated
;
2091 struct pst_map
*fdr_to_pst
;
2092 /* Index within current psymtab dependency list */
2093 struct partial_symtab
**dependency_list
;
2094 int dependencies_used
, dependencies_allocated
;
2095 struct cleanup
*old_chain
;
2097 enum language prev_language
;
2098 asection
*text_sect
;
2099 int relocatable
= 0;
2101 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2102 the shared libraries are prelinked at a high memory address.
2103 We have to adjust the start address of the object file for this case,
2104 by setting it to the start address of the first procedure in the file.
2105 But we should do no adjustments if we are debugging a .o file, where
2106 the text section (and fh->adr) really starts at zero. */
2107 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2108 if (text_sect
!= NULL
2109 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2112 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2113 sizeof (EXTR
) * hdr
->iextMax
);
2115 includes_allocated
= 30;
2117 psymtab_include_list
= (char **) alloca (includes_allocated
*
2119 next_symbol_text_func
= mdebug_next_symbol_text
;
2121 dependencies_allocated
= 30;
2122 dependencies_used
= 0;
2124 (struct partial_symtab
**) alloca (dependencies_allocated
*
2125 sizeof (struct partial_symtab
*));
2127 last_source_file
= NULL
;
2132 * Only parse the Local and External symbols, and the Relative FDR.
2133 * Fixup enough of the loader symtab to be able to use it.
2134 * Allocate space only for the file's portions we need to
2139 max_glevel
= MIN_GLEVEL
;
2141 /* Allocate the map FDR -> PST.
2142 Minor hack: -O3 images might claim some global data belongs
2143 to FDR -1. We`ll go along with that */
2144 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2145 old_chain
= make_cleanup (free
, fdr_to_pst
);
2148 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2149 fdr_to_pst
[-1].pst
= pst
;
2153 /* Allocate the global pending list. */
2155 ((struct mdebug_pending
**)
2156 obstack_alloc (&objfile
->psymbol_obstack
,
2157 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2158 memset ((PTR
) pending_list
, 0,
2159 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2161 /* Pass 0 over external syms: swap them in. */
2162 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2163 make_cleanup (free
, ext_block
);
2165 ext_out
= (char *) debug_info
->external_ext
;
2166 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2168 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2169 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2171 /* Pass 1 over external syms: Presize and partition the list */
2173 ext_in_end
= ext_in
+ hdr
->iextMax
;
2174 for (; ext_in
< ext_in_end
; ext_in
++)
2176 /* See calls to complain below. */
2177 if (ext_in
->ifd
>= -1
2178 && ext_in
->ifd
< hdr
->ifdMax
2179 && ext_in
->asym
.iss
>= 0
2180 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2181 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2184 /* Pass 1.5 over files: partition out global symbol space */
2186 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2188 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2189 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2190 fdr_to_pst
[f_idx
].n_globals
= 0;
2193 /* Pass 2 over external syms: fill in external symbols */
2195 ext_in_end
= ext_in
+ hdr
->iextMax
;
2196 for (; ext_in
< ext_in_end
; ext_in
++)
2198 enum minimal_symbol_type ms_type
= mst_text
;
2199 CORE_ADDR svalue
= ext_in
->asym
.value
;
2201 /* The Irix 5 native tools seem to sometimes generate bogus
2202 external symbols. */
2203 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2205 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2208 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2210 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2215 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2216 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2218 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2221 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2222 switch (ext_in
->asym
.st
)
2225 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2228 ms_type
= mst_file_text
;
2229 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2232 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2234 /* The value of a common symbol is its size, not its address.
2238 else if (ext_in
->asym
.sc
== scData
2239 || ext_in
->asym
.sc
== scSData
2240 || ext_in
->asym
.sc
== scRData
2241 || ext_in
->asym
.sc
== scPData
2242 || ext_in
->asym
.sc
== scXData
)
2245 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2250 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2254 if (ext_in
->asym
.sc
== scAbs
)
2256 else if (ext_in
->asym
.sc
== scText
2257 || ext_in
->asym
.sc
== scInit
2258 || ext_in
->asym
.sc
== scFini
)
2260 ms_type
= mst_file_text
;
2261 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2263 else if (ext_in
->asym
.sc
== scData
2264 || ext_in
->asym
.sc
== scSData
2265 || ext_in
->asym
.sc
== scRData
2266 || ext_in
->asym
.sc
== scPData
2267 || ext_in
->asym
.sc
== scXData
)
2269 ms_type
= mst_file_data
;
2270 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2274 ms_type
= mst_file_bss
;
2275 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2279 /* The alpha has the section start addresses in stLocal symbols
2280 whose name starts with a `.'. Skip those but complain for all
2281 other stLocal symbols. */
2286 ms_type
= mst_unknown
;
2287 complain (&unknown_ext_complaint
, name
);
2289 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2292 /* Pass 3 over files, over local syms: fill in static symbols */
2293 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2295 struct partial_symtab
*save_pst
;
2299 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2303 fdr_to_pst
[f_idx
].pst
= NULL
;
2307 /* Determine the start address for this object file from the
2308 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2312 if (relocatable
|| textlow
!= 0)
2313 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2317 pst
= start_psymtab_common (objfile
, section_offsets
,
2320 objfile
->global_psymbols
.next
,
2321 objfile
->static_psymbols
.next
);
2322 pst
->read_symtab_private
= ((char *)
2323 obstack_alloc (&objfile
->psymbol_obstack
,
2324 sizeof (struct symloc
)));
2325 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2328 FDR_IDX (pst
) = f_idx
;
2329 CUR_BFD (pst
) = cur_bfd
;
2330 DEBUG_SWAP (pst
) = debug_swap
;
2331 DEBUG_INFO (pst
) = debug_info
;
2332 PENDING_LIST (pst
) = pending_list
;
2334 /* The way to turn this into a symtab is to call... */
2335 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2337 /* Set up language for the pst.
2338 The language from the FDR is used if it is unambigious (e.g. cfront
2339 with native cc and g++ will set the language to C).
2340 Otherwise we have to deduce the language from the filename.
2341 Native ecoff has every header file in a separate FDR, so
2342 deduce_language_from_filename will return language_unknown for
2343 a header file, which is not what we want.
2344 But the FDRs for the header files are after the FDR for the source
2345 file, so we can assign the language of the source file to the
2346 following header files. Then we save the language in the private
2347 pst data so that we can reuse it when building symtabs. */
2348 prev_language
= psymtab_language
;
2352 case langCplusplusV2
:
2353 psymtab_language
= language_cplus
;
2356 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2359 if (psymtab_language
== language_unknown
)
2360 psymtab_language
= prev_language
;
2361 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2363 pst
->texthigh
= pst
->textlow
;
2365 /* For stabs-in-ecoff files, the second symbol must be @stab.
2366 This symbol is emitted by mips-tfile to signal that the
2367 current object file uses encapsulated stabs instead of mips
2368 ecoff for local symbols. (It is the second symbol because
2369 the first symbol is the stFile used to signal the start of a
2371 processing_gcc_compilation
= 0;
2374 (*swap_sym_in
) (cur_bfd
,
2375 ((char *) debug_info
->external_sym
2376 + (fh
->isymBase
+ 1) * external_sym_size
),
2378 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2379 processing_gcc_compilation
= 2;
2382 if (processing_gcc_compilation
!= 0)
2384 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2389 (*swap_sym_in
) (cur_bfd
,
2390 (((char *) debug_info
->external_sym
)
2391 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2393 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2394 if (!ECOFF_IS_STAB (&sh
))
2396 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2401 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2402 if (sh
.st
== stStaticProc
)
2404 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2405 prim_record_minimal_symbol_and_info (namestring
,
2412 procaddr
= sh
.value
;
2414 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2415 (debug_info
->external_aux
2418 (*swap_sym_in
) (cur_bfd
,
2419 ((char *) debug_info
->external_sym
2420 + ((fh
->isymBase
+ isym
- 1)
2421 * external_sym_size
)),
2425 long high
= procaddr
+ sh
.value
;
2427 /* Kludge for Irix 5.2 zero fh->adr. */
2429 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2430 pst
->textlow
= procaddr
;
2431 if (high
> pst
->texthigh
)
2432 pst
->texthigh
= high
;
2435 else if (sh
.st
== stStatic
)
2449 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2450 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2451 prim_record_minimal_symbol_and_info (namestring
,
2460 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2461 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2462 prim_record_minimal_symbol_and_info (namestring
,
2473 #define SET_NAMESTRING() \
2474 namestring = debug_info->ss + fh->issBase + sh.iss
2475 #define CUR_SYMBOL_TYPE type_code
2476 #define CUR_SYMBOL_VALUE sh.value
2477 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2479 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2480 #define HANDLE_RBRAC(val) \
2481 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2482 #include "partial-stab.h"
2487 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2490 enum address_class
class;
2492 (*swap_sym_in
) (cur_bfd
,
2493 ((char *) debug_info
->external_sym
2494 + ((fh
->isymBase
+ cur_sdx
)
2495 * external_sym_size
)),
2498 if (ECOFF_IS_STAB (&sh
))
2504 /* Non absolute static symbols go into the minimal table. */
2505 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2506 || (sh
.index
== indexNil
2507 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2509 /* FIXME, premature? */
2514 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2519 /* The value of a stEnd symbol is the displacement from the
2520 corresponding start symbol value, do not relocate it. */
2522 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2529 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2533 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2544 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2545 mst_file_text
, NULL
,
2546 SECT_OFF_TEXT
, objfile
);
2551 /* Usually there is a local and a global stProc symbol
2552 for a function. This means that the function name
2553 has already been entered into the mimimal symbol table
2554 while processing the global symbols in pass 2 above.
2555 One notable exception is the PROGRAM name from
2556 f77 compiled executables, it is only put out as
2557 local stProc symbol, and a global MAIN__ stProc symbol
2558 points to it. It doesn't matter though, as gdb is
2559 still able to find the PROGRAM name via the partial
2560 symbol table, and the MAIN__ symbol via the minimal
2562 if (sh
.st
== stProc
)
2563 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2564 VAR_NAMESPACE
, LOC_BLOCK
,
2565 objfile
->global_psymbols
,
2566 sh
.value
, psymtab_language
, objfile
);
2568 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2569 VAR_NAMESPACE
, LOC_BLOCK
,
2570 objfile
->static_psymbols
,
2571 sh
.value
, psymtab_language
, objfile
);
2573 /* Skip over procedure to next one. */
2574 if (sh
.index
>= hdr
->iauxMax
)
2576 /* Should not happen, but does when cross-compiling
2577 with the MIPS compiler. FIXME -- pull later. */
2578 complain (&index_complaint
, name
);
2579 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2582 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2583 (debug_info
->external_aux
2586 procaddr
= sh
.value
;
2588 if (new_sdx
<= cur_sdx
)
2590 /* This should not happen either... FIXME. */
2591 complain (&aux_index_complaint
, name
);
2592 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2596 (*swap_sym_in
) (cur_bfd
,
2597 ((char *) debug_info
->external_sym
2598 + ((fh
->isymBase
+ cur_sdx
- 1)
2599 * external_sym_size
)),
2604 /* Kludge for Irix 5.2 zero fh->adr. */
2606 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2607 pst
->textlow
= procaddr
;
2609 high
= procaddr
+ sh
.value
;
2610 if (high
> pst
->texthigh
)
2611 pst
->texthigh
= high
;
2614 case stStatic
: /* Variable */
2619 || sh
.sc
== scXData
)
2620 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2621 mst_file_data
, NULL
,
2625 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2632 case stIndirect
:/* Irix5 forward declaration */
2633 /* Skip forward declarations from Irix5 cc */
2636 case stTypedef
:/* Typedef */
2637 /* Skip typedefs for forward declarations and opaque
2638 structs from alpha and mips cc. */
2639 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2641 class = LOC_TYPEDEF
;
2644 case stConstant
: /* Constant decl */
2651 case stBlock
: /* { }, str, un, enum*/
2652 /* Do not create a partial symbol for cc unnamed aggregates
2653 and gcc empty aggregates. */
2654 if ((sh
.sc
== scInfo
2655 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2657 && sh
.index
!= cur_sdx
+ 2)
2659 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2660 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2661 objfile
->static_psymbols
,
2663 psymtab_language
, objfile
);
2665 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2667 /* Skip over the block */
2669 if (new_sdx
<= cur_sdx
)
2671 /* This happens with the Ultrix kernel. */
2672 complain (&block_index_complaint
, name
);
2673 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2678 case stFile
: /* File headers */
2679 case stLabel
: /* Labels */
2680 case stEnd
: /* Ends of files */
2683 case stLocal
: /* Local variables */
2684 /* Normally these are skipped because we skip over
2685 all blocks we see. However, these can occur
2686 as visible symbols in a .h file that contains code. */
2690 /* Both complaints are valid: one gives symbol name,
2691 the other the offending symbol type. */
2692 complain (&unknown_sym_complaint
, name
);
2693 complain (&unknown_st_complaint
, sh
.st
);
2697 /* Use this gdb symbol */
2698 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2699 VAR_NAMESPACE
, class,
2700 objfile
->static_psymbols
, sh
.value
,
2701 psymtab_language
, objfile
);
2703 cur_sdx
++; /* Go to next file symbol */
2706 /* Now do enter the external symbols. */
2707 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2708 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2709 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2710 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2711 for (; --cur_sdx
>= 0; ext_ptr
++)
2713 enum address_class
class;
2718 if (ext_ptr
->ifd
!= f_idx
)
2720 psh
= &ext_ptr
->asym
;
2722 /* Do not add undefined symbols to the partial symbol table. */
2723 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2726 svalue
= psh
->value
;
2730 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2737 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2741 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2748 /* These are generated for static symbols in .o files,
2753 /* External procedure symbols have been entered
2754 into the minimal symbol table in pass 2 above.
2755 Ignore them, as parse_external will ignore them too. */
2761 complain (&unknown_ext_complaint
,
2762 debug_info
->ssext
+ psh
->iss
);
2763 /* Fall through, pretend it's global. */
2765 /* Global common symbols are resolved by the runtime loader,
2767 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2773 name
= debug_info
->ssext
+ psh
->iss
;
2774 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2775 VAR_NAMESPACE
, class,
2776 objfile
->global_psymbols
,
2778 psymtab_language
, objfile
);
2782 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2783 empty and put on the free list. */
2784 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2785 psymtab_include_list
, includes_used
,
2786 -1, save_pst
->texthigh
,
2787 dependency_list
, dependencies_used
);
2788 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2789 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2791 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2792 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2795 /* The objfile has its functions reordered if this partial symbol
2796 table overlaps any other partial symbol table.
2797 We cannot assume a reordered objfile if a partial symbol table
2798 is contained within another partial symbol table, as partial symbol
2799 tables for include files with executable code are contained
2800 within the partial symbol table for the including source file,
2801 and we do not want to flag the objfile reordered for these cases.
2803 This strategy works well for Irix-5.2 shared libraries, but we
2804 might have to use a more elaborate (and slower) algorithm for
2806 save_pst
= fdr_to_pst
[f_idx
].pst
;
2807 if (save_pst
!= NULL
2808 && save_pst
->textlow
!= 0
2809 && !(objfile
->flags
& OBJF_REORDERED
))
2811 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
2814 && save_pst
->textlow
>= pst
->textlow
2815 && save_pst
->textlow
< pst
->texthigh
2816 && save_pst
->texthigh
> pst
->texthigh
)
2818 objfile
->flags
|= OBJF_REORDERED
;
2825 /* Now scan the FDRs for dependencies */
2826 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2828 fh
= f_idx
+ debug_info
->fdr
;
2829 pst
= fdr_to_pst
[f_idx
].pst
;
2831 if (pst
== (struct partial_symtab
*)NULL
)
2834 /* This should catch stabs-in-ecoff. */
2838 /* Skip the first file indirect entry as it is a self dependency
2839 for source files or a reverse .h -> .c dependency for header files. */
2840 pst
->number_of_dependencies
= 0;
2842 ((struct partial_symtab
**)
2843 obstack_alloc (&objfile
->psymbol_obstack
,
2845 * sizeof (struct partial_symtab
*))));
2846 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2850 (*swap_rfd_in
) (cur_bfd
,
2851 ((char *) debug_info
->external_rfd
2852 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2854 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2856 complain (&bad_file_number_complaint
, rh
);
2860 /* Skip self dependencies of header files. */
2864 /* Do not add to dependeny list if psymtab was empty. */
2865 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2867 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2871 /* Remove the dummy psymtab created for -O3 images above, if it is
2872 still empty, to enable the detection of stripped executables. */
2873 if (objfile
->psymtabs
->next
== NULL
2874 && objfile
->psymtabs
->number_of_dependencies
== 0
2875 && objfile
->psymtabs
->n_global_syms
== 0
2876 && objfile
->psymtabs
->n_static_syms
== 0)
2877 objfile
->psymtabs
= NULL
;
2878 do_cleanups (old_chain
);
2881 /* If the current psymbol has an enumerated type, we need to add
2882 all the the enum constants to the partial symbol table. */
2885 handle_psymbol_enumerators (objfile
, fh
, stype
)
2886 struct objfile
*objfile
;
2890 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2891 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2892 = debug_swap
->swap_sym_in
;
2893 char *ext_sym
= ((char *) debug_info
->external_sym
2894 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2904 /* It is an enumerated type if the next symbol entry is a stMember
2905 and its auxiliary index is indexNil or its auxiliary entry
2906 is a plain btNil or btVoid. */
2907 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2908 if (sh
.st
!= stMember
)
2911 if (sh
.index
== indexNil
)
2913 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
2914 &(debug_info
->external_aux
2915 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2917 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2929 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2930 if (sh
.st
!= stMember
)
2932 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2934 /* Note that the value doesn't matter for enum constants
2935 in psymtabs, just in symtabs. */
2936 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2937 VAR_NAMESPACE
, LOC_CONST
,
2938 objfile
->static_psymbols
, 0,
2939 psymtab_language
, objfile
);
2940 ext_sym
+= external_sym_size
;
2945 mdebug_next_symbol_text ()
2950 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2951 ((char *) debug_info
->external_sym
2952 + ((cur_fdr
->isymBase
+ cur_sdx
)
2953 * debug_swap
->external_sym_size
)),
2955 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2958 /* Ancillary function to psymtab_to_symtab(). Does all the work
2959 for turning the partial symtab PST into a symtab, recurring
2960 first on all dependent psymtabs. The argument FILENAME is
2961 only passed so we can see in debug stack traces what file
2964 This function has a split personality, based on whether the
2965 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2966 The flow of control and even the memory allocation differs. FIXME. */
2969 psymtab_to_symtab_1 (pst
, filename
)
2970 struct partial_symtab
*pst
;
2973 bfd_size_type external_sym_size
;
2974 bfd_size_type external_pdr_size
;
2975 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2976 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
2980 struct linetable
*lines
;
2986 /* Read in all partial symbtabs on which this one is dependent.
2987 NOTE that we do have circular dependencies, sigh. We solved
2988 that by setting pst->readin before this point. */
2990 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2991 if (!pst
->dependencies
[i
]->readin
)
2993 /* Inform about additional files to be read in. */
2996 fputs_filtered (" ", gdb_stdout
);
2998 fputs_filtered ("and ", gdb_stdout
);
3000 printf_filtered ("%s...",
3001 pst
->dependencies
[i
]->filename
);
3002 wrap_here (""); /* Flush output */
3003 gdb_flush (gdb_stdout
);
3005 /* We only pass the filename for debug purposes */
3006 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3007 pst
->dependencies
[i
]->filename
);
3010 /* Do nothing if this is a dummy psymtab. */
3012 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3013 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3016 /* Now read the symbols for this symtab */
3018 cur_bfd
= CUR_BFD (pst
);
3019 debug_swap
= DEBUG_SWAP (pst
);
3020 debug_info
= DEBUG_INFO (pst
);
3021 pending_list
= PENDING_LIST (pst
);
3022 external_sym_size
= debug_swap
->external_sym_size
;
3023 external_pdr_size
= debug_swap
->external_pdr_size
;
3024 swap_sym_in
= debug_swap
->swap_sym_in
;
3025 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3026 current_objfile
= pst
->objfile
;
3027 cur_fd
= FDR_IDX (pst
);
3028 fh
= ((cur_fd
== -1)
3030 : debug_info
->fdr
+ cur_fd
);
3033 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3034 processing_gcc_compilation
= 0;
3035 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3039 (*swap_sym_in
) (cur_bfd
,
3040 ((char *) debug_info
->external_sym
3041 + (fh
->isymBase
+ 1) * external_sym_size
),
3043 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3046 /* We indicate that this is a GCC compilation so that certain
3047 features will be enabled in stabsread/dbxread. */
3048 processing_gcc_compilation
= 2;
3052 if (processing_gcc_compilation
!= 0)
3057 unsigned long first_off
= 0;
3059 /* This symbol table contains stabs-in-ecoff entries. */
3061 /* Parse local symbols first */
3063 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3065 current_objfile
= NULL
;
3068 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3074 (*swap_sym_in
) (cur_bfd
,
3075 (((char *) debug_info
->external_sym
)
3076 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3078 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3080 if (ECOFF_IS_STAB (&sh
))
3082 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3084 /* We should never get non N_STAB symbols here, but they
3085 should be harmless, so keep process_one_symbol from
3086 complaining about them. */
3087 if (type_code
& N_STAB
)
3089 process_one_symbol (type_code
, 0, valu
, name
,
3090 pst
->section_offsets
, pst
->objfile
);
3092 if (type_code
== N_FUN
)
3094 /* Make up special symbol to contain
3095 procedure specific info */
3096 struct mips_extra_func_info
*e
=
3097 ((struct mips_extra_func_info
*)
3098 obstack_alloc (¤t_objfile
->symbol_obstack
,
3099 sizeof (struct mips_extra_func_info
)));
3100 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3101 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3102 SYMBOL_CLASS (s
) = LOC_CONST
;
3103 SYMBOL_TYPE (s
) = builtin_type_void
;
3104 SYMBOL_VALUE (s
) = (long) e
;
3105 add_symbol_to_list (s
, &local_symbols
);
3108 else if (sh
.st
== stLabel
)
3110 if (sh
.index
== indexNil
)
3112 /* This is what the gcc2_compiled and __gnu_compiled_*
3113 show up as. So don't complain. */
3117 /* Handle encoded stab line number. */
3118 record_line (current_subfile
, sh
.index
, valu
);
3120 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3121 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3122 /* These are generated by gcc-2.x, do not complain */
3125 complain (&stab_unknown_complaint
, name
);
3127 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
3130 /* Sort the symbol table now, we are done adding symbols to it.
3131 We must do this before parse_procedure calls lookup_symbol. */
3132 sort_symtab_syms (st
);
3134 /* There used to be a call to sort_blocks here, but this should not
3135 be necessary for stabs symtabs. And as sort_blocks modifies the
3136 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3137 it did the wrong thing if the first procedure in a file was
3138 generated via asm statements. */
3140 /* Fill in procedure info next. */
3142 pdr_ptr
= ((char *) debug_info
->external_pdr
3143 + fh
->ipdFirst
* external_pdr_size
);
3144 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3145 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
3149 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
3155 parse_procedure (&pr
, st
, first_off
, pst
);
3160 /* This symbol table contains ordinary ecoff entries. */
3162 /* FIXME: doesn't use pst->section_offsets. */
3168 /* How many symbols will we need */
3169 /* FIXME, this does not count enum values. */
3170 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
3174 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
3178 f_max
+= fh
->csym
+ fh
->cpd
;
3179 maxlines
= 2 * fh
->cline
;
3180 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
3182 /* The proper language was already determined when building
3183 the psymtab, use it. */
3184 st
->language
= PST_PRIVATE (pst
)->pst_language
;
3187 psymtab_language
= st
->language
;
3189 lines
= LINETABLE (st
);
3191 /* Get a new lexical context */
3193 push_parse_stack ();
3194 top_stack
->cur_st
= st
;
3195 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
3197 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
3198 BLOCK_END (top_stack
->cur_block
) = 0;
3199 top_stack
->blocktype
= stFile
;
3200 top_stack
->maxsyms
= 2 * f_max
;
3201 top_stack
->cur_type
= 0;
3202 top_stack
->procadr
= 0;
3203 top_stack
->numargs
= 0;
3210 /* Parse local symbols first */
3211 sym_ptr
= ((char *) debug_info
->external_sym
3212 + fh
->isymBase
* external_sym_size
);
3213 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
3214 while (sym_ptr
< sym_end
)
3219 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
3220 c
= parse_symbol (&sh
,
3221 debug_info
->external_aux
+ fh
->iauxBase
,
3222 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3223 sym_ptr
+= c
* external_sym_size
;
3226 /* Linenumbers. At the end, check if we can save memory.
3227 parse_lines has to look ahead an arbitrary number of PDR
3228 structures, so we swap them all first. */
3232 struct cleanup
*old_chain
;
3238 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3240 old_chain
= make_cleanup (free
, pr_block
);
3242 pdr_ptr
= ((char *) debug_info
->external_pdr
3243 + fh
->ipdFirst
* external_pdr_size
);
3244 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3248 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3249 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3251 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
);
3252 if (lines
->nitems
< fh
->cline
)
3253 lines
= shrink_linetable (lines
);
3255 /* Fill in procedure info next. */
3257 pdr_in_end
= pdr_in
+ fh
->cpd
;
3258 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3259 parse_procedure (pdr_in
, 0, pr_block
->adr
, pst
);
3261 do_cleanups (old_chain
);
3265 LINETABLE (st
) = lines
;
3267 /* .. and our share of externals.
3268 XXX use the global list to speed up things here. how?
3269 FIXME, Maybe quit once we have found the right number of ext's? */
3270 top_stack
->cur_st
= st
;
3271 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3273 top_stack
->blocktype
= stFile
;
3275 = (debug_info
->symbolic_header
.isymMax
3276 + debug_info
->symbolic_header
.ipdMax
3277 + debug_info
->symbolic_header
.iextMax
);
3279 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3280 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3281 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3283 /* If there are undefined symbols, tell the user.
3284 The alpha has an undefined symbol for every symbol that is
3285 from a shared library, so tell the user only if verbose is on. */
3286 if (info_verbose
&& n_undef_symbols
)
3288 printf_filtered ("File %s contains %d unresolved references:",
3289 st
->filename
, n_undef_symbols
);
3290 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3291 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3292 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3299 /* Sort the symbol table now, we are done adding symbols to it.*/
3300 sort_symtab_syms (st
);
3305 /* Now link the psymtab and the symtab. */
3308 current_objfile
= NULL
;
3311 /* Ancillary parsing procedures. */
3313 /* Return 1 if the symbol pointed to by SH has a cross reference
3314 to an opaque aggregate type, else 0. */
3317 has_opaque_xref (fh
, sh
)
3326 if (sh
->index
== indexNil
)
3329 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
3330 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
3331 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
3335 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
3336 if (rn
->rfd
== 0xfff)
3337 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
3345 /* Lookup the type at relative index RN. Return it in TPP
3346 if found and in any event come up with its name PNAME.
3347 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3348 Return value says how many aux symbols we ate. */
3351 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3355 enum type_code type_code
; /* Use to alloc new type if none is found. */
3367 struct mdebug_pending
*pend
;
3369 *tpp
= (struct type
*)NULL
;
3371 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
3373 /* Escape index means 'the next one' */
3374 if (rn
->rfd
== 0xfff)
3377 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3384 /* mips cc uses a rf of -1 for opaque struct definitions.
3385 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3386 resolve them if the struct gets defined in another compilation unit. */
3389 *pname
= "<undefined>";
3390 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3391 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3395 /* mips cc uses an escaped rn->index of 0 for struct return types
3396 of procedures that were compiled without -g. These will always remain
3398 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3400 *pname
= "<undefined>";
3404 /* Find the relative file descriptor and the symbol in it. */
3405 fh
= get_rfd (fd
, rf
);
3406 xref_fd
= fh
- debug_info
->fdr
;
3408 if (rn
->index
>= fh
->csym
)
3410 /* File indirect entry is corrupt. */
3411 *pname
= "<illegal>";
3412 complain (&bad_rfd_entry_complaint
,
3413 sym_name
, xref_fd
, rn
->index
);
3417 /* If we have processed this symbol then we left a forwarding
3418 pointer to the type in the pending list. If not, we`ll put
3419 it in a list of pending types, to be processed later when
3420 the file will be. In any event, we collect the name for the
3423 esh
= ((char *) debug_info
->external_sym
3424 + ((fh
->isymBase
+ rn
->index
)
3425 * debug_swap
->external_sym_size
));
3426 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3428 /* Make sure that this type of cross reference can be handled. */
3429 if ((sh
.sc
!= scInfo
3430 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
3431 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3432 && sh
.st
!= stEnum
))
3433 && (sh
.st
!= stBlock
|| (sh
.sc
!= scCommon
&& sh
.sc
!= scSCommon
)))
3435 /* File indirect entry is corrupt. */
3436 *pname
= "<illegal>";
3437 complain (&bad_rfd_entry_complaint
,
3438 sym_name
, xref_fd
, rn
->index
);
3442 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3444 pend
= is_pending_symbol (fh
, esh
);
3449 /* We have not yet seen this type. */
3451 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
3455 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3457 a) forward declarations of structs/unions/enums which are not
3458 defined in this compilation unit.
3459 For these the type will be void. This is a bad design decision
3460 as cross referencing across compilation units is impossible
3461 due to the missing name.
3462 b) forward declarations of structs/unions/enums which are defined
3463 later in this file or in another file in the same compilation
3464 unit. Irix5 cc uses a stIndirect symbol for this.
3465 Simply cross reference those again to get the true type.
3466 The forward references are not entered in the pending list and
3467 in the symbol table. */
3469 (*debug_swap
->swap_tir_in
) (bigend
,
3470 &(debug_info
->external_aux
3471 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3473 if (tir
.tq0
!= tqNil
)
3474 complain (&illegal_forward_tq0_complaint
, sym_name
);
3478 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3480 *pname
= "<undefined>";
3487 (debug_info
->external_aux
3488 + fh
->iauxBase
+ sh
.index
+ 1),
3489 tpp
, type_code
, pname
,
3490 fh
->fBigendian
, sym_name
);
3494 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3495 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3501 else if (sh
.st
== stTypedef
)
3503 /* Parse the type for a normal typedef. This might recursively call
3504 cross_ref till we get a non typedef'ed type.
3505 FIXME: This is not correct behaviour, but gdb currently
3506 cannot handle typedefs without type copying. But type copying is
3507 impossible as we might have mutual forward references between
3508 two files and the copied type would not get filled in when
3509 we later parse its definition. */
3510 *tpp
= parse_type (xref_fd
,
3511 debug_info
->external_aux
+ fh
->iauxBase
,
3515 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3519 /* Cross reference to a struct/union/enum which is defined
3520 in another file in the same compilation unit but that file
3521 has not been parsed yet.
3522 Initialize the type only, it will be filled in when
3523 it's definition is parsed. */
3524 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3526 add_pending (fh
, esh
, *tpp
);
3529 /* We used one auxent normally, two if we got a "next one" rf. */
3534 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3535 keeping the symtab sorted */
3537 static struct symbol
*
3538 mylookup_symbol (name
, block
, namespace, class)
3540 register struct block
*block
;
3541 enum namespace namespace;
3542 enum address_class
class;
3544 register int bot
, top
, inc
;
3545 register struct symbol
*sym
;
3548 top
= BLOCK_NSYMS (block
);
3552 sym
= BLOCK_SYM (block
, bot
);
3553 if (SYMBOL_NAME (sym
)[0] == inc
3554 && SYMBOL_NAMESPACE (sym
) == namespace
3555 && SYMBOL_CLASS (sym
) == class
3556 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3560 block
= BLOCK_SUPERBLOCK (block
);
3562 return mylookup_symbol (name
, block
, namespace, class);
3567 /* Add a new symbol S to a block B.
3568 Infrequently, we will need to reallocate the block to make it bigger.
3569 We only detect this case when adding to top_stack->cur_block, since
3570 that's the only time we know how big the block is. FIXME. */
3577 int nsyms
= BLOCK_NSYMS (b
)++;
3578 struct block
*origb
;
3579 struct parse_stack
*stackp
;
3581 if (b
== top_stack
->cur_block
&&
3582 nsyms
>= top_stack
->maxsyms
)
3584 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3585 /* In this case shrink_block is actually grow_block, since
3586 BLOCK_NSYMS(b) is larger than its current size. */
3588 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3590 /* Now run through the stack replacing pointers to the
3591 original block. shrink_block has already done this
3592 for the blockvector and BLOCK_FUNCTION. */
3593 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3595 if (stackp
->cur_block
== origb
)
3597 stackp
->cur_block
= b
;
3598 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3602 BLOCK_SYM (b
, nsyms
) = s
;
3605 /* Add a new block B to a symtab S */
3612 struct blockvector
*bv
= BLOCKVECTOR (s
);
3614 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3615 (sizeof (struct blockvector
)
3616 + BLOCKVECTOR_NBLOCKS (bv
)
3617 * sizeof (bv
->block
)));
3618 if (bv
!= BLOCKVECTOR (s
))
3619 BLOCKVECTOR (s
) = bv
;
3621 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3624 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3625 MIPS' linenumber encoding might need more than one byte
3626 to describe it, LAST is used to detect these continuation lines.
3628 Combining lines with the same line number seems like a bad idea.
3629 E.g: There could be a line number entry with the same line number after the
3630 prologue and GDB should not ignore it (this is a better way to find
3631 a prologue than mips_skip_prologue).
3632 But due to the compressed line table format there are line number entries
3633 for the same line which are needed to bridge the gap to the next
3634 line number entry. These entries have a bogus address info with them
3635 and we are unable to tell them from intended duplicate line number
3637 This is another reason why -ggdb debugging format is preferable. */
3640 add_line (lt
, lineno
, adr
, last
)
3641 struct linetable
*lt
;
3646 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3647 Change them to something sensible. */
3651 last
= -2; /* make sure we record first line */
3653 if (last
== lineno
) /* skip continuation lines */
3656 lt
->item
[lt
->nitems
].line
= lineno
;
3657 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3661 /* Sorting and reordering procedures */
3663 /* Blocks with a smaller low bound should come first */
3666 compare_blocks (arg1
, arg2
)
3670 register int addr_diff
;
3671 struct block
**b1
= (struct block
**) arg1
;
3672 struct block
**b2
= (struct block
**) arg2
;
3674 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3676 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3680 /* Sort the blocks of a symtab S.
3681 Reorder the blocks in the blockvector by code-address,
3682 as required by some MI search routines */
3688 struct blockvector
*bv
= BLOCKVECTOR (s
);
3690 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3693 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3694 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3695 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3696 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3700 * This is very unfortunate: normally all functions are compiled in
3701 * the order they are found, but if the file is compiled -O3 things
3702 * are very different. It would be nice to find a reliable test
3703 * to detect -O3 images in advance.
3705 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3706 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3707 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3708 sizeof (struct block
*),
3712 register CORE_ADDR high
= 0;
3713 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3715 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3716 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3717 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3718 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3721 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3722 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3724 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3725 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3726 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3727 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3731 /* Constructor/restructor/destructor procedures */
3733 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3734 MAXSYMS and linenumbers MAXLINES we'll put in it */
3736 static struct symtab
*
3737 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3741 struct objfile
*objfile
;
3743 struct symtab
*s
= allocate_symtab (name
, objfile
);
3745 LINETABLE (s
) = new_linetable (maxlines
);
3747 /* All symtabs must have at least two blocks */
3748 BLOCKVECTOR (s
) = new_bvect (2);
3749 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3750 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3751 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3752 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3754 s
->free_code
= free_linetable
;
3759 /* Allocate a new partial_symtab NAME */
3761 static struct partial_symtab
*
3762 new_psymtab (name
, objfile
, section_offsets
)
3764 struct objfile
*objfile
;
3765 struct section_offsets
*section_offsets
;
3767 struct partial_symtab
*psymtab
;
3769 psymtab
= allocate_psymtab (name
, objfile
);
3770 psymtab
->section_offsets
= section_offsets
;
3772 /* Keep a backpointer to the file's symbols */
3774 psymtab
->read_symtab_private
= ((char *)
3775 obstack_alloc (&objfile
->psymbol_obstack
,
3776 sizeof (struct symloc
)));
3777 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3778 CUR_BFD (psymtab
) = cur_bfd
;
3779 DEBUG_SWAP (psymtab
) = debug_swap
;
3780 DEBUG_INFO (psymtab
) = debug_info
;
3781 PENDING_LIST (psymtab
) = pending_list
;
3783 /* The way to turn this into a symtab is to call... */
3784 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3789 /* Allocate a linetable array of the given SIZE. Since the struct
3790 already includes one item, we subtract one when calculating the
3791 proper size to allocate. */
3793 static struct linetable
*
3794 new_linetable (size
)
3797 struct linetable
*l
;
3799 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3800 l
= (struct linetable
*) xmalloc (size
);
3805 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3806 I am not so sure about the 3.4 ones.
3808 Since the struct linetable already includes one item, we subtract one when
3809 calculating the proper size to allocate. */
3811 static struct linetable
*
3812 shrink_linetable (lt
)
3813 struct linetable
*lt
;
3816 return (struct linetable
*) xrealloc ((PTR
) lt
,
3817 (sizeof (struct linetable
)
3819 * sizeof (lt
->item
))));
3822 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3824 static struct blockvector
*
3828 struct blockvector
*bv
;
3831 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3832 bv
= (struct blockvector
*) xzalloc (size
);
3834 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3839 /* Allocate and zero a new block of MAXSYMS symbols */
3841 static struct block
*
3845 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3847 return (struct block
*) xzalloc (size
);
3850 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3851 Shrink_block can also be used by add_symbol to grow a block. */
3853 static struct block
*
3859 struct blockvector
*bv
= BLOCKVECTOR (s
);
3862 /* Just reallocate it and fix references to the old one */
3864 new = (struct block
*) xrealloc ((PTR
) b
,
3865 (sizeof (struct block
)
3866 + ((BLOCK_NSYMS (b
) - 1)
3867 * sizeof (struct symbol
*))));
3869 /* Should chase pointers to old one. Fortunately, that`s just
3870 the block`s function and inferior blocks */
3871 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3872 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3873 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3874 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3875 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3876 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3877 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3881 /* Create a new symbol with printname NAME */
3883 static struct symbol
*
3887 struct symbol
*s
= ((struct symbol
*)
3888 obstack_alloc (¤t_objfile
->symbol_obstack
,
3889 sizeof (struct symbol
)));
3891 memset ((PTR
) s
, 0, sizeof (*s
));
3892 SYMBOL_NAME (s
) = name
;
3893 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3894 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3898 /* Create a new type with printname NAME */
3900 static struct type
*
3906 t
= alloc_type (current_objfile
);
3907 TYPE_NAME (t
) = name
;
3908 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3912 /* Read ECOFF debugging information from a BFD section. This is
3913 called from elfread.c. It parses the section into a
3914 ecoff_debug_info struct, and then lets the rest of the file handle
3918 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3919 struct objfile
*objfile
;
3920 const struct ecoff_debug_swap
*swap
;
3922 struct section_offsets
*section_offsets
;
3924 bfd
*abfd
= objfile
->obfd
;
3925 struct ecoff_debug_info
*info
;
3927 info
= ((struct ecoff_debug_info
*)
3928 obstack_alloc (&objfile
->psymbol_obstack
,
3929 sizeof (struct ecoff_debug_info
)));
3931 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
3932 error ("Error reading ECOFF debugging information: %s",
3933 bfd_errmsg (bfd_get_error ()));
3935 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3939 /* Things used for calling functions in the inferior.
3940 These functions are exported to our companion
3941 mips-tdep.c file and are here because they play
3942 with the symbol-table explicitly. */
3944 /* Sigtramp: make sure we have all the necessary information
3945 about the signal trampoline code. Since the official code
3946 from MIPS does not do so, we make up that information ourselves.
3947 If they fix the library (unlikely) this code will neutralize itself. */
3949 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3950 here because it calls functions defined in this file, but perhaps
3951 this could be handled in a better way. */
3958 struct block
*b
, *b0
= NULL
;
3960 sigtramp_address
= -1;
3962 /* We have to handle the following cases here:
3963 a) The Mips library has a sigtramp label within sigvec.
3964 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3965 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3968 b0
= SYMBOL_BLOCK_VALUE (s
);
3969 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3973 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3974 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3977 /* But maybe this program uses its own version of sigvec */
3981 /* Did we or MIPSco fix the library ? */
3982 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3984 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3985 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3989 sigtramp_address
= SYMBOL_VALUE (s
);
3990 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3992 /* But what symtab does it live in ? */
3993 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3996 * Ok, there goes the fix: turn it into a procedure, with all the
3997 * needed info. Note we make it a nested procedure of sigvec,
3998 * which is the way the (assembly) code is actually written.
4000 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4001 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4002 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4004 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
4006 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4008 SYMBOL_BLOCK_VALUE (s
) = b
;
4009 BLOCK_START (b
) = sigtramp_address
;
4010 BLOCK_END (b
) = sigtramp_end
;
4011 BLOCK_FUNCTION (b
) = s
;
4012 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4016 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4018 struct mips_extra_func_info
*e
=
4019 ((struct mips_extra_func_info
*)
4020 xzalloc (sizeof (struct mips_extra_func_info
)));
4022 e
->numargs
= 0; /* the kernel thinks otherwise */
4023 e
->pdr
.frameoffset
= 32;
4024 e
->pdr
.framereg
= SP_REGNUM
;
4025 /* Note that setting pcreg is no longer strictly necessary as
4026 mips_frame_saved_pc is now aware of signal handler frames. */
4027 e
->pdr
.pcreg
= PC_REGNUM
;
4028 e
->pdr
.regmask
= -2;
4029 /* Offset to saved r31, in the sigtramp case the saved registers
4030 are above the frame in the sigcontext.
4031 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4032 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4033 and 32 * 4 bytes for the floating point registers. */
4034 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4035 e
->pdr
.fregmask
= -1;
4036 /* Offset to saved f30 (first saved *double* register). */
4037 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4038 e
->pdr
.isym
= (long) s
;
4039 e
->pdr
.adr
= sigtramp_address
;
4041 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4042 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4043 SYMBOL_VALUE (s
) = (long) e
;
4044 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4045 SYMBOL_CLASS (s
) = LOC_CONST
;
4046 SYMBOL_TYPE (s
) = builtin_type_void
;
4047 current_objfile
= NULL
;
4050 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4054 _initialize_mdebugread ()
4056 /* Missing basic types */
4058 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4060 mdebug_type_string
=
4061 init_type (TYPE_CODE_STRING
,
4062 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4064 (struct objfile
*) NULL
);
4066 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4067 good? Would we be better off with TYPE_CODE_ERROR? Should
4068 TYPE_CODE_ERROR print things in hex if it knows the size? */
4069 mdebug_type_fixed_dec
=
4070 init_type (TYPE_CODE_INT
,
4071 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4073 (struct objfile
*) NULL
);
4075 mdebug_type_float_dec
=
4076 init_type (TYPE_CODE_ERROR
,
4077 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4078 0, "floating decimal",
4079 (struct objfile
*) NULL
);