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_complex
;
278 static struct type
*mdebug_type_double_complex
;
279 static struct type
*mdebug_type_fixed_dec
;
280 static struct type
*mdebug_type_float_dec
;
281 static struct type
*mdebug_type_string
;
283 /* Forward declarations */
286 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
289 parse_partial_symbols
PARAMS ((struct objfile
*,
290 struct section_offsets
*));
293 *get_rfd
PARAMS ((int, int));
296 has_opaque_xref
PARAMS ((FDR
*, SYMR
*));
299 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
300 char **, int, char *));
302 static struct symbol
*
303 new_symbol
PARAMS ((char *));
306 new_type
PARAMS ((char *));
308 static struct block
*
309 new_block
PARAMS ((int));
311 static struct symtab
*
312 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
314 static struct linetable
*
315 new_linetable
PARAMS ((int));
317 static struct blockvector
*
318 new_bvect
PARAMS ((int));
321 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int, struct section_offsets
*));
324 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
326 static struct symbol
*
327 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
328 enum address_class
));
330 static struct block
*
331 shrink_block
PARAMS ((struct block
*, struct symtab
*));
334 xzalloc
PARAMS ((unsigned int));
337 sort_blocks
PARAMS ((struct symtab
*));
340 compare_blocks
PARAMS ((const void *, const void *));
342 static struct partial_symtab
*
343 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
346 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
349 add_block
PARAMS ((struct block
*, struct symtab
*));
352 add_symbol
PARAMS ((struct symbol
*, struct block
*));
355 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
357 static struct linetable
*
358 shrink_linetable
PARAMS ((struct linetable
*));
361 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int));
364 mdebug_next_symbol_text
PARAMS ((void));
366 /* Address bounds for the signal trampoline in inferior, if any */
368 CORE_ADDR sigtramp_address
, sigtramp_end
;
370 /* Allocate zeroed memory */
376 PTR p
= xmalloc (size
);
382 /* Exported procedure: Builds a symtab from the PST partial one.
383 Restores the environment in effect when PST was created, delegates
384 most of the work to an ancillary procedure, and sorts
385 and reorders the symtab list at the end */
388 mdebug_psymtab_to_symtab (pst
)
389 struct partial_symtab
*pst
;
397 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
398 gdb_flush (gdb_stdout
);
401 next_symbol_text_func
= mdebug_next_symbol_text
;
403 psymtab_to_symtab_1 (pst
, pst
->filename
);
405 /* Match with global symbols. This only needs to be done once,
406 after all of the symtabs and dependencies have been read in. */
407 scan_file_globals (pst
->objfile
);
410 printf_filtered ("done.\n");
413 /* File-level interface functions */
415 /* Find a file descriptor given its index RF relative to a file CF */
425 fdrs
= debug_info
->fdr
;
427 /* Object files do not have the RFD table, all refs are absolute */
430 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
431 ((char *) debug_info
->external_rfd
433 * debug_swap
->external_rfd_size
)),
438 /* Return a safer print NAME for a file descriptor */
445 return "<stripped file>";
448 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
452 /* Read in and parse the symtab of the file OBJFILE. Symbols from
453 different sections are relocated via the SECTION_OFFSETS. */
456 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
457 struct objfile
*objfile
;
458 const struct ecoff_debug_swap
*swap
;
459 struct ecoff_debug_info
*info
;
460 struct section_offsets
*section_offsets
;
462 cur_bfd
= objfile
->obfd
;
466 /* Make sure all the FDR information is swapped in. */
467 if (info
->fdr
== (FDR
*) NULL
)
473 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
474 (info
->symbolic_header
.ifdMax
476 fdr_src
= info
->external_fdr
;
478 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
480 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
481 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
484 parse_partial_symbols (objfile
, section_offsets
);
487 /* Check to make sure file was compiled with -g. If not, warn the
488 user of this limitation. */
489 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
491 if (max_gdbinfo
== 0)
492 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
494 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
495 gdb_flush (gdb_stdout
);
500 /* Local utilities */
502 /* Map of FDR indexes to partial symtabs */
506 struct partial_symtab
*pst
; /* the psymtab proper */
507 long n_globals
; /* exported globals (external symbols) */
508 long globals_offset
; /* cumulative */
512 /* Utility stack, used to nest procedures and blocks properly.
513 It is a doubly linked list, to avoid too many alloc/free.
514 Since we might need it quite a few times it is NOT deallocated
517 static struct parse_stack
519 struct parse_stack
*next
, *prev
;
520 struct symtab
*cur_st
; /* Current symtab. */
521 struct block
*cur_block
; /* Block in it. */
523 /* What are we parsing. stFile, or stBlock are for files and
524 blocks. stProc or stStaticProc means we have seen the start of a
525 procedure, but not the start of the block within in. When we see
526 the start of that block, we change it to stNil, without pushing a
527 new block, i.e. stNil means both a procedure and a block. */
531 int maxsyms
; /* Max symbols in this block. */
532 struct type
*cur_type
; /* Type we parse fields for. */
533 int cur_field
; /* Field number in cur_type. */
534 CORE_ADDR procadr
; /* Start addres of this procedure */
535 int numargs
; /* Its argument count */
538 *top_stack
; /* Top stack ptr */
541 /* Enter a new lexical context */
546 struct parse_stack
*new;
548 /* Reuse frames if possible */
549 if (top_stack
&& top_stack
->prev
)
550 new = top_stack
->prev
;
552 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
553 /* Initialize new frame with previous content */
556 register struct parse_stack
*prev
= new->prev
;
559 top_stack
->prev
= new;
561 new->next
= top_stack
;
566 /* Exit a lexical context */
574 top_stack
= top_stack
->next
;
578 /* Cross-references might be to things we haven't looked at
579 yet, e.g. type references. To avoid too many type
580 duplications we keep a quick fixup table, an array
581 of lists of references indexed by file descriptor */
583 struct mdebug_pending
585 struct mdebug_pending
*next
; /* link */
586 char *s
; /* the unswapped symbol */
587 struct type
*t
; /* its partial type descriptor */
591 /* The pending information is kept for an entire object file, and used
592 to be in the sym_private field. I took it out when I split
593 mdebugread from mipsread, because this might not be the only type
594 of symbols read from an object file. Instead, we allocate the
595 pending information table when we create the partial symbols, and
596 we store a pointer to the single table in each psymtab. */
598 static struct mdebug_pending
**pending_list
;
600 /* Check whether we already saw symbol SH in file FH */
602 static struct mdebug_pending
*
603 is_pending_symbol (fh
, sh
)
607 int f_idx
= fh
- debug_info
->fdr
;
608 register struct mdebug_pending
*p
;
610 /* Linear search is ok, list is typically no more than 10 deep */
611 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
617 /* Add a new symbol SH of type T */
620 add_pending (fh
, sh
, t
)
625 int f_idx
= fh
- debug_info
->fdr
;
626 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
628 /* Make sure we do not make duplicates */
631 p
= ((struct mdebug_pending
*)
632 obstack_alloc (¤t_objfile
->psymbol_obstack
,
633 sizeof (struct mdebug_pending
)));
636 p
->next
= pending_list
[f_idx
];
637 pending_list
[f_idx
] = p
;
642 /* Parsing Routines proper. */
644 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
645 For blocks, procedures and types we open a new lexical context.
646 This is basically just a big switch on the symbol's type. Argument
647 AX is the base pointer of aux symbols for this file (fh->iauxBase).
648 EXT_SH points to the unswapped symbol, which is needed for struct,
649 union, etc., types; it is NULL for an EXTR. BIGEND says whether
650 aux symbols are big-endian or little-endian. Return count of
651 SYMR's handled (normally one). */
654 parse_symbol (sh
, ax
, ext_sh
, bigend
, section_offsets
)
659 struct section_offsets
*section_offsets
;
661 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
662 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
663 debug_swap
->swap_sym_in
;
667 struct mdebug_pending
*pend
;
671 enum address_class
class;
673 long svalue
= sh
->value
;
676 if (ext_sh
== (char *) NULL
)
677 name
= debug_info
->ssext
+ sh
->iss
;
679 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
684 /* The value of a stEnd symbol is the displacement from the
685 corresponding start symbol value, do not relocate it. */
687 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
694 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
698 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
707 case stGlobal
: /* external symbol, goes into global block */
709 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
711 s
= new_symbol (name
);
712 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
715 case stStatic
: /* static data, goes into current block. */
717 b
= top_stack
->cur_block
;
718 s
= new_symbol (name
);
719 if (sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
721 /* It is a FORTRAN common block. At least for SGI Fortran the
722 address is not in the symbol; we need to fix it later in
723 scan_file_globals. */
724 int bucket
= hashname (SYMBOL_NAME (s
));
725 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
726 global_sym_chain
[bucket
] = s
;
729 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
732 case stLocal
: /* local variable, goes into current block */
733 if (sh
->sc
== scRegister
)
735 class = LOC_REGISTER
;
736 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
740 b
= top_stack
->cur_block
;
741 s
= new_symbol (name
);
742 SYMBOL_VALUE (s
) = svalue
;
744 data
: /* Common code for symbols describing data */
745 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
746 SYMBOL_CLASS (s
) = class;
749 /* Type could be missing in a number of cases */
750 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
751 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
753 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
754 /* Value of a data symbol is its memory address */
757 case stParam
: /* arg to procedure, goes into current block */
759 top_stack
->numargs
++;
761 /* Special GNU C++ name. */
762 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
763 name
= "this"; /* FIXME, not alloc'd in obstack */
764 s
= new_symbol (name
);
766 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
770 /* Pass by value in register. */
771 SYMBOL_CLASS(s
) = LOC_REGPARM
;
772 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
775 /* Pass by reference on stack. */
776 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
779 /* Pass by reference in register. */
780 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
781 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
784 /* Pass by value on stack. */
785 SYMBOL_CLASS(s
) = LOC_ARG
;
788 SYMBOL_VALUE (s
) = svalue
;
789 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
790 add_symbol (s
, top_stack
->cur_block
);
792 /* FIXME: This has not been tested. See dbxread.c */
793 /* Add the type of this parameter to the function/procedure
794 type of this block. */
795 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
799 case stLabel
: /* label, goes into current block */
800 s
= new_symbol (name
);
801 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
802 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
803 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
804 SYMBOL_TYPE (s
) = builtin_type_int
;
805 add_symbol (s
, top_stack
->cur_block
);
808 case stProc
: /* Procedure, usually goes into global block */
809 case stStaticProc
: /* Static procedure, goes into current block */
810 s
= new_symbol (name
);
811 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
812 SYMBOL_CLASS (s
) = LOC_BLOCK
;
813 /* Type of the return value */
814 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
815 t
= builtin_type_int
;
817 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
818 b
= top_stack
->cur_block
;
819 if (sh
->st
== stProc
)
821 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
822 /* The next test should normally be true, but provides a
823 hook for nested functions (which we don't want to make
825 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
826 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
827 /* Irix 5 sometimes has duplicate names for the same
828 function. We want to add such names up at the global
829 level, not as a nested function. */
830 else if (sh
->value
== top_stack
->procadr
)
831 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
835 /* Make a type for the procedure itself */
837 /* FIXME: This has not been tested yet! See dbxread.c */
838 /* Generate a template for the type of this function. The
839 types of the arguments will be added as we read the symbol
841 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
843 SYMBOL_TYPE (s
) = lookup_function_type (t
);
846 /* Create and enter a new lexical context */
847 b
= new_block (top_stack
->maxsyms
);
848 SYMBOL_BLOCK_VALUE (s
) = b
;
849 BLOCK_FUNCTION (b
) = s
;
850 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
851 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
852 add_block (b
, top_stack
->cur_st
);
854 /* Not if we only have partial info */
855 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
859 top_stack
->cur_block
= b
;
860 top_stack
->blocktype
= sh
->st
;
861 top_stack
->cur_type
= SYMBOL_TYPE (s
);
862 top_stack
->cur_field
= -1;
863 top_stack
->procadr
= sh
->value
;
864 top_stack
->numargs
= 0;
867 /* Beginning of code for structure, union, and enum definitions.
868 They all share a common set of local variables, defined here. */
870 enum type_code type_code
;
876 case stStruct
: /* Start a block defining a struct type */
877 type_code
= TYPE_CODE_STRUCT
;
878 goto structured_common
;
880 case stUnion
: /* Start a block defining a union type */
881 type_code
= TYPE_CODE_UNION
;
882 goto structured_common
;
884 case stEnum
: /* Start a block defining an enum type */
885 type_code
= TYPE_CODE_ENUM
;
886 goto structured_common
;
888 case stBlock
: /* Either a lexical block, or some type */
889 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
&& sh
->sc
!= scSCommon
)
890 goto case_stBlock_code
; /* Lexical block */
892 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
894 /* Common code for handling struct, union, enum, and/or as-yet-
895 unknown-type blocks of info about structured data. `type_code'
896 has been set to the proper TYPE_CODE, if we know it. */
899 top_stack
->blocktype
= stBlock
;
901 /* First count the number of fields and the highest value. */
904 for (ext_tsym
= ext_sh
+ external_sym_size
;
906 ext_tsym
+= external_sym_size
)
910 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
918 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
919 /* If the type of the member is Nil (or Void),
920 without qualifiers, assume the tag is an
922 if (tsym
.index
== indexNil
)
923 type_code
= TYPE_CODE_ENUM
;
926 (*debug_swap
->swap_tir_in
) (bigend
,
927 &ax
[tsym
.index
].a_ti
,
929 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
931 type_code
= TYPE_CODE_ENUM
;
934 if (tsym
.value
> max_value
)
935 max_value
= tsym
.value
;
944 /* This is a no-op; is it trying to tell us something
945 we should be checking? */
946 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
950 /* This is something like a struct within a
951 struct. Skip over the fields of the inner
952 struct. The -1 is because the for loop will
953 increment ext_tsym. */
954 ext_tsym
= ((char *) debug_info
->external_sym
955 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
956 * external_sym_size
));
962 /* mips cc puts out a typedef for struct x if it is not yet
963 defined when it encounters
964 struct y { struct x *xp; };
969 /* Irix5 cc puts out a stIndirect for struct x if it is not
970 yet defined when it encounters
971 struct y { struct x *xp; };
976 complain (&block_member_complaint
, tsym
.st
);
981 /* In an stBlock, there is no way to distinguish structs,
982 unions, and enums at this point. This is a bug in the
983 original design (that has been fixed with the recent
984 addition of the stStruct, stUnion, and stEnum symbol
985 types.) The way you can tell is if/when you see a variable
986 or field of that type. In that case the variable's type
987 (in the AUX table) says if the type is struct, union, or
988 enum, and points back to the stBlock here. So you can
989 patch the tag kind up later - but only if there actually is
990 a variable or field of that type.
992 So until we know for sure, we will guess at this point.
994 If the first member has index==indexNil or a void type,
995 assume we have an enumeration.
996 Otherwise, if there is more than one member, and all
997 the members have offset 0, assume we have a union.
998 Otherwise, assume we have a struct.
1000 The heuristic could guess wrong in the case of of an
1001 enumeration with no members or a union with one (or zero)
1002 members, or when all except the last field of a struct have
1003 width zero. These are uncommon and/or illegal situations,
1004 and in any case guessing wrong probably doesn't matter
1007 But if we later do find out we were wrong, we fixup the tag
1008 kind. Members of an enumeration must be handled
1009 differently from struct/union fields, and that is harder to
1010 patch up, but luckily we shouldn't need to. (If there are
1011 any enumeration members, we can tell for sure it's an enum
1014 if (type_code
== TYPE_CODE_UNDEF
)
1015 if (nfields
> 1 && max_value
== 0)
1016 type_code
= TYPE_CODE_UNION
;
1018 type_code
= TYPE_CODE_STRUCT
;
1020 /* Create a new type or use the pending type. */
1021 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1022 if (pend
== (struct mdebug_pending
*) NULL
)
1024 t
= new_type (NULL
);
1025 add_pending (cur_fdr
, ext_sh
, t
);
1030 /* Do not set the tag name if it is a compiler generated tag name
1031 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1032 Alpha cc puts out an sh->iss of zero for those. */
1033 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1034 TYPE_TAG_NAME (t
) = NULL
;
1036 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1039 TYPE_CODE (t
) = type_code
;
1040 TYPE_LENGTH (t
) = sh
->value
;
1041 TYPE_NFIELDS (t
) = nfields
;
1042 TYPE_FIELDS (t
) = f
= ((struct field
*)
1044 nfields
* sizeof (struct field
)));
1046 if (type_code
== TYPE_CODE_ENUM
)
1048 /* This is a non-empty enum. */
1050 /* DEC c89 has the number of enumerators in the sh.value field,
1051 not the type length, so we have to compensate for that
1052 incompatibility quirk.
1053 This might do the wrong thing for an enum with one or two
1054 enumerators and gcc -gcoff -fshort-enums, but these cases
1055 are hopefully rare enough. */
1056 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1057 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1058 for (ext_tsym
= ext_sh
+ external_sym_size
;
1060 ext_tsym
+= external_sym_size
)
1063 struct symbol
*enum_sym
;
1065 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1067 if (tsym
.st
!= stMember
)
1070 f
->bitpos
= tsym
.value
;
1072 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1075 enum_sym
= ((struct symbol
*)
1076 obstack_alloc (¤t_objfile
->symbol_obstack
,
1077 sizeof (struct symbol
)));
1078 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1079 SYMBOL_NAME (enum_sym
) = f
->name
;
1080 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1081 SYMBOL_TYPE (enum_sym
) = t
;
1082 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1083 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1084 add_symbol (enum_sym
, top_stack
->cur_block
);
1086 /* Skip the stMembers that we've handled. */
1091 /* make this the current type */
1092 top_stack
->cur_type
= t
;
1093 top_stack
->cur_field
= 0;
1095 /* Do not create a symbol for alpha cc unnamed structs. */
1099 /* gcc puts out an empty struct for an opaque struct definitions,
1100 do not create a symbol for it either. */
1101 if (TYPE_NFIELDS (t
) == 0)
1103 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1107 s
= new_symbol (name
);
1108 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1109 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1110 SYMBOL_VALUE (s
) = 0;
1111 SYMBOL_TYPE (s
) = t
;
1112 add_symbol (s
, top_stack
->cur_block
);
1115 /* End of local variables shared by struct, union, enum, and
1116 block (as yet unknown struct/union/enum) processing. */
1120 /* beginnning of (code) block. Value of symbol
1121 is the displacement from procedure start */
1122 push_parse_stack ();
1124 /* Do not start a new block if this is the outermost block of a
1125 procedure. This allows the LOC_BLOCK symbol to point to the
1126 block with the local variables, so funcname::var works. */
1127 if (top_stack
->blocktype
== stProc
1128 || top_stack
->blocktype
== stStaticProc
)
1130 top_stack
->blocktype
= stNil
;
1134 top_stack
->blocktype
= stBlock
;
1135 b
= new_block (top_stack
->maxsyms
);
1136 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1137 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1138 top_stack
->cur_block
= b
;
1139 add_block (b
, top_stack
->cur_st
);
1142 case stEnd
: /* end (of anything) */
1143 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
|| sh
->sc
== scSCommon
)
1145 /* Finished with type */
1146 top_stack
->cur_type
= 0;
1148 else if (sh
->sc
== scText
&&
1149 (top_stack
->blocktype
== stProc
||
1150 top_stack
->blocktype
== stStaticProc
))
1152 /* Finished with procedure */
1153 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1154 struct mips_extra_func_info
*e
;
1158 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1160 /* Make up special symbol to contain procedure specific info */
1161 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1162 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1163 SYMBOL_CLASS (s
) = LOC_CONST
;
1164 SYMBOL_TYPE (s
) = builtin_type_void
;
1165 e
= ((struct mips_extra_func_info
*)
1166 obstack_alloc (¤t_objfile
->symbol_obstack
,
1167 sizeof (struct mips_extra_func_info
)));
1168 SYMBOL_VALUE (s
) = (long) e
;
1169 e
->numargs
= top_stack
->numargs
;
1170 add_symbol (s
, top_stack
->cur_block
);
1172 /* Reallocate symbols, saving memory */
1173 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1175 /* f77 emits proc-level with address bounds==[0,0],
1176 So look for such child blocks, and patch them. */
1177 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1179 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1180 if (BLOCK_SUPERBLOCK (b_bad
) == b
1181 && BLOCK_START (b_bad
) == top_stack
->procadr
1182 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1184 BLOCK_START (b_bad
) = BLOCK_START (b
);
1185 BLOCK_END (b_bad
) = BLOCK_END (b
);
1189 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1191 /* End of (code) block. The value of the symbol is the
1192 displacement from the procedure`s start address of the
1193 end of this block. */
1194 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1195 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1197 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1199 /* End of outermost block. Pop parse stack and ignore. The
1200 following stEnd of stProc will take care of the block. */
1203 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1205 /* End of file. Pop parse stack and ignore. Higher
1206 level code deals with this. */
1210 complain (&stEnd_complaint
, sh
->sc
);
1212 pop_parse_stack (); /* restore previous lexical context */
1215 case stMember
: /* member of struct or union */
1216 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1218 f
->bitpos
= sh
->value
;
1220 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1221 f
->bitsize
= bitsize
;
1224 case stIndirect
: /* forward declaration on Irix5 */
1225 /* Forward declarations from Irix5 cc are handled by cross_ref,
1229 case stTypedef
: /* type definition */
1230 /* Typedefs for forward declarations and opaque structs from alpha cc
1231 are handled by cross_ref, skip them. */
1235 /* Parse the type or use the pending type. */
1236 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1237 if (pend
== (struct mdebug_pending
*) NULL
)
1239 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1240 add_pending (cur_fdr
, ext_sh
, t
);
1245 /* mips cc puts out a typedef with the name of the struct for forward
1246 declarations. These should not go into the symbol table and
1247 TYPE_NAME should not be set for them.
1248 They can't be distinguished from an intentional typedef to
1249 the same name however:
1251 struct x { int ix; int jx; };
1255 struct xx {int ixx; int jxx; };
1256 generates a cross referencing stTypedef for x and xx.
1257 The user visible effect of this is that the type of a pointer
1258 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1259 The problem is fixed with alpha cc and Irix5 cc. */
1261 /* However if the typedef cross references to an opaque aggregate, it
1262 is safe to omit it from the symbol table. */
1264 if (has_opaque_xref (cur_fdr
, sh
))
1266 s
= new_symbol (name
);
1267 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1268 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1269 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1270 SYMBOL_TYPE (s
) = t
;
1271 add_symbol (s
, top_stack
->cur_block
);
1273 /* Incomplete definitions of structs should not get a name. */
1274 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1275 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1276 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1277 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1279 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1280 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1282 /* If we are giving a name to a type such as "pointer to
1283 foo" or "function returning foo", we better not set
1284 the TYPE_NAME. If the program contains "typedef char
1285 *caddr_t;", we don't want all variables of type char
1286 * to print as caddr_t. This is not just a
1287 consequence of GDB's type management; CC and GCC (at
1288 least through version 2.4) both output variables of
1289 either type char * or caddr_t with the type
1290 refering to the stTypedef symbol for caddr_t. If a future
1291 compiler cleans this up it GDB is not ready for it
1292 yet, but if it becomes ready we somehow need to
1293 disable this check (without breaking the PCC/GCC2.4
1298 Fortunately, this check seems not to be necessary
1299 for anything except pointers or functions. */
1302 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1306 case stFile
: /* file name */
1307 push_parse_stack ();
1308 top_stack
->blocktype
= sh
->st
;
1311 /* I`ve never seen these for C */
1313 break; /* register relocation */
1315 break; /* forwarding address */
1317 break; /* constant */
1319 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1326 /* Parse the type information provided in the raw AX entries for
1327 the symbol SH. Return the bitfield size in BS, in case.
1328 We must byte-swap the AX entries before we use them; BIGEND says whether
1329 they are big-endian or little-endian (from fh->fBigendian). */
1331 static struct type
*
1332 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1335 unsigned int aux_index
;
1340 /* Null entries in this map are treated specially */
1341 static struct type
**map_bt
[] =
1343 &builtin_type_void
, /* btNil */
1345 &builtin_type_char
, /* btChar */
1346 &builtin_type_unsigned_char
,/* btUChar */
1347 &builtin_type_short
, /* btShort */
1348 &builtin_type_unsigned_short
, /* btUShort */
1349 &builtin_type_int
, /* btInt */
1350 &builtin_type_unsigned_int
, /* btUInt */
1351 &builtin_type_long
, /* btLong */
1352 &builtin_type_unsigned_long
,/* btULong */
1353 &builtin_type_float
, /* btFloat */
1354 &builtin_type_double
, /* btDouble */
1361 &mdebug_type_complex
, /* btComplex */
1362 &mdebug_type_double_complex
, /* btDComplex */
1364 &mdebug_type_fixed_dec
, /* btFixedDec */
1365 &mdebug_type_float_dec
, /* btFloatDec */
1366 &mdebug_type_string
, /* btString */
1369 &builtin_type_void
, /* btVoid */
1370 0, /* DEC C++: Pointer to member */
1371 0, /* DEC C++: Virtual function table */
1372 0, /* DEC C++: Class (Record) */
1373 &builtin_type_long
, /* btLong64 */
1374 &builtin_type_unsigned_long
, /* btULong64 */
1375 &builtin_type_long_long
, /* btLongLong64 */
1376 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1377 &builtin_type_unsigned_long
, /* btAdr64 */
1378 &builtin_type_long
, /* btInt64 */
1379 &builtin_type_unsigned_long
, /* btUInt64 */
1383 struct type
*tp
= 0;
1384 enum type_code type_code
= TYPE_CODE_UNDEF
;
1386 /* Handle undefined types, they have indexNil. */
1387 if (aux_index
== indexNil
)
1388 return builtin_type_int
;
1390 /* Handle corrupt aux indices. */
1391 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1393 complain (&index_complaint
, sym_name
);
1394 return builtin_type_int
;
1398 /* Use aux as a type information record, map its basic type. */
1399 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1400 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1402 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1403 return builtin_type_int
;
1407 tp
= *map_bt
[t
->bt
];
1412 /* Cannot use builtin types -- build our own */
1416 tp
= lookup_pointer_type (builtin_type_void
);
1419 type_code
= TYPE_CODE_STRUCT
;
1422 type_code
= TYPE_CODE_UNION
;
1425 type_code
= TYPE_CODE_ENUM
;
1428 type_code
= TYPE_CODE_RANGE
;
1431 type_code
= TYPE_CODE_SET
;
1434 /* alpha cc uses this for typedefs. The true type will be
1435 obtained by crossreferencing below. */
1436 type_code
= TYPE_CODE_ERROR
;
1439 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1440 return builtin_type_int
;
1444 /* Move on to next aux */
1449 /* Inhibit core dumps with some cfront generated objects that
1451 if (bs
== (int *)NULL
)
1453 complain (&bad_fbitfield_complaint
, sym_name
);
1454 return builtin_type_int
;
1456 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1460 /* All these types really point to some (common) MIPS type
1461 definition, and only the type-qualifiers fully identify
1462 them. We'll make the same effort at sharing. */
1463 if (t
->bt
== btStruct
||
1467 /* btSet (I think) implies that the name is a tag name, not a typedef
1468 name. This apparently is a MIPS extension for C sets. */
1473 /* Try to cross reference this type, build new type on failure. */
1474 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1475 if (tp
== (struct type
*) NULL
)
1476 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1478 /* DEC c89 produces cross references to qualified aggregate types,
1479 dereference them. */
1480 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1481 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1482 tp
= tp
->target_type
;
1484 /* Make sure that TYPE_CODE(tp) has an expected type code.
1485 Any type may be returned from cross_ref if file indirect entries
1487 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1488 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1489 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1491 complain (&unexpected_type_code_complaint
, sym_name
);
1496 /* Usually, TYPE_CODE(tp) is already type_code. The main
1497 exception is if we guessed wrong re struct/union/enum.
1498 But for struct vs. union a wrong guess is harmless, so
1499 don't complain(). */
1500 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1501 && type_code
!= TYPE_CODE_ENUM
)
1502 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1503 && type_code
== TYPE_CODE_ENUM
))
1505 complain (&bad_tag_guess_complaint
, sym_name
);
1508 if (TYPE_CODE (tp
) != type_code
)
1510 TYPE_CODE (tp
) = type_code
;
1513 /* Do not set the tag name if it is a compiler generated tag name
1514 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1515 if (name
[0] == '.' || name
[0] == '\0')
1516 TYPE_TAG_NAME (tp
) = NULL
;
1517 else if (TYPE_TAG_NAME (tp
) == NULL
1518 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1519 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1520 ¤t_objfile
->type_obstack
);
1524 /* All these types really point to some (common) MIPS type
1525 definition, and only the type-qualifiers fully identify
1526 them. We'll make the same effort at sharing.
1527 FIXME: btIndirect cannot happen here as it is handled by the
1528 switch t->bt above. And we are not doing any guessing on range types. */
1529 if (t
->bt
== btIndirect
||
1534 /* Try to cross reference this type, build new type on failure. */
1535 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1536 if (tp
== (struct type
*) NULL
)
1537 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1539 /* Make sure that TYPE_CODE(tp) has an expected type code.
1540 Any type may be returned from cross_ref if file indirect entries
1542 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1544 complain (&unexpected_type_code_complaint
, sym_name
);
1548 /* Usually, TYPE_CODE(tp) is already type_code. The main
1549 exception is if we guessed wrong re struct/union/enum. */
1550 if (TYPE_CODE (tp
) != type_code
)
1552 complain (&bad_tag_guess_complaint
, sym_name
);
1553 TYPE_CODE (tp
) = type_code
;
1555 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1556 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1557 ¤t_objfile
->type_obstack
);
1560 if (t
->bt
== btTypedef
)
1564 /* Try to cross reference this type, it should succeed. */
1565 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1566 if (tp
== (struct type
*) NULL
)
1568 complain (&unable_to_cross_ref_complaint
, sym_name
);
1569 tp
= builtin_type_int
;
1573 /* Deal with range types */
1574 if (t
->bt
== btRange
)
1576 TYPE_NFIELDS (tp
) = 2;
1577 TYPE_FIELDS (tp
) = ((struct field
*)
1578 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1579 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1580 ¤t_objfile
->type_obstack
);
1581 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1583 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1584 ¤t_objfile
->type_obstack
);
1585 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1589 /* Parse all the type qualifiers now. If there are more
1590 than 6 the game will continue in the next aux */
1594 #define PARSE_TQ(tq) \
1595 if (t->tq != tqNil) \
1596 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1608 /* mips cc 2.x and gcc never put out continued aux entries. */
1612 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1616 /* Complain for illegal continuations due to corrupt aux entries. */
1618 complain (&bad_continued_complaint
, sym_name
);
1623 /* Make up a complex type from a basic one. Type is passed by
1624 reference in TPP and side-effected as necessary. The type
1625 qualifier TQ says how to handle the aux symbols at AX for
1626 the symbol SX we are currently analyzing. BIGEND says whether
1627 aux symbols are big-endian or little-endian.
1628 Returns the number of aux symbols we parsed. */
1631 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1642 /* Used in array processing */
1653 t
= lookup_pointer_type (*tpp
);
1658 t
= lookup_function_type (*tpp
);
1665 /* Determine and record the domain type (type of index) */
1666 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1672 rf
= AUX_GET_ISYM (bigend
, ax
);
1675 fh
= get_rfd (fd
, rf
);
1677 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1678 id
, (int *) NULL
, bigend
, sym_name
);
1680 /* The bounds type should be an integer type, but might be anything
1681 else due to corrupt aux entries. */
1682 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1684 complain (&array_index_type_complaint
, sym_name
);
1685 indx
= builtin_type_int
;
1688 /* Get the bounds, and create the array type. */
1690 lower
= AUX_GET_DNLOW (bigend
, ax
);
1692 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1694 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1696 range
= create_range_type ((struct type
*) NULL
, indx
,
1699 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1701 /* We used to fill in the supplied array element bitsize
1702 here if the TYPE_LENGTH of the target type was zero.
1703 This happens for a `pointer to an array of anonymous structs',
1704 but in this case the array element bitsize is also zero,
1705 so nothing is gained.
1706 And we used to check the TYPE_LENGTH of the target type against
1707 the supplied array element bitsize.
1708 gcc causes a mismatch for `pointer to array of object',
1709 since the sdb directives it uses do not have a way of
1710 specifying the bitsize, but it does no harm (the
1711 TYPE_LENGTH should be correct) and we should be able to
1712 ignore the erroneous bitsize from the auxiliary entry safely.
1713 dbx seems to ignore it too. */
1719 /* Volatile -- currently ignored */
1723 /* Const -- currently ignored */
1727 complain (&unknown_type_qual_complaint
, tq
);
1733 /* Parse a procedure descriptor record PR. Note that the procedure is
1734 parsed _after_ the local symbols, now we just insert the extra
1735 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1736 already been placed in the procedure's main block. Note also that
1737 images that have been partially stripped (ld -x) have been deprived
1738 of local symbols, and we have to cope with them here. FIRST_OFF is
1739 the offset of the first procedure for this FDR; we adjust the
1740 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1741 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1742 in question, or NULL to use top_stack->cur_block. */
1744 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long,
1745 struct partial_symtab
*));
1748 parse_procedure (pr
, search_symtab
, first_off
, pst
)
1750 struct symtab
*search_symtab
;
1751 unsigned long first_off
;
1752 struct partial_symtab
*pst
;
1754 struct symbol
*s
, *i
;
1756 struct mips_extra_func_info
*e
;
1759 /* Simple rule to find files linked "-x" */
1760 if (cur_fdr
->rss
== -1)
1764 /* Static procedure at address pr->adr. Sigh. */
1765 /* FIXME-32x64. assuming pr->adr fits in long. */
1766 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1774 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1775 ((char *) debug_info
->external_ext
1777 * debug_swap
->external_ext_size
)),
1779 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1787 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1788 ((char *) debug_info
->external_sym
1789 + ((cur_fdr
->isymBase
+ pr
->isym
)
1790 * debug_swap
->external_sym_size
)),
1792 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1795 if (search_symtab
!= NULL
)
1798 /* This loses both in the case mentioned (want a static, find a global),
1799 but also if we are looking up a non-mangled name which happens to
1800 match the name of a mangled function. */
1801 /* We have to save the cur_fdr across the call to lookup_symbol.
1802 If the pdr is for a static function and if a global function with
1803 the same name exists, lookup_symbol will eventually read in the symtab
1804 for the global function and clobber cur_fdr. */
1805 FDR
*save_cur_fdr
= cur_fdr
;
1806 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1807 cur_fdr
= save_cur_fdr
;
1811 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1817 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1818 VAR_NAMESPACE
, LOC_BLOCK
);
1822 b
= SYMBOL_BLOCK_VALUE (s
);
1826 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1830 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1831 s
= new_symbol (sh_name
);
1832 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1833 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1834 /* Donno its type, hope int is ok */
1835 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1836 add_symbol (s
, top_stack
->cur_block
);
1837 /* Wont have symbols for this one */
1839 SYMBOL_BLOCK_VALUE (s
) = b
;
1840 BLOCK_FUNCTION (b
) = s
;
1841 BLOCK_START (b
) = pr
->adr
;
1842 /* BOUND used to be the end of procedure's text, but the
1843 argument is no longer passed in. */
1844 BLOCK_END (b
) = bound
;
1845 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1846 add_block (b
, top_stack
->cur_st
);
1850 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1854 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1856 e
->pdr
.isym
= (long) s
;
1857 e
->pdr
.adr
+= pst
->textlow
- first_off
;
1859 /* Correct incorrect setjmp procedure descriptor from the library
1860 to make backtrace through setjmp work. */
1861 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1863 complain (&bad_setjmp_pdr_complaint
, 0);
1864 e
->pdr
.pcreg
= RA_REGNUM
;
1865 e
->pdr
.regmask
= 0x80000000;
1866 e
->pdr
.regoffset
= -4;
1871 /* Relocate the extra function info pointed to by the symbol table. */
1874 ecoff_relocate_efi (sym
, delta
)
1878 struct mips_extra_func_info
*e
;
1880 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
1882 e
->pdr
.adr
+= delta
;
1885 /* Parse the external symbol ES. Just call parse_symbol() after
1886 making sure we know where the aux are for it.
1887 BIGEND says whether aux entries are big-endian or little-endian.
1889 This routine clobbers top_stack->cur_block and ->cur_st. */
1891 static void parse_external
PARAMS ((EXTR
*, int, struct section_offsets
*));
1894 parse_external (es
, bigend
, section_offsets
)
1897 struct section_offsets
*section_offsets
;
1901 if (es
->ifd
!= ifdNil
)
1904 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1905 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1909 cur_fdr
= debug_info
->fdr
;
1913 /* Reading .o files */
1914 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1917 switch (es
->asym
.st
)
1920 /* These are generated for static symbols in .o files,
1941 /* FIXME: Turn this into a complaint? */
1943 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1944 what
, debug_info
->ssext
+ es
->asym
.iss
,
1945 fdr_name (cur_fdr
));
1949 switch (es
->asym
.st
)
1953 /* There is no need to parse the external procedure symbols.
1954 If they are from objects compiled without -g, their index will
1955 be indexNil, and the symbol definition from the minimal symbol
1956 is preferrable (yielding a function returning int instead of int).
1957 If the index points to a local procedure symbol, the local
1958 symbol already provides the correct type.
1959 Note that the index of the external procedure symbol points
1960 to the local procedure symbol in the local symbol table, and
1961 _not_ to the auxiliary symbol info. */
1965 /* Global common symbols are resolved by the runtime loader,
1967 if (es
->asym
.sc
== scCommon
|| es
->asym
.sc
== scSCommon
)
1970 /* Note that the case of a symbol with indexNil must be handled
1971 anyways by parse_symbol(). */
1972 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
);
1979 /* Parse the line number info for file descriptor FH into
1980 GDB's linetable LT. MIPS' encoding requires a little bit
1981 of magic to get things out. Note also that MIPS' line
1982 numbers can go back and forth, apparently we can live
1983 with that and do not need to reorder our linetables */
1985 static void parse_lines
PARAMS ((FDR
*, PDR
*, struct linetable
*, int,
1986 struct partial_symtab
*));
1989 parse_lines (fh
, pr
, lt
, maxlines
, pst
)
1992 struct linetable
*lt
;
1994 struct partial_symtab
*pst
;
1996 unsigned char *base
;
1998 int delta
, count
, lineno
= 0;
1999 unsigned long first_off
= pr
->adr
;
2001 if (fh
->cbLine
== 0)
2004 /* Scan by procedure descriptors */
2006 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2010 unsigned char *halt
;
2012 /* No code for this one */
2013 if (pr
->iline
== ilineNil
||
2014 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2017 /* Determine start and end address of compressed line bytes for
2019 base
= debug_info
->line
+ fh
->cbLineOffset
;
2020 if (j
!= (fh
->cpd
- 1))
2021 halt
= base
+ pr
[1].cbLineOffset
;
2023 halt
= base
+ fh
->cbLine
;
2024 base
+= pr
->cbLineOffset
;
2026 adr
= pst
->textlow
+ pr
->adr
- first_off
;
2028 l
= adr
>> 2; /* in words */
2029 for (lineno
= pr
->lnLow
; base
< halt
; )
2031 count
= *base
& 0x0f;
2032 delta
= *base
++ >> 4;
2037 delta
= (base
[0] << 8) | base
[1];
2038 if (delta
>= 0x8000)
2042 lineno
+= delta
; /* first delta is 0 */
2044 /* Complain if the line table overflows. Could happen
2045 with corrupt binaries. */
2046 if (lt
->nitems
>= maxlines
)
2048 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2051 k
= add_line (lt
, lineno
, l
, k
);
2057 /* Master parsing procedure for first-pass reading of file symbols
2058 into a partial_symtab. */
2061 parse_partial_symbols (objfile
, section_offsets
)
2062 struct objfile
*objfile
;
2063 struct section_offsets
*section_offsets
;
2065 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2066 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2067 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2068 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2069 = debug_swap
->swap_ext_in
;
2070 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2071 = debug_swap
->swap_sym_in
;
2072 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2073 = debug_swap
->swap_rfd_in
;
2075 HDRR
*hdr
= &debug_info
->symbolic_header
;
2076 /* Running pointers */
2081 register EXTR
*ext_in
;
2084 struct partial_symtab
*pst
;
2086 int past_first_source_file
= 0;
2088 /* List of current psymtab's include files */
2089 char **psymtab_include_list
;
2090 int includes_allocated
;
2093 struct pst_map
*fdr_to_pst
;
2094 /* Index within current psymtab dependency list */
2095 struct partial_symtab
**dependency_list
;
2096 int dependencies_used
, dependencies_allocated
;
2097 struct cleanup
*old_chain
;
2099 enum language prev_language
;
2100 asection
*text_sect
;
2101 int relocatable
= 0;
2103 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2104 the shared libraries are prelinked at a high memory address.
2105 We have to adjust the start address of the object file for this case,
2106 by setting it to the start address of the first procedure in the file.
2107 But we should do no adjustments if we are debugging a .o file, where
2108 the text section (and fh->adr) really starts at zero. */
2109 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2110 if (text_sect
!= NULL
2111 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2114 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2115 sizeof (EXTR
) * hdr
->iextMax
);
2117 includes_allocated
= 30;
2119 psymtab_include_list
= (char **) alloca (includes_allocated
*
2121 next_symbol_text_func
= mdebug_next_symbol_text
;
2123 dependencies_allocated
= 30;
2124 dependencies_used
= 0;
2126 (struct partial_symtab
**) alloca (dependencies_allocated
*
2127 sizeof (struct partial_symtab
*));
2129 last_source_file
= NULL
;
2134 * Only parse the Local and External symbols, and the Relative FDR.
2135 * Fixup enough of the loader symtab to be able to use it.
2136 * Allocate space only for the file's portions we need to
2141 max_glevel
= MIN_GLEVEL
;
2143 /* Allocate the map FDR -> PST.
2144 Minor hack: -O3 images might claim some global data belongs
2145 to FDR -1. We`ll go along with that */
2146 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2147 old_chain
= make_cleanup (free
, fdr_to_pst
);
2150 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2151 fdr_to_pst
[-1].pst
= pst
;
2155 /* Allocate the global pending list. */
2157 ((struct mdebug_pending
**)
2158 obstack_alloc (&objfile
->psymbol_obstack
,
2159 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2160 memset ((PTR
) pending_list
, 0,
2161 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2163 /* Pass 0 over external syms: swap them in. */
2164 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2165 make_cleanup (free
, ext_block
);
2167 ext_out
= (char *) debug_info
->external_ext
;
2168 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2170 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2171 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2173 /* Pass 1 over external syms: Presize and partition the list */
2175 ext_in_end
= ext_in
+ hdr
->iextMax
;
2176 for (; ext_in
< ext_in_end
; ext_in
++)
2178 /* See calls to complain below. */
2179 if (ext_in
->ifd
>= -1
2180 && ext_in
->ifd
< hdr
->ifdMax
2181 && ext_in
->asym
.iss
>= 0
2182 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2183 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2186 /* Pass 1.5 over files: partition out global symbol space */
2188 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2190 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2191 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2192 fdr_to_pst
[f_idx
].n_globals
= 0;
2195 /* Pass 2 over external syms: fill in external symbols */
2197 ext_in_end
= ext_in
+ hdr
->iextMax
;
2198 for (; ext_in
< ext_in_end
; ext_in
++)
2200 enum minimal_symbol_type ms_type
= mst_text
;
2201 CORE_ADDR svalue
= ext_in
->asym
.value
;
2203 /* The Irix 5 native tools seem to sometimes generate bogus
2204 external symbols. */
2205 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2207 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2210 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2212 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2217 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2218 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2220 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2223 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2224 switch (ext_in
->asym
.st
)
2227 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2230 ms_type
= mst_file_text
;
2231 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2234 if (ext_in
->asym
.sc
== scCommon
|| ext_in
->asym
.sc
== scSCommon
)
2236 /* The value of a common symbol is its size, not its address.
2240 else if (ext_in
->asym
.sc
== scData
2241 || ext_in
->asym
.sc
== scSData
2242 || ext_in
->asym
.sc
== scRData
2243 || ext_in
->asym
.sc
== scPData
2244 || ext_in
->asym
.sc
== scXData
)
2247 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2252 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2256 if (ext_in
->asym
.sc
== scAbs
)
2258 else if (ext_in
->asym
.sc
== scText
2259 || ext_in
->asym
.sc
== scInit
2260 || ext_in
->asym
.sc
== scFini
)
2262 ms_type
= mst_file_text
;
2263 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2265 else if (ext_in
->asym
.sc
== scData
2266 || ext_in
->asym
.sc
== scSData
2267 || ext_in
->asym
.sc
== scRData
2268 || ext_in
->asym
.sc
== scPData
2269 || ext_in
->asym
.sc
== scXData
)
2271 ms_type
= mst_file_data
;
2272 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2276 ms_type
= mst_file_bss
;
2277 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2281 /* The alpha has the section start addresses in stLocal symbols
2282 whose name starts with a `.'. Skip those but complain for all
2283 other stLocal symbols. */
2288 ms_type
= mst_unknown
;
2289 complain (&unknown_ext_complaint
, name
);
2291 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2294 /* Pass 3 over files, over local syms: fill in static symbols */
2295 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2297 struct partial_symtab
*save_pst
;
2301 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2305 fdr_to_pst
[f_idx
].pst
= NULL
;
2309 /* Determine the start address for this object file from the
2310 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2314 if (relocatable
|| textlow
!= 0)
2315 textlow
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2319 pst
= start_psymtab_common (objfile
, section_offsets
,
2322 objfile
->global_psymbols
.next
,
2323 objfile
->static_psymbols
.next
);
2324 pst
->read_symtab_private
= ((char *)
2325 obstack_alloc (&objfile
->psymbol_obstack
,
2326 sizeof (struct symloc
)));
2327 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2330 FDR_IDX (pst
) = f_idx
;
2331 CUR_BFD (pst
) = cur_bfd
;
2332 DEBUG_SWAP (pst
) = debug_swap
;
2333 DEBUG_INFO (pst
) = debug_info
;
2334 PENDING_LIST (pst
) = pending_list
;
2336 /* The way to turn this into a symtab is to call... */
2337 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2339 /* Set up language for the pst.
2340 The language from the FDR is used if it is unambigious (e.g. cfront
2341 with native cc and g++ will set the language to C).
2342 Otherwise we have to deduce the language from the filename.
2343 Native ecoff has every header file in a separate FDR, so
2344 deduce_language_from_filename will return language_unknown for
2345 a header file, which is not what we want.
2346 But the FDRs for the header files are after the FDR for the source
2347 file, so we can assign the language of the source file to the
2348 following header files. Then we save the language in the private
2349 pst data so that we can reuse it when building symtabs. */
2350 prev_language
= psymtab_language
;
2354 case langCplusplusV2
:
2355 psymtab_language
= language_cplus
;
2358 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2361 if (psymtab_language
== language_unknown
)
2362 psymtab_language
= prev_language
;
2363 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2365 pst
->texthigh
= pst
->textlow
;
2367 /* For stabs-in-ecoff files, the second symbol must be @stab.
2368 This symbol is emitted by mips-tfile to signal that the
2369 current object file uses encapsulated stabs instead of mips
2370 ecoff for local symbols. (It is the second symbol because
2371 the first symbol is the stFile used to signal the start of a
2373 processing_gcc_compilation
= 0;
2376 (*swap_sym_in
) (cur_bfd
,
2377 ((char *) debug_info
->external_sym
2378 + (fh
->isymBase
+ 1) * external_sym_size
),
2380 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2381 processing_gcc_compilation
= 2;
2384 if (processing_gcc_compilation
!= 0)
2386 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2391 (*swap_sym_in
) (cur_bfd
,
2392 (((char *) debug_info
->external_sym
)
2393 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2395 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2396 if (!ECOFF_IS_STAB (&sh
))
2398 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2403 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2404 if (sh
.st
== stStaticProc
)
2406 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2407 prim_record_minimal_symbol_and_info (namestring
,
2414 procaddr
= sh
.value
;
2416 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2417 (debug_info
->external_aux
2420 (*swap_sym_in
) (cur_bfd
,
2421 ((char *) debug_info
->external_sym
2422 + ((fh
->isymBase
+ isym
- 1)
2423 * external_sym_size
)),
2427 long high
= procaddr
+ sh
.value
;
2429 /* Kludge for Irix 5.2 zero fh->adr. */
2431 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2432 pst
->textlow
= procaddr
;
2433 if (high
> pst
->texthigh
)
2434 pst
->texthigh
= high
;
2437 else if (sh
.st
== stStatic
)
2451 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2452 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2453 prim_record_minimal_symbol_and_info (namestring
,
2462 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2463 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2464 prim_record_minimal_symbol_and_info (namestring
,
2475 #define SET_NAMESTRING() \
2476 namestring = debug_info->ss + fh->issBase + sh.iss
2477 #define CUR_SYMBOL_TYPE type_code
2478 #define CUR_SYMBOL_VALUE sh.value
2479 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2481 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2482 #define HANDLE_RBRAC(val) \
2483 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2484 #include "partial-stab.h"
2489 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2492 enum address_class
class;
2494 (*swap_sym_in
) (cur_bfd
,
2495 ((char *) debug_info
->external_sym
2496 + ((fh
->isymBase
+ cur_sdx
)
2497 * external_sym_size
)),
2500 if (ECOFF_IS_STAB (&sh
))
2506 /* Non absolute static symbols go into the minimal table. */
2507 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2508 || (sh
.index
== indexNil
2509 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2511 /* FIXME, premature? */
2516 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2521 /* The value of a stEnd symbol is the displacement from the
2522 corresponding start symbol value, do not relocate it. */
2524 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2531 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2535 sh
.value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2546 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2547 mst_file_text
, NULL
,
2548 SECT_OFF_TEXT
, objfile
);
2553 /* Usually there is a local and a global stProc symbol
2554 for a function. This means that the function name
2555 has already been entered into the mimimal symbol table
2556 while processing the global symbols in pass 2 above.
2557 One notable exception is the PROGRAM name from
2558 f77 compiled executables, it is only put out as
2559 local stProc symbol, and a global MAIN__ stProc symbol
2560 points to it. It doesn't matter though, as gdb is
2561 still able to find the PROGRAM name via the partial
2562 symbol table, and the MAIN__ symbol via the minimal
2564 if (sh
.st
== stProc
)
2565 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2566 VAR_NAMESPACE
, LOC_BLOCK
,
2567 objfile
->global_psymbols
,
2568 sh
.value
, psymtab_language
, objfile
);
2570 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2571 VAR_NAMESPACE
, LOC_BLOCK
,
2572 objfile
->static_psymbols
,
2573 sh
.value
, psymtab_language
, objfile
);
2575 /* Skip over procedure to next one. */
2576 if (sh
.index
>= hdr
->iauxMax
)
2578 /* Should not happen, but does when cross-compiling
2579 with the MIPS compiler. FIXME -- pull later. */
2580 complain (&index_complaint
, name
);
2581 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2584 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2585 (debug_info
->external_aux
2588 procaddr
= sh
.value
;
2590 if (new_sdx
<= cur_sdx
)
2592 /* This should not happen either... FIXME. */
2593 complain (&aux_index_complaint
, name
);
2594 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2598 (*swap_sym_in
) (cur_bfd
,
2599 ((char *) debug_info
->external_sym
2600 + ((fh
->isymBase
+ cur_sdx
- 1)
2601 * external_sym_size
)),
2606 /* Kludge for Irix 5.2 zero fh->adr. */
2608 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2609 pst
->textlow
= procaddr
;
2611 high
= procaddr
+ sh
.value
;
2612 if (high
> pst
->texthigh
)
2613 pst
->texthigh
= high
;
2616 case stStatic
: /* Variable */
2621 || sh
.sc
== scXData
)
2622 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2623 mst_file_data
, NULL
,
2627 prim_record_minimal_symbol_and_info (name
, sh
.value
,
2634 case stIndirect
:/* Irix5 forward declaration */
2635 /* Skip forward declarations from Irix5 cc */
2638 case stTypedef
:/* Typedef */
2639 /* Skip typedefs for forward declarations and opaque
2640 structs from alpha and mips cc. */
2641 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
2643 class = LOC_TYPEDEF
;
2646 case stConstant
: /* Constant decl */
2653 case stBlock
: /* { }, str, un, enum*/
2654 /* Do not create a partial symbol for cc unnamed aggregates
2655 and gcc empty aggregates. */
2656 if ((sh
.sc
== scInfo
2657 || sh
.sc
== scCommon
|| sh
.sc
== scSCommon
)
2659 && sh
.index
!= cur_sdx
+ 2)
2661 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2662 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2663 objfile
->static_psymbols
,
2665 psymtab_language
, objfile
);
2667 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2669 /* Skip over the block */
2671 if (new_sdx
<= cur_sdx
)
2673 /* This happens with the Ultrix kernel. */
2674 complain (&block_index_complaint
, name
);
2675 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2680 case stFile
: /* File headers */
2681 case stLabel
: /* Labels */
2682 case stEnd
: /* Ends of files */
2685 case stLocal
: /* Local variables */
2686 /* Normally these are skipped because we skip over
2687 all blocks we see. However, these can occur
2688 as visible symbols in a .h file that contains code. */
2692 /* Both complaints are valid: one gives symbol name,
2693 the other the offending symbol type. */
2694 complain (&unknown_sym_complaint
, name
);
2695 complain (&unknown_st_complaint
, sh
.st
);
2699 /* Use this gdb symbol */
2700 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2701 VAR_NAMESPACE
, class,
2702 objfile
->static_psymbols
, sh
.value
,
2703 psymtab_language
, objfile
);
2705 cur_sdx
++; /* Go to next file symbol */
2708 /* Now do enter the external symbols. */
2709 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2710 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2711 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2712 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2713 for (; --cur_sdx
>= 0; ext_ptr
++)
2715 enum address_class
class;
2720 if (ext_ptr
->ifd
!= f_idx
)
2722 psh
= &ext_ptr
->asym
;
2724 /* Do not add undefined symbols to the partial symbol table. */
2725 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2728 svalue
= psh
->value
;
2732 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2739 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2743 svalue
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2750 /* These are generated for static symbols in .o files,
2755 /* External procedure symbols have been entered
2756 into the minimal symbol table in pass 2 above.
2757 Ignore them, as parse_external will ignore them too. */
2763 complain (&unknown_ext_complaint
,
2764 debug_info
->ssext
+ psh
->iss
);
2765 /* Fall through, pretend it's global. */
2767 /* Global common symbols are resolved by the runtime loader,
2769 if (psh
->sc
== scCommon
|| psh
->sc
== scSCommon
)
2775 name
= debug_info
->ssext
+ psh
->iss
;
2776 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2777 VAR_NAMESPACE
, class,
2778 objfile
->global_psymbols
,
2780 psymtab_language
, objfile
);
2784 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2785 empty and put on the free list. */
2786 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2787 psymtab_include_list
, includes_used
,
2788 -1, save_pst
->texthigh
,
2789 dependency_list
, dependencies_used
);
2790 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2791 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2793 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2794 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2797 /* The objfile has its functions reordered if this partial symbol
2798 table overlaps any other partial symbol table.
2799 We cannot assume a reordered objfile if a partial symbol table
2800 is contained within another partial symbol table, as partial symbol
2801 tables for include files with executable code are contained
2802 within the partial symbol table for the including source file,
2803 and we do not want to flag the objfile reordered for these cases.
2805 This strategy works well for Irix-5.2 shared libraries, but we
2806 might have to use a more elaborate (and slower) algorithm for
2808 save_pst
= fdr_to_pst
[f_idx
].pst
;
2809 if (save_pst
!= NULL
2810 && save_pst
->textlow
!= 0
2811 && !(objfile
->flags
& OBJF_REORDERED
))
2813 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
2816 && save_pst
->textlow
>= pst
->textlow
2817 && save_pst
->textlow
< pst
->texthigh
2818 && save_pst
->texthigh
> pst
->texthigh
)
2820 objfile
->flags
|= OBJF_REORDERED
;
2827 /* Now scan the FDRs for dependencies */
2828 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2830 fh
= f_idx
+ debug_info
->fdr
;
2831 pst
= fdr_to_pst
[f_idx
].pst
;
2833 if (pst
== (struct partial_symtab
*)NULL
)
2836 /* This should catch stabs-in-ecoff. */
2840 /* Skip the first file indirect entry as it is a self dependency
2841 for source files or a reverse .h -> .c dependency for header files. */
2842 pst
->number_of_dependencies
= 0;
2844 ((struct partial_symtab
**)
2845 obstack_alloc (&objfile
->psymbol_obstack
,
2847 * sizeof (struct partial_symtab
*))));
2848 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2852 (*swap_rfd_in
) (cur_bfd
,
2853 ((char *) debug_info
->external_rfd
2854 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2856 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2858 complain (&bad_file_number_complaint
, rh
);
2862 /* Skip self dependencies of header files. */
2866 /* Do not add to dependeny list if psymtab was empty. */
2867 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2869 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2873 /* Remove the dummy psymtab created for -O3 images above, if it is
2874 still empty, to enable the detection of stripped executables. */
2875 if (objfile
->psymtabs
->next
== NULL
2876 && objfile
->psymtabs
->number_of_dependencies
== 0
2877 && objfile
->psymtabs
->n_global_syms
== 0
2878 && objfile
->psymtabs
->n_static_syms
== 0)
2879 objfile
->psymtabs
= NULL
;
2880 do_cleanups (old_chain
);
2883 /* If the current psymbol has an enumerated type, we need to add
2884 all the the enum constants to the partial symbol table. */
2887 handle_psymbol_enumerators (objfile
, fh
, stype
)
2888 struct objfile
*objfile
;
2892 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2893 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2894 = debug_swap
->swap_sym_in
;
2895 char *ext_sym
= ((char *) debug_info
->external_sym
2896 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2906 /* It is an enumerated type if the next symbol entry is a stMember
2907 and its auxiliary index is indexNil or its auxiliary entry
2908 is a plain btNil or btVoid. */
2909 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2910 if (sh
.st
!= stMember
)
2913 if (sh
.index
== indexNil
)
2915 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
2916 &(debug_info
->external_aux
2917 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2919 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2931 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2932 if (sh
.st
!= stMember
)
2934 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2936 /* Note that the value doesn't matter for enum constants
2937 in psymtabs, just in symtabs. */
2938 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2939 VAR_NAMESPACE
, LOC_CONST
,
2940 objfile
->static_psymbols
, 0,
2941 psymtab_language
, objfile
);
2942 ext_sym
+= external_sym_size
;
2947 mdebug_next_symbol_text ()
2952 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2953 ((char *) debug_info
->external_sym
2954 + ((cur_fdr
->isymBase
+ cur_sdx
)
2955 * debug_swap
->external_sym_size
)),
2957 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2960 /* Ancillary function to psymtab_to_symtab(). Does all the work
2961 for turning the partial symtab PST into a symtab, recurring
2962 first on all dependent psymtabs. The argument FILENAME is
2963 only passed so we can see in debug stack traces what file
2966 This function has a split personality, based on whether the
2967 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2968 The flow of control and even the memory allocation differs. FIXME. */
2971 psymtab_to_symtab_1 (pst
, filename
)
2972 struct partial_symtab
*pst
;
2975 bfd_size_type external_sym_size
;
2976 bfd_size_type external_pdr_size
;
2977 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2978 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
2982 struct linetable
*lines
;
2988 /* Read in all partial symbtabs on which this one is dependent.
2989 NOTE that we do have circular dependencies, sigh. We solved
2990 that by setting pst->readin before this point. */
2992 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2993 if (!pst
->dependencies
[i
]->readin
)
2995 /* Inform about additional files to be read in. */
2998 fputs_filtered (" ", gdb_stdout
);
3000 fputs_filtered ("and ", gdb_stdout
);
3002 printf_filtered ("%s...",
3003 pst
->dependencies
[i
]->filename
);
3004 wrap_here (""); /* Flush output */
3005 gdb_flush (gdb_stdout
);
3007 /* We only pass the filename for debug purposes */
3008 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3009 pst
->dependencies
[i
]->filename
);
3012 /* Do nothing if this is a dummy psymtab. */
3014 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3015 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3018 /* Now read the symbols for this symtab */
3020 cur_bfd
= CUR_BFD (pst
);
3021 debug_swap
= DEBUG_SWAP (pst
);
3022 debug_info
= DEBUG_INFO (pst
);
3023 pending_list
= PENDING_LIST (pst
);
3024 external_sym_size
= debug_swap
->external_sym_size
;
3025 external_pdr_size
= debug_swap
->external_pdr_size
;
3026 swap_sym_in
= debug_swap
->swap_sym_in
;
3027 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3028 current_objfile
= pst
->objfile
;
3029 cur_fd
= FDR_IDX (pst
);
3030 fh
= ((cur_fd
== -1)
3032 : debug_info
->fdr
+ cur_fd
);
3035 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3036 processing_gcc_compilation
= 0;
3037 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3041 (*swap_sym_in
) (cur_bfd
,
3042 ((char *) debug_info
->external_sym
3043 + (fh
->isymBase
+ 1) * external_sym_size
),
3045 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3048 /* We indicate that this is a GCC compilation so that certain
3049 features will be enabled in stabsread/dbxread. */
3050 processing_gcc_compilation
= 2;
3054 if (processing_gcc_compilation
!= 0)
3059 unsigned long first_off
= 0;
3061 /* This symbol table contains stabs-in-ecoff entries. */
3063 /* Parse local symbols first */
3065 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3067 current_objfile
= NULL
;
3070 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3076 (*swap_sym_in
) (cur_bfd
,
3077 (((char *) debug_info
->external_sym
)
3078 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3080 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3082 if (ECOFF_IS_STAB (&sh
))
3084 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3086 /* We should never get non N_STAB symbols here, but they
3087 should be harmless, so keep process_one_symbol from
3088 complaining about them. */
3089 if (type_code
& N_STAB
)
3091 process_one_symbol (type_code
, 0, valu
, name
,
3092 pst
->section_offsets
, pst
->objfile
);
3094 if (type_code
== N_FUN
)
3096 /* Make up special symbol to contain
3097 procedure specific info */
3098 struct mips_extra_func_info
*e
=
3099 ((struct mips_extra_func_info
*)
3100 obstack_alloc (¤t_objfile
->symbol_obstack
,
3101 sizeof (struct mips_extra_func_info
)));
3102 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3103 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3104 SYMBOL_CLASS (s
) = LOC_CONST
;
3105 SYMBOL_TYPE (s
) = builtin_type_void
;
3106 SYMBOL_VALUE (s
) = (long) e
;
3107 add_symbol_to_list (s
, &local_symbols
);
3110 else if (sh
.st
== stLabel
)
3112 if (sh
.index
== indexNil
)
3114 /* This is what the gcc2_compiled and __gnu_compiled_*
3115 show up as. So don't complain. */
3119 /* Handle encoded stab line number. */
3120 record_line (current_subfile
, sh
.index
, valu
);
3122 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3123 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3124 /* These are generated by gcc-2.x, do not complain */
3127 complain (&stab_unknown_complaint
, name
);
3129 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
3132 /* Sort the symbol table now, we are done adding symbols to it.
3133 We must do this before parse_procedure calls lookup_symbol. */
3134 sort_symtab_syms (st
);
3136 /* There used to be a call to sort_blocks here, but this should not
3137 be necessary for stabs symtabs. And as sort_blocks modifies the
3138 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3139 it did the wrong thing if the first procedure in a file was
3140 generated via asm statements. */
3142 /* Fill in procedure info next. */
3144 pdr_ptr
= ((char *) debug_info
->external_pdr
3145 + fh
->ipdFirst
* external_pdr_size
);
3146 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3147 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
3151 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
3157 parse_procedure (&pr
, st
, first_off
, pst
);
3162 /* This symbol table contains ordinary ecoff entries. */
3164 /* FIXME: doesn't use pst->section_offsets. */
3170 /* How many symbols will we need */
3171 /* FIXME, this does not count enum values. */
3172 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
3176 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
3180 f_max
+= fh
->csym
+ fh
->cpd
;
3181 maxlines
= 2 * fh
->cline
;
3182 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
3184 /* The proper language was already determined when building
3185 the psymtab, use it. */
3186 st
->language
= PST_PRIVATE (pst
)->pst_language
;
3189 psymtab_language
= st
->language
;
3191 lines
= LINETABLE (st
);
3193 /* Get a new lexical context */
3195 push_parse_stack ();
3196 top_stack
->cur_st
= st
;
3197 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
3199 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
3200 BLOCK_END (top_stack
->cur_block
) = 0;
3201 top_stack
->blocktype
= stFile
;
3202 top_stack
->maxsyms
= 2 * f_max
;
3203 top_stack
->cur_type
= 0;
3204 top_stack
->procadr
= 0;
3205 top_stack
->numargs
= 0;
3212 /* Parse local symbols first */
3213 sym_ptr
= ((char *) debug_info
->external_sym
3214 + fh
->isymBase
* external_sym_size
);
3215 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
3216 while (sym_ptr
< sym_end
)
3221 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
3222 c
= parse_symbol (&sh
,
3223 debug_info
->external_aux
+ fh
->iauxBase
,
3224 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3225 sym_ptr
+= c
* external_sym_size
;
3228 /* Linenumbers. At the end, check if we can save memory.
3229 parse_lines has to look ahead an arbitrary number of PDR
3230 structures, so we swap them all first. */
3234 struct cleanup
*old_chain
;
3240 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3242 old_chain
= make_cleanup (free
, pr_block
);
3244 pdr_ptr
= ((char *) debug_info
->external_pdr
3245 + fh
->ipdFirst
* external_pdr_size
);
3246 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3250 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3251 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3253 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
);
3254 if (lines
->nitems
< fh
->cline
)
3255 lines
= shrink_linetable (lines
);
3257 /* Fill in procedure info next. */
3259 pdr_in_end
= pdr_in
+ fh
->cpd
;
3260 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3261 parse_procedure (pdr_in
, 0, pr_block
->adr
, pst
);
3263 do_cleanups (old_chain
);
3267 LINETABLE (st
) = lines
;
3269 /* .. and our share of externals.
3270 XXX use the global list to speed up things here. how?
3271 FIXME, Maybe quit once we have found the right number of ext's? */
3272 top_stack
->cur_st
= st
;
3273 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3275 top_stack
->blocktype
= stFile
;
3277 = (debug_info
->symbolic_header
.isymMax
3278 + debug_info
->symbolic_header
.ipdMax
3279 + debug_info
->symbolic_header
.iextMax
);
3281 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3282 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3283 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
);
3285 /* If there are undefined symbols, tell the user.
3286 The alpha has an undefined symbol for every symbol that is
3287 from a shared library, so tell the user only if verbose is on. */
3288 if (info_verbose
&& n_undef_symbols
)
3290 printf_filtered ("File %s contains %d unresolved references:",
3291 st
->filename
, n_undef_symbols
);
3292 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3293 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3294 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3301 /* Sort the symbol table now, we are done adding symbols to it.*/
3302 sort_symtab_syms (st
);
3307 /* Now link the psymtab and the symtab. */
3310 current_objfile
= NULL
;
3313 /* Ancillary parsing procedures. */
3315 /* Return 1 if the symbol pointed to by SH has a cross reference
3316 to an opaque aggregate type, else 0. */
3319 has_opaque_xref (fh
, sh
)
3328 if (sh
->index
== indexNil
)
3331 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
3332 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
3333 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
3337 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
3338 if (rn
->rfd
== 0xfff)
3339 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
3347 /* Lookup the type at relative index RN. Return it in TPP
3348 if found and in any event come up with its name PNAME.
3349 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3350 Return value says how many aux symbols we ate. */
3353 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3357 enum type_code type_code
; /* Use to alloc new type if none is found. */
3369 struct mdebug_pending
*pend
;
3371 *tpp
= (struct type
*)NULL
;
3373 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
3375 /* Escape index means 'the next one' */
3376 if (rn
->rfd
== 0xfff)
3379 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3386 /* mips cc uses a rf of -1 for opaque struct definitions.
3387 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3388 resolve them if the struct gets defined in another compilation unit. */
3391 *pname
= "<undefined>";
3392 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3393 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3397 /* mips cc uses an escaped rn->index of 0 for struct return types
3398 of procedures that were compiled without -g. These will always remain
3400 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3402 *pname
= "<undefined>";
3406 /* Find the relative file descriptor and the symbol in it. */
3407 fh
= get_rfd (fd
, rf
);
3408 xref_fd
= fh
- debug_info
->fdr
;
3410 if (rn
->index
>= fh
->csym
)
3412 /* File indirect entry is corrupt. */
3413 *pname
= "<illegal>";
3414 complain (&bad_rfd_entry_complaint
,
3415 sym_name
, xref_fd
, rn
->index
);
3419 /* If we have processed this symbol then we left a forwarding
3420 pointer to the type in the pending list. If not, we`ll put
3421 it in a list of pending types, to be processed later when
3422 the file will be. In any event, we collect the name for the
3425 esh
= ((char *) debug_info
->external_sym
3426 + ((fh
->isymBase
+ rn
->index
)
3427 * debug_swap
->external_sym_size
));
3428 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3430 /* Make sure that this type of cross reference can be handled. */
3431 if ((sh
.sc
!= scInfo
3432 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
3433 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3434 && sh
.st
!= stEnum
))
3435 && (sh
.st
!= stBlock
|| (sh
.sc
!= scCommon
&& sh
.sc
!= scSCommon
)))
3437 /* File indirect entry is corrupt. */
3438 *pname
= "<illegal>";
3439 complain (&bad_rfd_entry_complaint
,
3440 sym_name
, xref_fd
, rn
->index
);
3444 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3446 pend
= is_pending_symbol (fh
, esh
);
3451 /* We have not yet seen this type. */
3453 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
3457 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3459 a) forward declarations of structs/unions/enums which are not
3460 defined in this compilation unit.
3461 For these the type will be void. This is a bad design decision
3462 as cross referencing across compilation units is impossible
3463 due to the missing name.
3464 b) forward declarations of structs/unions/enums which are defined
3465 later in this file or in another file in the same compilation
3466 unit. Irix5 cc uses a stIndirect symbol for this.
3467 Simply cross reference those again to get the true type.
3468 The forward references are not entered in the pending list and
3469 in the symbol table. */
3471 (*debug_swap
->swap_tir_in
) (bigend
,
3472 &(debug_info
->external_aux
3473 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3475 if (tir
.tq0
!= tqNil
)
3476 complain (&illegal_forward_tq0_complaint
, sym_name
);
3480 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3482 *pname
= "<undefined>";
3489 (debug_info
->external_aux
3490 + fh
->iauxBase
+ sh
.index
+ 1),
3491 tpp
, type_code
, pname
,
3492 fh
->fBigendian
, sym_name
);
3496 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3497 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3503 else if (sh
.st
== stTypedef
)
3505 /* Parse the type for a normal typedef. This might recursively call
3506 cross_ref till we get a non typedef'ed type.
3507 FIXME: This is not correct behaviour, but gdb currently
3508 cannot handle typedefs without type copying. But type copying is
3509 impossible as we might have mutual forward references between
3510 two files and the copied type would not get filled in when
3511 we later parse its definition. */
3512 *tpp
= parse_type (xref_fd
,
3513 debug_info
->external_aux
+ fh
->iauxBase
,
3517 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3521 /* Cross reference to a struct/union/enum which is defined
3522 in another file in the same compilation unit but that file
3523 has not been parsed yet.
3524 Initialize the type only, it will be filled in when
3525 it's definition is parsed. */
3526 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3528 add_pending (fh
, esh
, *tpp
);
3531 /* We used one auxent normally, two if we got a "next one" rf. */
3536 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3537 keeping the symtab sorted */
3539 static struct symbol
*
3540 mylookup_symbol (name
, block
, namespace, class)
3542 register struct block
*block
;
3543 enum namespace namespace;
3544 enum address_class
class;
3546 register int bot
, top
, inc
;
3547 register struct symbol
*sym
;
3550 top
= BLOCK_NSYMS (block
);
3554 sym
= BLOCK_SYM (block
, bot
);
3555 if (SYMBOL_NAME (sym
)[0] == inc
3556 && SYMBOL_NAMESPACE (sym
) == namespace
3557 && SYMBOL_CLASS (sym
) == class
3558 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3562 block
= BLOCK_SUPERBLOCK (block
);
3564 return mylookup_symbol (name
, block
, namespace, class);
3569 /* Add a new symbol S to a block B.
3570 Infrequently, we will need to reallocate the block to make it bigger.
3571 We only detect this case when adding to top_stack->cur_block, since
3572 that's the only time we know how big the block is. FIXME. */
3579 int nsyms
= BLOCK_NSYMS (b
)++;
3580 struct block
*origb
;
3581 struct parse_stack
*stackp
;
3583 if (b
== top_stack
->cur_block
&&
3584 nsyms
>= top_stack
->maxsyms
)
3586 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3587 /* In this case shrink_block is actually grow_block, since
3588 BLOCK_NSYMS(b) is larger than its current size. */
3590 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3592 /* Now run through the stack replacing pointers to the
3593 original block. shrink_block has already done this
3594 for the blockvector and BLOCK_FUNCTION. */
3595 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3597 if (stackp
->cur_block
== origb
)
3599 stackp
->cur_block
= b
;
3600 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3604 BLOCK_SYM (b
, nsyms
) = s
;
3607 /* Add a new block B to a symtab S */
3614 struct blockvector
*bv
= BLOCKVECTOR (s
);
3616 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3617 (sizeof (struct blockvector
)
3618 + BLOCKVECTOR_NBLOCKS (bv
)
3619 * sizeof (bv
->block
)));
3620 if (bv
!= BLOCKVECTOR (s
))
3621 BLOCKVECTOR (s
) = bv
;
3623 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3626 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3627 MIPS' linenumber encoding might need more than one byte
3628 to describe it, LAST is used to detect these continuation lines.
3630 Combining lines with the same line number seems like a bad idea.
3631 E.g: There could be a line number entry with the same line number after the
3632 prologue and GDB should not ignore it (this is a better way to find
3633 a prologue than mips_skip_prologue).
3634 But due to the compressed line table format there are line number entries
3635 for the same line which are needed to bridge the gap to the next
3636 line number entry. These entries have a bogus address info with them
3637 and we are unable to tell them from intended duplicate line number
3639 This is another reason why -ggdb debugging format is preferable. */
3642 add_line (lt
, lineno
, adr
, last
)
3643 struct linetable
*lt
;
3648 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3649 Change them to something sensible. */
3653 last
= -2; /* make sure we record first line */
3655 if (last
== lineno
) /* skip continuation lines */
3658 lt
->item
[lt
->nitems
].line
= lineno
;
3659 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3663 /* Sorting and reordering procedures */
3665 /* Blocks with a smaller low bound should come first */
3668 compare_blocks (arg1
, arg2
)
3672 register int addr_diff
;
3673 struct block
**b1
= (struct block
**) arg1
;
3674 struct block
**b2
= (struct block
**) arg2
;
3676 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3678 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3682 /* Sort the blocks of a symtab S.
3683 Reorder the blocks in the blockvector by code-address,
3684 as required by some MI search routines */
3690 struct blockvector
*bv
= BLOCKVECTOR (s
);
3692 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3695 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3696 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3697 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3698 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3702 * This is very unfortunate: normally all functions are compiled in
3703 * the order they are found, but if the file is compiled -O3 things
3704 * are very different. It would be nice to find a reliable test
3705 * to detect -O3 images in advance.
3707 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3708 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3709 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3710 sizeof (struct block
*),
3714 register CORE_ADDR high
= 0;
3715 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3717 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3718 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3719 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3720 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3723 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3724 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3726 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3727 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3728 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3729 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3733 /* Constructor/restructor/destructor procedures */
3735 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3736 MAXSYMS and linenumbers MAXLINES we'll put in it */
3738 static struct symtab
*
3739 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3743 struct objfile
*objfile
;
3745 struct symtab
*s
= allocate_symtab (name
, objfile
);
3747 LINETABLE (s
) = new_linetable (maxlines
);
3749 /* All symtabs must have at least two blocks */
3750 BLOCKVECTOR (s
) = new_bvect (2);
3751 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3752 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3753 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3754 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3756 s
->free_code
= free_linetable
;
3761 /* Allocate a new partial_symtab NAME */
3763 static struct partial_symtab
*
3764 new_psymtab (name
, objfile
, section_offsets
)
3766 struct objfile
*objfile
;
3767 struct section_offsets
*section_offsets
;
3769 struct partial_symtab
*psymtab
;
3771 psymtab
= allocate_psymtab (name
, objfile
);
3772 psymtab
->section_offsets
= section_offsets
;
3774 /* Keep a backpointer to the file's symbols */
3776 psymtab
->read_symtab_private
= ((char *)
3777 obstack_alloc (&objfile
->psymbol_obstack
,
3778 sizeof (struct symloc
)));
3779 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3780 CUR_BFD (psymtab
) = cur_bfd
;
3781 DEBUG_SWAP (psymtab
) = debug_swap
;
3782 DEBUG_INFO (psymtab
) = debug_info
;
3783 PENDING_LIST (psymtab
) = pending_list
;
3785 /* The way to turn this into a symtab is to call... */
3786 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3791 /* Allocate a linetable array of the given SIZE. Since the struct
3792 already includes one item, we subtract one when calculating the
3793 proper size to allocate. */
3795 static struct linetable
*
3796 new_linetable (size
)
3799 struct linetable
*l
;
3801 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3802 l
= (struct linetable
*) xmalloc (size
);
3807 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3808 I am not so sure about the 3.4 ones.
3810 Since the struct linetable already includes one item, we subtract one when
3811 calculating the proper size to allocate. */
3813 static struct linetable
*
3814 shrink_linetable (lt
)
3815 struct linetable
*lt
;
3818 return (struct linetable
*) xrealloc ((PTR
) lt
,
3819 (sizeof (struct linetable
)
3821 * sizeof (lt
->item
))));
3824 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3826 static struct blockvector
*
3830 struct blockvector
*bv
;
3833 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3834 bv
= (struct blockvector
*) xzalloc (size
);
3836 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3841 /* Allocate and zero a new block of MAXSYMS symbols */
3843 static struct block
*
3847 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3849 return (struct block
*) xzalloc (size
);
3852 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3853 Shrink_block can also be used by add_symbol to grow a block. */
3855 static struct block
*
3861 struct blockvector
*bv
= BLOCKVECTOR (s
);
3864 /* Just reallocate it and fix references to the old one */
3866 new = (struct block
*) xrealloc ((PTR
) b
,
3867 (sizeof (struct block
)
3868 + ((BLOCK_NSYMS (b
) - 1)
3869 * sizeof (struct symbol
*))));
3871 /* Should chase pointers to old one. Fortunately, that`s just
3872 the block`s function and inferior blocks */
3873 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3874 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3875 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3876 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3877 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3878 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3879 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3883 /* Create a new symbol with printname NAME */
3885 static struct symbol
*
3889 struct symbol
*s
= ((struct symbol
*)
3890 obstack_alloc (¤t_objfile
->symbol_obstack
,
3891 sizeof (struct symbol
)));
3893 memset ((PTR
) s
, 0, sizeof (*s
));
3894 SYMBOL_NAME (s
) = name
;
3895 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3896 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3900 /* Create a new type with printname NAME */
3902 static struct type
*
3908 t
= alloc_type (current_objfile
);
3909 TYPE_NAME (t
) = name
;
3910 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3914 /* Read ECOFF debugging information from a BFD section. This is
3915 called from elfread.c. It parses the section into a
3916 ecoff_debug_info struct, and then lets the rest of the file handle
3920 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3921 struct objfile
*objfile
;
3922 const struct ecoff_debug_swap
*swap
;
3924 struct section_offsets
*section_offsets
;
3926 bfd
*abfd
= objfile
->obfd
;
3927 struct ecoff_debug_info
*info
;
3929 info
= ((struct ecoff_debug_info
*)
3930 obstack_alloc (&objfile
->psymbol_obstack
,
3931 sizeof (struct ecoff_debug_info
)));
3933 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
3934 error ("Error reading ECOFF debugging information: %s",
3935 bfd_errmsg (bfd_get_error ()));
3937 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3941 /* Things used for calling functions in the inferior.
3942 These functions are exported to our companion
3943 mips-tdep.c file and are here because they play
3944 with the symbol-table explicitly. */
3946 /* Sigtramp: make sure we have all the necessary information
3947 about the signal trampoline code. Since the official code
3948 from MIPS does not do so, we make up that information ourselves.
3949 If they fix the library (unlikely) this code will neutralize itself. */
3951 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3952 here because it calls functions defined in this file, but perhaps
3953 this could be handled in a better way. */
3960 struct block
*b
, *b0
= NULL
;
3962 sigtramp_address
= -1;
3964 /* We have to handle the following cases here:
3965 a) The Mips library has a sigtramp label within sigvec.
3966 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3967 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3970 b0
= SYMBOL_BLOCK_VALUE (s
);
3971 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3975 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3976 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3979 /* But maybe this program uses its own version of sigvec */
3983 /* Did we or MIPSco fix the library ? */
3984 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3986 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3987 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3991 sigtramp_address
= SYMBOL_VALUE (s
);
3992 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3994 /* But what symtab does it live in ? */
3995 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3998 * Ok, there goes the fix: turn it into a procedure, with all the
3999 * needed info. Note we make it a nested procedure of sigvec,
4000 * which is the way the (assembly) code is actually written.
4002 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4003 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4004 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4006 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
4008 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4010 SYMBOL_BLOCK_VALUE (s
) = b
;
4011 BLOCK_START (b
) = sigtramp_address
;
4012 BLOCK_END (b
) = sigtramp_end
;
4013 BLOCK_FUNCTION (b
) = s
;
4014 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4018 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4020 struct mips_extra_func_info
*e
=
4021 ((struct mips_extra_func_info
*)
4022 xzalloc (sizeof (struct mips_extra_func_info
)));
4024 e
->numargs
= 0; /* the kernel thinks otherwise */
4025 e
->pdr
.frameoffset
= 32;
4026 e
->pdr
.framereg
= SP_REGNUM
;
4027 /* Note that setting pcreg is no longer strictly necessary as
4028 mips_frame_saved_pc is now aware of signal handler frames. */
4029 e
->pdr
.pcreg
= PC_REGNUM
;
4030 e
->pdr
.regmask
= -2;
4031 /* Offset to saved r31, in the sigtramp case the saved registers
4032 are above the frame in the sigcontext.
4033 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4034 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4035 and 32 * 4 bytes for the floating point registers. */
4036 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4037 e
->pdr
.fregmask
= -1;
4038 /* Offset to saved f30 (first saved *double* register). */
4039 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4040 e
->pdr
.isym
= (long) s
;
4041 e
->pdr
.adr
= sigtramp_address
;
4043 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4044 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4045 SYMBOL_VALUE (s
) = (long) e
;
4046 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4047 SYMBOL_CLASS (s
) = LOC_CONST
;
4048 SYMBOL_TYPE (s
) = builtin_type_void
;
4049 current_objfile
= NULL
;
4052 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4056 _initialize_mdebugread ()
4058 /* Missing basic types */
4060 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4062 mdebug_type_string
=
4063 init_type (TYPE_CODE_STRING
,
4064 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4066 (struct objfile
*) NULL
);
4068 mdebug_type_complex
=
4069 init_type (TYPE_CODE_ERROR
,
4070 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
4072 (struct objfile
*) NULL
);
4073 mdebug_type_double_complex
=
4074 init_type (TYPE_CODE_ERROR
,
4075 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
4076 0, "double complex",
4077 (struct objfile
*) NULL
);
4079 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4080 good? Would we be better off with TYPE_CODE_ERROR? Should
4081 TYPE_CODE_ERROR print things in hex if it knows the size? */
4082 mdebug_type_fixed_dec
=
4083 init_type (TYPE_CODE_INT
,
4084 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4086 (struct objfile
*) NULL
);
4088 mdebug_type_float_dec
=
4089 init_type (TYPE_CODE_ERROR
,
4090 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4091 0, "floating decimal",
4092 (struct objfile
*) NULL
);