X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fmdebugread.c;h=d4aebc4bab961f17bf35669d20284047da04db67;hb=41989fcd807079207bf6a6ed39eb72ff4f3087eb;hp=325afabbfce4cb3a020ed413cea664e919906a3f;hpb=899c402166e46e5b16b3e668d2b947b12a682136;p=platform%2Fupstream%2Fbinutils.git diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index 325afab..d4aebc4 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1,25 +1,27 @@ /* Read a symbol table in ECOFF format (Third-Eye). - Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 1997 + Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. Original version contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ /* This module provides the function mdebug_build_psymtabs. It reads ECOFF debugging information into partial symbol tables. The @@ -45,24 +47,29 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "gdbcore.h" #include "symfile.h" #include "objfiles.h" -#include "obstack.h" +#include "gdb_obstack.h" #include "buildsym.h" #include "stabsread.h" #include "complaints.h" #include "demangle.h" +#include "gdb_assert.h" +#include "block.h" +#include "dictionary.h" /* These are needed if the tm.h file does not contain the necessary mips specific definitions. */ #ifndef MIPS_EFI_SYMBOL_NAME #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__" -extern void ecoff_relocate_efi PARAMS ((struct symbol *, CORE_ADDR)); +extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR); #include "coff/sym.h" #include "coff/symconst.h" -typedef struct mips_extra_func_info { - long numargs; - PDR pdr; -} *mips_extra_func_info_t; +typedef struct mips_extra_func_info + { + long numargs; + PDR pdr; + } + *mips_extra_func_info_t; #ifndef RA_REGNUM #define RA_REGNUM 0 #endif @@ -75,8 +82,6 @@ typedef struct mips_extra_func_info { #include "gdb_stat.h" #include "gdb_string.h" -#include "gdb-stabs.h" - #include "bfd.h" #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */ @@ -86,31 +91,36 @@ typedef struct mips_extra_func_info { #include "aout/stab_gnu.h" /* STABS information */ #include "expression.h" -#include "language.h" /* Needed inside partial-stab.h */ +#include "language.h" /* For local_hex_string() */ -/* Provide a default mapping from a ecoff register number to a gdb REGNUM. */ -#ifndef ECOFF_REG_TO_REGNUM -#define ECOFF_REG_TO_REGNUM(num) (num) -#endif +extern void _initialize_mdebugread (void); + +/* Provide a way to test if we have both ECOFF and ELF symbol tables. + We use this define in order to know whether we should override a + symbol's ECOFF section with its ELF section. This is necessary in + case the symbol's ELF section could not be represented in ECOFF. */ +#define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ + && bfd_get_section_by_name (bfd, ".mdebug") != NULL) + /* We put a pointer to this structure in the read_symtab_private field of the psymtab. */ struct symloc -{ - /* Index of the FDR that this psymtab represents. */ - int fdr_idx; - /* The BFD that the psymtab was created from. */ - bfd *cur_bfd; - const struct ecoff_debug_swap *debug_swap; - struct ecoff_debug_info *debug_info; - struct mdebug_pending **pending_list; - /* Pointer to external symbols for this file. */ - EXTR *extern_tab; - /* Size of extern_tab. */ - int extern_count; - enum language pst_language; -}; + { + /* Index of the FDR that this psymtab represents. */ + int fdr_idx; + /* The BFD that the psymtab was created from. */ + bfd *cur_bfd; + const struct ecoff_debug_swap *debug_swap; + struct ecoff_debug_info *debug_info; + struct mdebug_pending **pending_list; + /* Pointer to external symbols for this file. */ + EXTR *extern_tab; + /* Size of extern_tab. */ + int extern_count; + enum language pst_language; + }; #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private) #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx) @@ -118,102 +128,59 @@ struct symloc #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap) #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info) #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list) - -/* Things we import explicitly from other modules */ - -extern int info_verbose; +#define SC_IS_TEXT(sc) ((sc) == scText \ + || (sc) == scRConst \ + || (sc) == scInit \ + || (sc) == scFini) +#define SC_IS_DATA(sc) ((sc) == scData \ + || (sc) == scSData \ + || (sc) == scRData \ + || (sc) == scPData \ + || (sc) == scXData) +#define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon) +#define SC_IS_BSS(sc) ((sc) == scBss) +#define SC_IS_SBSS(sc) ((sc) == scSBss) +#define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined) + /* Various complaints about symbol reading that don't abort the process */ +static void +index_complaint (const char *arg1) +{ + complaint (&symfile_complaints, "bad aux index at symbol %s", arg1); +} -static struct complaint bad_file_number_complaint = -{"bad file number %d", 0, 0}; - -static struct complaint index_complaint = -{"bad aux index at symbol %s", 0, 0}; - -static struct complaint aux_index_complaint = -{"bad proc end in aux found from symbol %s", 0, 0}; - -static struct complaint block_index_complaint = -{"bad aux index at block symbol %s", 0, 0}; - -static struct complaint unknown_ext_complaint = -{"unknown external symbol %s", 0, 0}; - -static struct complaint unknown_sym_complaint = -{"unknown local symbol %s", 0, 0}; - -static struct complaint unknown_st_complaint = -{"with type %d", 0, 0}; - -static struct complaint block_overflow_complaint = -{"block containing %s overfilled", 0, 0}; - -static struct complaint basic_type_complaint = -{"cannot map ECOFF basic type 0x%x for %s", 0, 0}; - -static struct complaint unknown_type_qual_complaint = -{"unknown type qualifier 0x%x", 0, 0}; - -static struct complaint array_index_type_complaint = -{"illegal array index type for %s, assuming int", 0, 0}; - -static struct complaint bad_tag_guess_complaint = -{"guessed tag type of %s incorrectly", 0, 0}; - -static struct complaint block_member_complaint = -{"declaration block contains unhandled symbol type %d", 0, 0}; - -static struct complaint stEnd_complaint = -{"stEnd with storage class %d not handled", 0, 0}; - -static struct complaint unknown_mdebug_symtype_complaint = -{"unknown symbol type 0x%x", 0, 0}; - -static struct complaint stab_unknown_complaint = -{"unknown stabs symbol %s", 0, 0}; - -static struct complaint pdr_for_nonsymbol_complaint = -{"PDR for %s, but no symbol", 0, 0}; - -static struct complaint pdr_static_symbol_complaint = -{"can't handle PDR for static proc at 0x%lx", 0, 0}; - -static struct complaint bad_setjmp_pdr_complaint = -{"fixing bad setjmp PDR from libc", 0, 0}; - -static struct complaint bad_fbitfield_complaint = -{"can't handle TIR fBitfield for %s", 0, 0}; - -static struct complaint bad_continued_complaint = -{"illegal TIR continued for %s", 0, 0}; - -static struct complaint bad_rfd_entry_complaint = -{"bad rfd entry for %s: file %d, index %d", 0, 0}; - -static struct complaint unexpected_type_code_complaint = -{"unexpected type code for %s", 0, 0}; - -static struct complaint unable_to_cross_ref_complaint = -{"unable to cross ref btTypedef for %s", 0, 0}; - -static struct complaint bad_indirect_xref_complaint = -{"unable to cross ref btIndirect for %s", 0, 0}; - -static struct complaint illegal_forward_tq0_complaint = -{"illegal tq0 in forward typedef for %s", 0, 0}; +static void +unknown_ext_complaint (const char *arg1) +{ + complaint (&symfile_complaints, "unknown external symbol %s", arg1); +} -static struct complaint illegal_forward_bt_complaint = -{"illegal bt %d in forward typedef for %s", 0, 0}; +static void +basic_type_complaint (int arg1, const char *arg2) +{ + complaint (&symfile_complaints, "cannot map ECOFF basic type 0x%x for %s", + arg1, arg2); +} -static struct complaint bad_linetable_guess_complaint = -{"guessed size of linetable for %s incorrectly", 0, 0}; +static void +bad_tag_guess_complaint (const char *arg1) +{ + complaint (&symfile_complaints, "guessed tag type of %s incorrectly", arg1); +} -static struct complaint bad_ext_ifd_complaint = -{"bad ifd for external symbol: %d (max %d)", 0, 0}; +static void +bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3) +{ + complaint (&symfile_complaints, "bad rfd entry for %s: file %d, index %d", + arg1, arg2, arg3); +} -static struct complaint bad_ext_iss_complaint = -{"bad iss for external symbol: %ld (max %ld)", 0, 0}; +static void +unexpected_type_code_complaint (const char *arg1) +{ + complaint (&symfile_complaints, "unexpected type code for %s", arg1); +} /* Macros and extra defs */ @@ -304,104 +271,54 @@ static int found_ecoff_debugging_info; /* Forward declarations */ -static void -add_pending PARAMS ((FDR *, char *, struct type *)); +static int upgrade_type (int, struct type **, int, union aux_ext *, + int, char *); -static struct mdebug_pending * -is_pending_symbol PARAMS ((FDR *, char *)); +static void parse_partial_symbols (struct objfile *); -static void -pop_parse_stack PARAMS ((void)); +static int has_opaque_xref (FDR *, SYMR *); -static void -push_parse_stack PARAMS ((void)); +static int cross_ref (int, union aux_ext *, struct type **, enum type_code, + char **, int, char *); -static char * -fdr_name PARAMS ((FDR *)); +static struct symbol *new_symbol (char *); -static void -mdebug_psymtab_to_symtab PARAMS ((struct partial_symtab *)); +static struct type *new_type (char *); -static int -upgrade_type PARAMS ((int, struct type **, int, union aux_ext *, int, char *)); +enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK }; -static void -parse_partial_symbols PARAMS ((struct objfile *, - struct section_offsets *)); +static struct block *new_block (enum block_type); -static FDR -*get_rfd PARAMS ((int, int)); +static struct symtab *new_symtab (char *, int, struct objfile *); -static int -has_opaque_xref PARAMS ((FDR *, SYMR *)); +static struct linetable *new_linetable (int); -static int -cross_ref PARAMS ((int, union aux_ext *, struct type **, enum type_code, - char **, int, char *)); +static struct blockvector *new_bvect (int); -static struct symbol * -new_symbol PARAMS ((char *)); +static struct type *parse_type (int, union aux_ext *, unsigned int, int *, + int, char *); -static struct type * -new_type PARAMS ((char *)); - -static struct block * -new_block PARAMS ((int)); - -static struct symtab * -new_symtab PARAMS ((char *, int, int, struct objfile *)); - -static struct linetable * -new_linetable PARAMS ((int)); - -static struct blockvector * -new_bvect PARAMS ((int)); - -static int -parse_symbol PARAMS ((SYMR *, union aux_ext *, char *, int, struct section_offsets *)); - -static struct type * -parse_type PARAMS ((int, union aux_ext *, unsigned int, int *, int, char *)); - -static struct symbol * -mylookup_symbol PARAMS ((char *, struct block *, namespace_enum, - enum address_class)); - -static struct block * -shrink_block PARAMS ((struct block *, struct symtab *)); +static struct symbol *mylookup_symbol (char *, struct block *, domain_enum, + enum address_class); -static PTR -xzalloc PARAMS ((unsigned int)); +static void sort_blocks (struct symtab *); -static void -sort_blocks PARAMS ((struct symtab *)); +static struct partial_symtab *new_psymtab (char *, struct objfile *); -static int -compare_blocks PARAMS ((const void *, const void *)); +static void psymtab_to_symtab_1 (struct partial_symtab *, char *); -static struct partial_symtab * -new_psymtab PARAMS ((char *, struct objfile *, struct section_offsets *)); +static void add_block (struct block *, struct symtab *); -static void -psymtab_to_symtab_1 PARAMS ((struct partial_symtab *, char *)); +static void add_symbol (struct symbol *, struct block *); -static void -add_block PARAMS ((struct block *, struct symtab *)); +static int add_line (struct linetable *, int, CORE_ADDR, int); -static void -add_symbol PARAMS ((struct symbol *, struct block *)); - -static int -add_line PARAMS ((struct linetable *, int, CORE_ADDR, int)); +static struct linetable *shrink_linetable (struct linetable *); -static struct linetable * -shrink_linetable PARAMS ((struct linetable *)); +static void handle_psymbol_enumerators (struct objfile *, FDR *, int, + CORE_ADDR); -static void -handle_psymbol_enumerators PARAMS ((struct objfile *, FDR *, int, CORE_ADDR)); - -static char * -mdebug_next_symbol_text PARAMS ((struct objfile *)); +static char *mdebug_next_symbol_text (struct objfile *); /* Address bounds for the signal trampoline in inferior, if any */ @@ -409,11 +326,10 @@ CORE_ADDR sigtramp_address, sigtramp_end; /* Allocate zeroed memory */ -static PTR -xzalloc (size) - unsigned int size; +static void * +xzalloc (unsigned int size) { - PTR p = xmalloc (size); + void *p = xmalloc (size); memset (p, 0, size); return p; @@ -425,8 +341,7 @@ xzalloc (size) and reorders the symtab list at the end */ static void -mdebug_psymtab_to_symtab (pst) - struct partial_symtab *pst; +mdebug_psymtab_to_symtab (struct partial_symtab *pst) { if (!pst) @@ -455,11 +370,10 @@ mdebug_psymtab_to_symtab (pst) /* Find a file descriptor given its index RF relative to a file CF */ static FDR * -get_rfd (cf, rf) - int cf, rf; +get_rfd (int cf, int rf) { FDR *fdrs; - register FDR *f; + FDR *f; RFDT rfd; fdrs = debug_info->fdr; @@ -468,18 +382,17 @@ get_rfd (cf, rf) if (f->rfdBase == 0) return fdrs + rf; (*debug_swap->swap_rfd_in) (cur_bfd, - ((char *) debug_info->external_rfd - + ((f->rfdBase + rf) - * debug_swap->external_rfd_size)), - &rfd); + ((char *) debug_info->external_rfd + + ((f->rfdBase + rf) + * debug_swap->external_rfd_size)), + &rfd); return fdrs + rfd; } /* Return a safer print NAME for a file descriptor */ static char * -fdr_name (f) - FDR *f; +fdr_name (FDR *f) { if (f->rss == -1) return ""; @@ -493,16 +406,19 @@ fdr_name (f) different sections are relocated via the SECTION_OFFSETS. */ void -mdebug_build_psymtabs (objfile, swap, info, section_offsets) - struct objfile *objfile; - const struct ecoff_debug_swap *swap; - struct ecoff_debug_info *info; - struct section_offsets *section_offsets; +mdebug_build_psymtabs (struct objfile *objfile, + const struct ecoff_debug_swap *swap, + struct ecoff_debug_info *info) { cur_bfd = objfile->obfd; debug_swap = swap; debug_info = info; + stabsread_new_init (); + buildsym_new_init (); + free_header_files (); + init_header_files (); + /* Make sure all the FDR information is swapped in. */ if (info->fdr == (FDR *) NULL) { @@ -521,7 +437,7 @@ mdebug_build_psymtabs (objfile, swap, info, section_offsets) (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr); } - parse_partial_symbols (objfile, section_offsets); + parse_partial_symbols (objfile); #if 0 /* Check to make sure file was compiled with -g. If not, warn the @@ -530,7 +446,7 @@ mdebug_build_psymtabs (objfile, swap, info, section_offsets) { if (max_gdbinfo == 0) printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n", - objfile->name); + objfile->name); printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n"); gdb_flush (gdb_stdout); } @@ -555,25 +471,24 @@ struct pst_map after use. */ static struct parse_stack -{ - struct parse_stack *next, *prev; - struct symtab *cur_st; /* Current symtab. */ - struct block *cur_block; /* Block in it. */ - - /* What are we parsing. stFile, or stBlock are for files and - blocks. stProc or stStaticProc means we have seen the start of a - procedure, but not the start of the block within in. When we see - the start of that block, we change it to stNil, without pushing a - new block, i.e. stNil means both a procedure and a block. */ - - int blocktype; - - int maxsyms; /* Max symbols in this block. */ - struct type *cur_type; /* Type we parse fields for. */ - int cur_field; /* Field number in cur_type. */ - CORE_ADDR procadr; /* Start addres of this procedure */ - int numargs; /* Its argument count */ -} + { + struct parse_stack *next, *prev; + struct symtab *cur_st; /* Current symtab. */ + struct block *cur_block; /* Block in it. */ + + /* What are we parsing. stFile, or stBlock are for files and + blocks. stProc or stStaticProc means we have seen the start of a + procedure, but not the start of the block within in. When we see + the start of that block, we change it to stNil, without pushing a + new block, i.e. stNil means both a procedure and a block. */ + + int blocktype; + + struct type *cur_type; /* Type we parse fields for. */ + int cur_field; /* Field number in cur_type. */ + CORE_ADDR procadr; /* Start addres of this procedure */ + int numargs; /* Its argument count */ + } *top_stack; /* Top stack ptr */ @@ -581,7 +496,7 @@ static struct parse_stack /* Enter a new lexical context */ static void -push_parse_stack () +push_parse_stack (void) { struct parse_stack *new; @@ -593,7 +508,7 @@ push_parse_stack () /* Initialize new frame with previous content */ if (top_stack) { - register struct parse_stack *prev = new->prev; + struct parse_stack *prev = new->prev; *new = *top_stack; top_stack->prev = new; @@ -606,7 +521,7 @@ push_parse_stack () /* Exit a lexical context */ static void -pop_parse_stack () +pop_parse_stack (void) { if (!top_stack) return; @@ -640,12 +555,10 @@ static struct mdebug_pending **pending_list; /* Check whether we already saw symbol SH in file FH */ static struct mdebug_pending * -is_pending_symbol (fh, sh) - FDR *fh; - char *sh; +is_pending_symbol (FDR *fh, char *sh) { int f_idx = fh - debug_info->fdr; - register struct mdebug_pending *p; + struct mdebug_pending *p; /* Linear search is ok, list is typically no more than 10 deep */ for (p = pending_list[f_idx]; p; p = p->next) @@ -657,10 +570,7 @@ is_pending_symbol (fh, sh) /* Add a new symbol SH of type T */ static void -add_pending (fh, sh, t) - FDR *fh; - char *sh; - struct type *t; +add_pending (FDR *fh, char *sh, struct type *t) { int f_idx = fh - debug_info->fdr; struct mdebug_pending *p = is_pending_symbol (fh, sh); @@ -691,16 +601,11 @@ add_pending (fh, sh, t) SYMR's handled (normally one). */ static int -parse_symbol (sh, ax, ext_sh, bigend, section_offsets) - SYMR *sh; - union aux_ext *ax; - char *ext_sh; - int bigend; - struct section_offsets *section_offsets; +parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, + struct section_offsets *section_offsets, struct objfile *objfile) { const bfd_size_type external_sym_size = debug_swap->external_sym_size; - void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) = - debug_swap->swap_sym_in; + void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; char *name; struct symbol *s; struct block *b; @@ -723,23 +628,23 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case scText: case scRConst: /* Do not relocate relative values. - The value of a stEnd symbol is the displacement from the - corresponding start symbol value. - The value of a stBlock symbol is the displacement from the - procedure address. */ + The value of a stEnd symbol is the displacement from the + corresponding start symbol value. + The value of a stBlock symbol is the displacement from the + procedure address. */ if (sh->st != stEnd && sh->st != stBlock) - sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT); + sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); break; case scData: case scSData: case scRData: case scPData: case scXData: - sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA); + sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); break; case scBss: case scSBss: - sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS); + sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile)); break; } @@ -760,12 +665,12 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) class = LOC_STATIC; b = top_stack->cur_block; s = new_symbol (name); - if (sh->sc == scCommon || sh->sc == scSCommon) + if (SC_IS_COMMON (sh->sc)) { /* It is a FORTRAN common block. At least for SGI Fortran the address is not in the symbol; we need to fix it later in scan_file_globals. */ - int bucket = hashname (SYMBOL_NAME (s)); + int bucket = hashname (DEPRECATED_SYMBOL_NAME (s)); SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket]; global_sym_chain[bucket] = s; } @@ -786,12 +691,12 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) SYMBOL_VALUE (s) = svalue; data: /* Common code for symbols describing data */ - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = class; add_symbol (s, b); /* Type could be missing if file is compiled without debugging info. */ - if (sh->sc == scUndefined || sh->sc == scSUndefined + if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil || sh->index == indexNil) SYMBOL_TYPE (s) = nodebug_var_symbol_type; else @@ -809,26 +714,26 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) name = "this"; /* FIXME, not alloc'd in obstack */ s = new_symbol (name); - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; switch (sh->sc) { case scRegister: /* Pass by value in register. */ - SYMBOL_CLASS(s) = LOC_REGPARM; + SYMBOL_CLASS (s) = LOC_REGPARM; svalue = ECOFF_REG_TO_REGNUM (svalue); break; case scVar: /* Pass by reference on stack. */ - SYMBOL_CLASS(s) = LOC_REF_ARG; + SYMBOL_CLASS (s) = LOC_REF_ARG; break; case scVarRegister: /* Pass by reference in register. */ - SYMBOL_CLASS(s) = LOC_REGPARM_ADDR; + SYMBOL_CLASS (s) = LOC_REGPARM_ADDR; svalue = ECOFF_REG_TO_REGNUM (svalue); break; default: /* Pass by value on stack. */ - SYMBOL_CLASS(s) = LOC_ARG; + SYMBOL_CLASS (s) = LOC_ARG; break; } SYMBOL_VALUE (s) = svalue; @@ -838,7 +743,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case stLabel: /* label, goes into current block */ s = new_symbol (name); - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */ + SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* so that it can be used */ SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */ SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; SYMBOL_TYPE (s) = mdebug_type_int; @@ -847,27 +752,59 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case stProc: /* Procedure, usually goes into global block */ case stStaticProc: /* Static procedure, goes into current block */ + /* For stProc symbol records, we need to check the storage class + as well, as only (stProc, scText) entries represent "real" + procedures - See the Compaq document titled "Object File / + Symbol Table Format Specification" for more information. + If the storage class is not scText, we discard the whole block + of symbol records for this stProc. */ + if (sh->st == stProc && sh->sc != scText) + { + char *ext_tsym = ext_sh; + int keep_counting = 1; + SYMR tsym; + + while (keep_counting) + { + ext_tsym += external_sym_size; + (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); + count++; + switch (tsym.st) + { + case stParam: + break; + case stEnd: + keep_counting = 0; + break; + default: + complaint (&symfile_complaints, + "unknown symbol type 0x%x", sh->st); + break; + } + } + break; + } s = new_symbol (name); - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = LOC_BLOCK; /* Type of the return value */ - if (sh->sc == scUndefined || sh->sc == scSUndefined || sh->sc == scNil) + if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) t = mdebug_type_int; else { t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name); - if (STREQ(name, "malloc") && t->code == TYPE_CODE_VOID) + if (STREQ (name, "malloc") && TYPE_CODE (t) == TYPE_CODE_VOID) { - /* I don't know why, but, at least under Linux/Alpha, - when linking against a malloc without debugging - symbols, its read as a function returning void---this - is bad because it means we cannot call functions with - string arguments interactively; i.e., "call - printf("howdy\n")" would fail with the error message - "program has no memory available". To avoid this, we - patch up the type and make it void* - instead. (davidm@azstarnet.com) - */ + /* I don't know why, but, at least under Alpha GNU/Linux, + when linking against a malloc without debugging + symbols, its read as a function returning void---this + is bad because it means we cannot call functions with + string arguments interactively; i.e., "call + printf("howdy\n")" would fail with the error message + "program has no memory available". To avoid this, we + patch up the type and make it void* + instead. (davidm@azstarnet.com) + */ t = make_pointer_type (t, NULL); } } @@ -891,8 +828,13 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) /* Make a type for the procedure itself */ SYMBOL_TYPE (s) = lookup_function_type (t); + /* All functions in C++ have prototypes. For C we don't have enough + information in the debug info. */ + if (SYMBOL_LANGUAGE (s) == language_cplus) + TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED; + /* Create and enter a new lexical context */ - b = new_block (top_stack->maxsyms); + b = new_block (FUNCTION_BLOCK); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_FUNCTION (b) = s; BLOCK_START (b) = BLOCK_END (b) = sh->value; @@ -900,7 +842,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) add_block (b, top_stack->cur_st); /* Not if we only have partial info */ - if (sh->sc == scUndefined || sh->sc == scSUndefined || sh->sc == scNil) + if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) break; push_parse_stack (); @@ -913,7 +855,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) break; /* Beginning of code for structure, union, and enum definitions. - They all share a common set of local variables, defined here. */ + They all share a common set of local variables, defined here. */ { enum type_code type_code; char *ext_tsym; @@ -934,7 +876,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) goto structured_common; case stBlock: /* Either a lexical block, or some type */ - if (sh->sc != scInfo && sh->sc != scCommon && sh->sc != scSCommon) + if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc)) goto case_stBlock_code; /* Lexical block */ type_code = TYPE_CODE_UNDEF; /* We have a type. */ @@ -961,30 +903,53 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) switch (tsym.st) { case stEnd: - goto end_of_fields; + /* C++ encodes class types as structures where there the + methods are encoded as stProc. The scope of stProc + symbols also ends with stEnd, thus creating a risk of + taking the wrong stEnd symbol record as the end of + the current struct, which would cause GDB to undercount + the real number of fields in this struct. To make sure + we really reached the right stEnd symbol record, we + check the associated name, and match it against the + struct name. Since method names are mangled while + the class name is not, there is no risk of having a + method whose name is identical to the class name + (in particular constructor method names are different + from the class name). There is therefore no risk that + this check stops the count on the StEnd of a method. + + Also, assume that we're really at the end when tsym.iss + is 0 (issNull). */ + if (tsym.iss == issNull + || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss, + name) == 0) + goto end_of_fields; + break; case stMember: if (nfields == 0 && type_code == TYPE_CODE_UNDEF) - /* If the type of the member is Nil (or Void), - without qualifiers, assume the tag is an - enumeration. - Alpha cc -migrate enums are recognized by a zero - index and a zero symbol value. - DU 4.0 cc enums are recognized by a member type of - btEnum without qualifiers and a zero symbol value. */ - if (tsym.index == indexNil - || (tsym.index == 0 && sh->value == 0)) - type_code = TYPE_CODE_ENUM; - else - { - (*debug_swap->swap_tir_in) (bigend, - &ax[tsym.index].a_ti, - &tir); - if ((tir.bt == btNil || tir.bt == btVoid - || (tir.bt == btEnum && sh->value == 0)) - && tir.tq0 == tqNil) - type_code = TYPE_CODE_ENUM; - } + { + /* If the type of the member is Nil (or Void), + without qualifiers, assume the tag is an + enumeration. + Alpha cc -migrate enums are recognized by a zero + index and a zero symbol value. + DU 4.0 cc enums are recognized by a member type of + btEnum without qualifiers and a zero symbol value. */ + if (tsym.index == indexNil + || (tsym.index == 0 && sh->value == 0)) + type_code = TYPE_CODE_ENUM; + else + { + (*debug_swap->swap_tir_in) (bigend, + &ax[tsym.index].a_ti, + &tir); + if ((tir.bt == btNil || tir.bt == btVoid + || (tir.bt == btEnum && sh->value == 0)) + && tir.tq0 == tqNil) + type_code = TYPE_CODE_ENUM; + } + } nfields++; if (tsym.value > max_value) max_value = tsym.value; @@ -998,14 +963,14 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) #if 0 /* This is a no-op; is it trying to tell us something we should be checking? */ - if (tsym.sc == scVariant); /*UNIMPLEMENTED*/ + if (tsym.sc == scVariant); /*UNIMPLEMENTED */ #endif if (tsym.index != 0) { /* This is something like a struct within a - struct. Skip over the fields of the inner - struct. The -1 is because the for loop will - increment ext_tsym. */ + struct. Skip over the fields of the inner + struct. The -1 is because the for loop will + increment ext_tsym. */ ext_tsym = ((char *) debug_info->external_sym + ((cur_fdr->isymBase + tsym.index - 1) * external_sym_size)); @@ -1028,7 +993,9 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) break; default: - complain (&block_member_complaint, tsym.st); + complaint (&symfile_complaints, + "declaration block contains unhandled symbol type %d", + tsym.st); } } end_of_fields:; @@ -1067,10 +1034,12 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) here.) */ if (type_code == TYPE_CODE_UNDEF) - if (nfields > 1 && max_value == 0) - type_code = TYPE_CODE_UNION; - else - type_code = TYPE_CODE_STRUCT; + { + if (nfields > 1 && max_value == 0) + type_code = TYPE_CODE_UNION; + else + type_code = TYPE_CODE_STRUCT; + } /* Create a new type or use the pending type. */ pend = is_pending_symbol (cur_fdr, ext_sh); @@ -1131,17 +1100,18 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) FIELD_TYPE (*f) = t; FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss; FIELD_BITSIZE (*f) = 0; + FIELD_STATIC_KIND (*f) = 0; enum_sym = ((struct symbol *) obstack_alloc (¤t_objfile->symbol_obstack, sizeof (struct symbol))); - memset ((PTR) enum_sym, 0, sizeof (struct symbol)); - SYMBOL_NAME (enum_sym) = + memset (enum_sym, 0, sizeof (struct symbol)); + DEPRECATED_SYMBOL_NAME (enum_sym) = obsavestring (f->name, strlen (f->name), ¤t_objfile->symbol_obstack); SYMBOL_CLASS (enum_sym) = LOC_CONST; SYMBOL_TYPE (enum_sym) = t; - SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE; + SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN; SYMBOL_VALUE (enum_sym) = tsym.value; if (SYMBOL_VALUE (enum_sym) < 0) unsigned_enum = 0; @@ -1171,7 +1141,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) } s = new_symbol (name); - SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE; + SYMBOL_DOMAIN (s) = STRUCT_DOMAIN; SYMBOL_CLASS (s) = LOC_TYPEDEF; SYMBOL_VALUE (s) = 0; SYMBOL_TYPE (s) = t; @@ -1185,12 +1155,12 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case_stBlock_code: found_ecoff_debugging_info = 1; /* beginnning of (code) block. Value of symbol - is the displacement from procedure start */ + is the displacement from procedure start */ push_parse_stack (); /* Do not start a new block if this is the outermost block of a - procedure. This allows the LOC_BLOCK symbol to point to the - block with the local variables, so funcname::var works. */ + procedure. This allows the LOC_BLOCK symbol to point to the + block with the local variables, so funcname::var works. */ if (top_stack->blocktype == stProc || top_stack->blocktype == stStaticProc) { @@ -1199,7 +1169,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) } top_stack->blocktype = stBlock; - b = new_block (top_stack->maxsyms); + b = new_block (NON_FUNCTION_BLOCK); BLOCK_START (b) = sh->value + top_stack->procadr; BLOCK_SUPERBLOCK (b) = top_stack->cur_block; top_stack->cur_block = b; @@ -1207,7 +1177,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) break; case stEnd: /* end (of anything) */ - if (sh->sc == scInfo || sh->sc == scCommon || sh->sc == scSCommon) + if (sh->sc == scInfo || SC_IS_COMMON (sh->sc)) { /* Finished with type */ top_stack->cur_type = 0; @@ -1219,7 +1189,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) /* Finished with procedure */ struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); struct mips_extra_func_info *e; - struct block *b; + struct block *b = top_stack->cur_block; struct type *ftype = top_stack->cur_type; int i; @@ -1227,21 +1197,18 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) /* Make up special symbol to contain procedure specific info */ s = new_symbol (MIPS_EFI_SYMBOL_NAME); - SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE; + SYMBOL_DOMAIN (s) = LABEL_DOMAIN; SYMBOL_CLASS (s) = LOC_CONST; SYMBOL_TYPE (s) = mdebug_type_void; e = ((struct mips_extra_func_info *) obstack_alloc (¤t_objfile->symbol_obstack, sizeof (struct mips_extra_func_info))); - memset ((PTR) e, 0, sizeof (struct mips_extra_func_info)); + memset (e, 0, sizeof (struct mips_extra_func_info)); SYMBOL_VALUE (s) = (long) e; e->numargs = top_stack->numargs; e->pdr.framereg = -1; add_symbol (s, top_stack->cur_block); - /* Reallocate symbols, saving memory */ - b = shrink_block (top_stack->cur_block, top_stack->cur_st); - /* f77 emits proc-level with address bounds==[0,0], So look for such child blocks, and patch them. */ for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) @@ -1259,20 +1226,24 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) if (TYPE_NFIELDS (ftype) <= 0) { /* No parameter type information is recorded with the function's - type. Set that from the type of the parameter symbols. */ + type. Set that from the type of the parameter symbols. */ int nparams = top_stack->numargs; int iparams; struct symbol *sym; if (nparams > 0) { + struct dict_iterator iter; TYPE_NFIELDS (ftype) = nparams; TYPE_FIELDS (ftype) = (struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field)); - - for (i = iparams = 0; iparams < nparams; i++) + + iparams = 0; + ALL_BLOCK_SYMBOLS (b, iter, sym) { - sym = BLOCK_SYM (b, i); + if (iparams == nparams) + break; + switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -1280,6 +1251,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case LOC_REGPARM: case LOC_REGPARM_ADDR: TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); + TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; iparams++; break; default: @@ -1295,7 +1267,6 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) displacement from the procedure`s start address of the end of this block. */ BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr; - shrink_block (top_stack->cur_block, top_stack->cur_st); } else if (sh->sc == scText && top_stack->blocktype == stNil) { @@ -1310,7 +1281,8 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) ; } else - complain (&stEnd_complaint, sh->sc); + complaint (&symfile_complaints, + "stEnd with storage class %d not handled", sh->sc); pop_parse_stack (); /* restore previous lexical context */ break; @@ -1322,18 +1294,19 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) bitsize = 0; FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name); FIELD_BITSIZE (*f) = bitsize; + FIELD_STATIC_KIND (*f) = 0; break; case stIndirect: /* forward declaration on Irix5 */ /* Forward declarations from Irix5 cc are handled by cross_ref, - skip them. */ + skip them. */ break; case stTypedef: /* type definition */ found_ecoff_debugging_info = 1; /* Typedefs for forward declarations and opaque structs from alpha cc - are handled by cross_ref, skip them. */ + are handled by cross_ref, skip them. */ if (sh->iss == 0) break; @@ -1341,35 +1314,35 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) pend = is_pending_symbol (cur_fdr, ext_sh); if (pend == (struct mdebug_pending *) NULL) { - t = parse_type (cur_fd, ax, sh->index, (int *)NULL, bigend, name); + t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name); add_pending (cur_fdr, ext_sh, t); } else t = pend->t; /* mips cc puts out a typedef with the name of the struct for forward - declarations. These should not go into the symbol table and - TYPE_NAME should not be set for them. - They can't be distinguished from an intentional typedef to - the same name however: - x.h: - struct x { int ix; int jx; }; - struct xx; - x.c: - typedef struct x x; - struct xx {int ixx; int jxx; }; - generates a cross referencing stTypedef for x and xx. - The user visible effect of this is that the type of a pointer - to struct foo sometimes is given as `foo *' instead of `struct foo *'. - The problem is fixed with alpha cc and Irix5 cc. */ + declarations. These should not go into the symbol table and + TYPE_NAME should not be set for them. + They can't be distinguished from an intentional typedef to + the same name however: + x.h: + struct x { int ix; int jx; }; + struct xx; + x.c: + typedef struct x x; + struct xx {int ixx; int jxx; }; + generates a cross referencing stTypedef for x and xx. + The user visible effect of this is that the type of a pointer + to struct foo sometimes is given as `foo *' instead of `struct foo *'. + The problem is fixed with alpha cc and Irix5 cc. */ /* However if the typedef cross references to an opaque aggregate, it - is safe to omit it from the symbol table. */ + is safe to omit it from the symbol table. */ if (has_opaque_xref (cur_fdr, sh)) break; s = new_symbol (name); - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = LOC_TYPEDEF; SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block; SYMBOL_TYPE (s) = t; @@ -1378,33 +1351,33 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) /* Incomplete definitions of structs should not get a name. */ if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0 - || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT + || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION))) { if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC) { /* If we are giving a name to a type such as "pointer to - foo" or "function returning foo", we better not set - the TYPE_NAME. If the program contains "typedef char - *caddr_t;", we don't want all variables of type char - * to print as caddr_t. This is not just a - consequence of GDB's type management; CC and GCC (at - least through version 2.4) both output variables of - either type char * or caddr_t with the type - refering to the stTypedef symbol for caddr_t. If a future - compiler cleans this up it GDB is not ready for it - yet, but if it becomes ready we somehow need to - disable this check (without breaking the PCC/GCC2.4 - case). - - Sigh. - - Fortunately, this check seems not to be necessary - for anything except pointers or functions. */ + foo" or "function returning foo", we better not set + the TYPE_NAME. If the program contains "typedef char + *caddr_t;", we don't want all variables of type char + * to print as caddr_t. This is not just a + consequence of GDB's type management; CC and GCC (at + least through version 2.4) both output variables of + either type char * or caddr_t with the type + refering to the stTypedef symbol for caddr_t. If a future + compiler cleans this up it GDB is not ready for it + yet, but if it becomes ready we somehow need to + disable this check (without breaking the PCC/GCC2.4 + case). + + Sigh. + + Fortunately, this check seems not to be necessary + for anything except pointers or functions. */ } else - TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s); + TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s); } break; @@ -1421,7 +1394,7 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) case stConstant: break; /* constant */ default: - complain (&unknown_mdebug_symtype_complaint, sh->st); + complaint (&symfile_complaints, "unknown symbol type 0x%x", sh->st); break; } @@ -1434,53 +1407,48 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets) they are big-endian or little-endian (from fh->fBigendian). */ static struct type * -parse_type (fd, ax, aux_index, bs, bigend, sym_name) - int fd; - union aux_ext *ax; - unsigned int aux_index; - int *bs; - int bigend; - char *sym_name; +parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, + int bigend, char *sym_name) { /* Null entries in this map are treated specially */ static struct type **map_bt[] = { - &mdebug_type_void, /* btNil */ - &mdebug_type_adr_32, /* btAdr */ - &mdebug_type_char, /* btChar */ - &mdebug_type_unsigned_char, /* btUChar */ - &mdebug_type_short, /* btShort */ + &mdebug_type_void, /* btNil */ + &mdebug_type_adr_32, /* btAdr */ + &mdebug_type_char, /* btChar */ + &mdebug_type_unsigned_char, /* btUChar */ + &mdebug_type_short, /* btShort */ &mdebug_type_unsigned_short, /* btUShort */ - &mdebug_type_int_32, /* btInt */ + &mdebug_type_int_32, /* btInt */ &mdebug_type_unsigned_int_32, /* btUInt */ - &mdebug_type_long_32, /* btLong */ + &mdebug_type_long_32, /* btLong */ &mdebug_type_unsigned_long_32, /* btULong */ - &mdebug_type_float, /* btFloat */ - &mdebug_type_double, /* btDouble */ - 0, /* btStruct */ - 0, /* btUnion */ - 0, /* btEnum */ - 0, /* btTypedef */ - 0, /* btRange */ - 0, /* btSet */ - &mdebug_type_complex, /* btComplex */ + &mdebug_type_float, /* btFloat */ + &mdebug_type_double, /* btDouble */ + 0, /* btStruct */ + 0, /* btUnion */ + 0, /* btEnum */ + 0, /* btTypedef */ + 0, /* btRange */ + 0, /* btSet */ + &mdebug_type_complex, /* btComplex */ &mdebug_type_double_complex, /* btDComplex */ - 0, /* btIndirect */ - &mdebug_type_fixed_dec, /* btFixedDec */ - &mdebug_type_float_dec, /* btFloatDec */ - &mdebug_type_string, /* btString */ - 0, /* btBit */ - 0, /* btPicture */ - &mdebug_type_void, /* btVoid */ - 0, /* DEC C++: Pointer to member */ - 0, /* DEC C++: Virtual function table */ - 0, /* DEC C++: Class (Record) */ - &mdebug_type_long_64, /* btLong64 */ + 0, /* btIndirect */ + &mdebug_type_fixed_dec, /* btFixedDec */ + &mdebug_type_float_dec, /* btFloatDec */ + &mdebug_type_string, /* btString */ + 0, /* btBit */ + 0, /* btPicture */ + &mdebug_type_void, /* btVoid */ + 0, /* DEC C++: Pointer to member */ + 0, /* DEC C++: Virtual function table */ + 0, /* DEC C++: Class (Record) */ + &mdebug_type_long_64, /* btLong64 */ &mdebug_type_unsigned_long_64, /* btULong64 */ - &mdebug_type_long_long_64, /* btLongLong64 */ - &mdebug_type_unsigned_long_long_64, /* btULongLong64 */ - &mdebug_type_adr_64, /* btAdr64 */ - &mdebug_type_int_64, /* btInt64 */ + &mdebug_type_long_long_64, /* btLongLong64 */ + &mdebug_type_unsigned_long_long_64, /* btULongLong64 */ + &mdebug_type_adr_64, /* btAdr64 */ + &mdebug_type_int_64, /* btInt64 */ &mdebug_type_unsigned_int_64, /* btUInt64 */ }; @@ -1495,7 +1463,7 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) /* Handle corrupt aux indices. */ if (aux_index >= (debug_info->fdr + fd)->caux) { - complain (&index_complaint, sym_name); + index_complaint (sym_name); return mdebug_type_int; } ax += aux_index; @@ -1504,7 +1472,7 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt))) { - complain (&basic_type_complaint, t->bt, sym_name); + basic_type_complaint (t->bt, sym_name); return mdebug_type_int; } if (map_bt[t->bt]) @@ -1543,7 +1511,7 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) type_code = TYPE_CODE_ERROR; break; default: - complain (&basic_type_complaint, t->bt, sym_name); + basic_type_complaint (t->bt, sym_name); return mdebug_type_int; } } @@ -1554,10 +1522,8 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) if (t->fBitfield) { int width = AUX_GET_WIDTH (bigend, ax); - - /* Inhibit core dumps with some cfront generated objects that - corrupt the TIR. */ - if (bs == (int *)NULL) + /* Inhibit core dumps if TIR is corrupted. */ + if (bs == (int *) NULL) { /* Alpha cc -migrate encodes char and unsigned char types as short and unsigned short types with a field width of 8. @@ -1569,10 +1535,11 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) else if (t->bt == btEnum) ; else - complain (&bad_fbitfield_complaint, sym_name); + complaint (&symfile_complaints, "can't handle TIR fBitfield for %s", + sym_name); } else - *bs = width; + *bs = width; ax++; } @@ -1597,13 +1564,14 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) if (rf == -1) { - complain (&bad_indirect_xref_complaint, sym_name); + complaint (&symfile_complaints, + "unable to cross ref btIndirect for %s", sym_name); return mdebug_type_int; } xref_fh = get_rfd (fd, rf); xref_fd = xref_fh - debug_info->fdr; tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase, - rn->index, (int *) NULL, xref_fh->fBigendian, sym_name); + rn->index, (int *) NULL, xref_fh->fBigendian, sym_name); } /* All these types really point to some (common) MIPS type @@ -1613,8 +1581,8 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) t->bt == btUnion || t->bt == btEnum || - /* btSet (I think) implies that the name is a tag name, not a typedef - name. This apparently is a MIPS extension for C sets. */ + /* btSet (I think) implies that the name is a tag name, not a typedef + name. This apparently is a MIPS extension for C sets. */ t->bt == btSet) { char *name; @@ -1625,19 +1593,19 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); /* DEC c89 produces cross references to qualified aggregate types, - dereference them. */ + dereference them. */ while (TYPE_CODE (tp) == TYPE_CODE_PTR || TYPE_CODE (tp) == TYPE_CODE_ARRAY) - tp = tp->target_type; + tp = TYPE_TARGET_TYPE (tp); /* Make sure that TYPE_CODE(tp) has an expected type code. - Any type may be returned from cross_ref if file indirect entries - are corrupted. */ + Any type may be returned from cross_ref if file indirect entries + are corrupted. */ if (TYPE_CODE (tp) != TYPE_CODE_STRUCT && TYPE_CODE (tp) != TYPE_CODE_UNION && TYPE_CODE (tp) != TYPE_CODE_ENUM) { - complain (&unexpected_type_code_complaint, sym_name); + unexpected_type_code_complaint (sym_name); } else { @@ -1651,7 +1619,7 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) || (TYPE_CODE (tp) != TYPE_CODE_ENUM && type_code == TYPE_CODE_ENUM)) { - complain (&bad_tag_guess_complaint, sym_name); + bad_tag_guess_complaint (sym_name); } if (TYPE_CODE (tp) != type_code) @@ -1660,13 +1628,13 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) } /* Do not set the tag name if it is a compiler generated tag name - (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */ + (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */ if (name[0] == '.' || name[0] == '\0') TYPE_TAG_NAME (tp) = NULL; else if (TYPE_TAG_NAME (tp) == NULL || !STREQ (TYPE_TAG_NAME (tp), name)) TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name), - ¤t_objfile->type_obstack); + ¤t_objfile->type_obstack); } } @@ -1684,11 +1652,11 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); /* Make sure that TYPE_CODE(tp) has an expected type code. - Any type may be returned from cross_ref if file indirect entries - are corrupted. */ + Any type may be returned from cross_ref if file indirect entries + are corrupted. */ if (TYPE_CODE (tp) != TYPE_CODE_RANGE) { - complain (&unexpected_type_code_complaint, sym_name); + unexpected_type_code_complaint (sym_name); } else { @@ -1696,7 +1664,7 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) exception is if we guessed wrong re struct/union/enum. */ if (TYPE_CODE (tp) != type_code) { - complain (&bad_tag_guess_complaint, sym_name); + bad_tag_guess_complaint (sym_name); TYPE_CODE (tp) = type_code; } if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name)) @@ -1712,7 +1680,8 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); if (tp == (struct type *) NULL) { - complain (&unable_to_cross_ref_complaint, sym_name); + complaint (&symfile_complaints, + "unable to cross ref btTypedef for %s", sym_name); tp = mdebug_type_int; } } @@ -1724,11 +1693,11 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) TYPE_FIELDS (tp) = ((struct field *) TYPE_ALLOC (tp, 2 * sizeof (struct field))); TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"), - ¤t_objfile->type_obstack); + ¤t_objfile->type_obstack); TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax); ax++; TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"), - ¤t_objfile->type_obstack); + ¤t_objfile->type_obstack); TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax); ax++; } @@ -1762,8 +1731,8 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) /* Complain for illegal continuations due to corrupt aux entries. */ if (t->continued) - complain (&bad_continued_complaint, sym_name); - + complaint (&symfile_complaints, "illegal TIR continued for %s", sym_name); + return tp; } @@ -1775,13 +1744,8 @@ parse_type (fd, ax, aux_index, bs, bigend, sym_name) Returns the number of aux symbols we parsed. */ static int -upgrade_type (fd, tpp, tq, ax, bigend, sym_name) - int fd; - struct type **tpp; - int tq; - union aux_ext *ax; - int bigend; - char *sym_name; +upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, + char *sym_name) { int off; struct type *t; @@ -1826,10 +1790,11 @@ upgrade_type (fd, tpp, tq, ax, bigend, sym_name) id, (int *) NULL, bigend, sym_name); /* The bounds type should be an integer type, but might be anything - else due to corrupt aux entries. */ + else due to corrupt aux entries. */ if (TYPE_CODE (indx) != TYPE_CODE_INT) { - complain (&array_index_type_complaint, sym_name); + complaint (&symfile_complaints, + "illegal array index type for %s, assuming int", sym_name); indx = mdebug_type_int; } @@ -1847,21 +1812,21 @@ upgrade_type (fd, tpp, tq, ax, bigend, sym_name) t = create_array_type ((struct type *) NULL, *tpp, range); /* We used to fill in the supplied array element bitsize - here if the TYPE_LENGTH of the target type was zero. - This happens for a `pointer to an array of anonymous structs', - but in this case the array element bitsize is also zero, - so nothing is gained. - And we used to check the TYPE_LENGTH of the target type against - the supplied array element bitsize. - gcc causes a mismatch for `pointer to array of object', - since the sdb directives it uses do not have a way of - specifying the bitsize, but it does no harm (the - TYPE_LENGTH should be correct) and we should be able to - ignore the erroneous bitsize from the auxiliary entry safely. - dbx seems to ignore it too. */ + here if the TYPE_LENGTH of the target type was zero. + This happens for a `pointer to an array of anonymous structs', + but in this case the array element bitsize is also zero, + so nothing is gained. + And we used to check the TYPE_LENGTH of the target type against + the supplied array element bitsize. + gcc causes a mismatch for `pointer to array of object', + since the sdb directives it uses do not have a way of + specifying the bitsize, but it does no harm (the + TYPE_LENGTH should be correct) and we should be able to + ignore the erroneous bitsize from the auxiliary entry safely. + dbx seems to ignore it too. */ /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH - problem. */ + problem. */ if (TYPE_LENGTH (*tpp) == 0) { TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB; @@ -1879,7 +1844,7 @@ upgrade_type (fd, tpp, tq, ax, bigend, sym_name) return 0; default: - complain (&unknown_type_qual_complaint, tq); + complaint (&symfile_complaints, "unknown type qualifier 0x%x", tq); return 0; } } @@ -1896,14 +1861,11 @@ upgrade_type (fd, tpp, tq, ax, bigend, sym_name) to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol in question, or NULL to use top_stack->cur_block. */ -static void parse_procedure PARAMS ((PDR *, struct symtab *, - struct partial_symtab *)); +static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *); static void -parse_procedure (pr, search_symtab, pst) - PDR *pr; - struct symtab *search_symtab; - struct partial_symtab *pst; +parse_procedure (PDR *pr, struct symtab *search_symtab, + struct partial_symtab *pst) { struct symbol *s, *i; struct block *b; @@ -1917,14 +1879,16 @@ parse_procedure (pr, search_symtab, pst) { /* Static procedure at address pr->adr. Sigh. */ /* FIXME-32x64. assuming pr->adr fits in long. */ - complain (&pdr_static_symbol_complaint, (unsigned long) pr->adr); + complaint (&symfile_complaints, + "can't handle PDR for static proc at 0x%lx", + (unsigned long) pr->adr); return; } else { /* external */ EXTR she; - + (*debug_swap->swap_ext_in) (cur_bfd, ((char *) debug_info->external_ext + (pr->isym @@ -1950,26 +1914,26 @@ parse_procedure (pr, search_symtab, pst) { #if 0 /* This loses both in the case mentioned (want a static, find a global), - but also if we are looking up a non-mangled name which happens to - match the name of a mangled function. */ + but also if we are looking up a non-mangled name which happens to + match the name of a mangled function. */ /* We have to save the cur_fdr across the call to lookup_symbol. - If the pdr is for a static function and if a global function with - the same name exists, lookup_symbol will eventually read in the symtab - for the global function and clobber cur_fdr. */ + If the pdr is for a static function and if a global function with + the same name exists, lookup_symbol will eventually read in the symtab + for the global function and clobber cur_fdr. */ FDR *save_cur_fdr = cur_fdr; - s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL); + s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL); cur_fdr = save_cur_fdr; #else s = mylookup_symbol (sh_name, BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK), - VAR_NAMESPACE, + VAR_DOMAIN, LOC_BLOCK); #endif } else s = mylookup_symbol (sh_name, top_stack->cur_block, - VAR_NAMESPACE, LOC_BLOCK); + VAR_DOMAIN, LOC_BLOCK); if (s != 0) { @@ -1977,13 +1941,13 @@ parse_procedure (pr, search_symtab, pst) } else { - complain (&pdr_for_nonsymbol_complaint, sh_name); + complaint (&symfile_complaints, "PDR for %s, but no symbol", sh_name); #if 1 return; #else /* FIXME -- delete. We can't do symbol allocation now; it's all done. */ s = new_symbol (sh_name); - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = LOC_BLOCK; /* Donno its type, hope int is ok */ SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int); @@ -1994,14 +1958,14 @@ parse_procedure (pr, search_symtab, pst) BLOCK_FUNCTION (b) = s; BLOCK_START (b) = pr->adr; /* BOUND used to be the end of procedure's text, but the - argument is no longer passed in. */ + argument is no longer passed in. */ BLOCK_END (b) = bound; BLOCK_SUPERBLOCK (b) = top_stack->cur_block; add_block (b, top_stack->cur_st); #endif } - i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST); + i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST); if (i) { @@ -2010,22 +1974,22 @@ parse_procedure (pr, search_symtab, pst) e->pdr.isym = (long) s; /* GDB expects the absolute function start address for the - procedure descriptor in e->pdr.adr. - As the address in the procedure descriptor is usually relative, - we would have to relocate e->pdr.adr with cur_fdr->adr and - ANOFFSET (pst->section_offsets, SECT_OFF_TEXT). - Unfortunately cur_fdr->adr and e->pdr.adr are both absolute - in shared libraries on some systems, and on other systems - e->pdr.adr is sometimes offset by a bogus value. - To work around these problems, we replace e->pdr.adr with - the start address of the function. */ + procedure descriptor in e->pdr.adr. + As the address in the procedure descriptor is usually relative, + we would have to relocate e->pdr.adr with cur_fdr->adr and + ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)). + Unfortunately cur_fdr->adr and e->pdr.adr are both absolute + in shared libraries on some systems, and on other systems + e->pdr.adr is sometimes offset by a bogus value. + To work around these problems, we replace e->pdr.adr with + the start address of the function. */ e->pdr.adr = BLOCK_START (b); /* Correct incorrect setjmp procedure descriptor from the library - to make backtrace through setjmp work. */ + to make backtrace through setjmp work. */ if (e->pdr.pcreg == 0 && STREQ (sh_name, "setjmp")) { - complain (&bad_setjmp_pdr_complaint, 0); + complaint (&symfile_complaints, "fixing bad setjmp PDR from libc"); e->pdr.pcreg = RA_REGNUM; e->pdr.regmask = 0x80000000; e->pdr.regoffset = -4; @@ -2046,7 +2010,7 @@ parse_procedure (pr, search_symtab, pst) To work around these problems, the return value type of a TYPE_CODE_VOID function is adjusted accordingly if no debugging info was found in the compilation unit. */ - + if (processing_gcc_compilation == 0 && found_ecoff_debugging_info == 0 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID) @@ -2056,14 +2020,12 @@ parse_procedure (pr, search_symtab, pst) /* Relocate the extra function info pointed to by the symbol table. */ void -ecoff_relocate_efi (sym, delta) - struct symbol *sym; - CORE_ADDR delta; +ecoff_relocate_efi (struct symbol *sym, CORE_ADDR delta) { struct mips_extra_func_info *e; e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym); - + e->pdr.adr += delta; } @@ -2073,13 +2035,12 @@ ecoff_relocate_efi (sym, delta) This routine clobbers top_stack->cur_block and ->cur_st. */ -static void parse_external PARAMS ((EXTR *, int, struct section_offsets *)); +static void parse_external (EXTR *, int, struct section_offsets *, + struct objfile *); static void -parse_external (es, bigend, section_offsets) - EXTR *es; - int bigend; - struct section_offsets *section_offsets; +parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets, + struct objfile *objfile) { union aux_ext *ax; @@ -2096,8 +2057,7 @@ parse_external (es, bigend, section_offsets) } /* Reading .o files */ - if (es->asym.sc == scUndefined || es->asym.sc == scSUndefined - || es->asym.sc == scNil) + if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil) { char *what; switch (es->asym.st) @@ -2137,25 +2097,25 @@ parse_external (es, bigend, section_offsets) case stProc: case stStaticProc: /* There is no need to parse the external procedure symbols. - If they are from objects compiled without -g, their index will - be indexNil, and the symbol definition from the minimal symbol - is preferrable (yielding a function returning int instead of int). - If the index points to a local procedure symbol, the local - symbol already provides the correct type. - Note that the index of the external procedure symbol points - to the local procedure symbol in the local symbol table, and - _not_ to the auxiliary symbol info. */ + If they are from objects compiled without -g, their index will + be indexNil, and the symbol definition from the minimal symbol + is preferrable (yielding a function returning int instead of int). + If the index points to a local procedure symbol, the local + symbol already provides the correct type. + Note that the index of the external procedure symbol points + to the local procedure symbol in the local symbol table, and + _not_ to the auxiliary symbol info. */ break; case stGlobal: case stLabel: /* Global common symbols are resolved by the runtime loader, - ignore them. */ - if (es->asym.sc == scCommon || es->asym.sc == scSCommon) + ignore them. */ + if (SC_IS_COMMON (es->asym.sc)) break; /* Note that the case of a symbol with indexNil must be handled - anyways by parse_symbol(). */ - parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets); + anyways by parse_symbol(). */ + parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile); break; default: break; @@ -2168,17 +2128,12 @@ parse_external (es, bigend, section_offsets) numbers can go back and forth, apparently we can live with that and do not need to reorder our linetables */ -static void parse_lines PARAMS ((FDR *, PDR *, struct linetable *, int, - struct partial_symtab *, CORE_ADDR)); +static void parse_lines (FDR *, PDR *, struct linetable *, int, + struct partial_symtab *, CORE_ADDR); static void -parse_lines (fh, pr, lt, maxlines, pst, lowest_pdr_addr) - FDR *fh; - PDR *pr; - struct linetable *lt; - int maxlines; - struct partial_symtab *pst; - CORE_ADDR lowest_pdr_addr; +parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines, + struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr) { unsigned char *base; int j, k; @@ -2201,18 +2156,18 @@ parse_lines (fh, pr, lt, maxlines, pst, lowest_pdr_addr) continue; /* Determine start and end address of compressed line bytes for - this procedure. */ + this procedure. */ base = debug_info->line + fh->cbLineOffset; if (j != (fh->cpd - 1)) - halt = base + pr[1].cbLineOffset; + halt = base + pr[1].cbLineOffset; else - halt = base + fh->cbLine; + halt = base + fh->cbLine; base += pr->cbLineOffset; adr = pst->textlow + pr->adr - lowest_pdr_addr; l = adr >> 2; /* in words */ - for (lineno = pr->lnLow; base < halt; ) + for (lineno = pr->lnLow; base < halt;) { count = *base & 0x0f; delta = *base++ >> 4; @@ -2231,7 +2186,9 @@ parse_lines (fh, pr, lt, maxlines, pst, lowest_pdr_addr) with corrupt binaries. */ if (lt->nitems >= maxlines) { - complain (&bad_linetable_guess_complaint, fdr_name (fh)); + complaint (&symfile_complaints, + "guessed size of linetable for %s incorrectly", + fdr_name (fh)); break; } k = add_line (lt, lineno, l, k); @@ -2240,23 +2197,26 @@ parse_lines (fh, pr, lt, maxlines, pst, lowest_pdr_addr) } } +static void +function_outside_compilation_unit_complaint (const char *arg1) +{ + complaint (&symfile_complaints, + "function `%s' appears to be defined outside of all compilation units", + arg1); +} + /* Master parsing procedure for first-pass reading of file symbols into a partial_symtab. */ static void -parse_partial_symbols (objfile, section_offsets) - struct objfile *objfile; - struct section_offsets *section_offsets; +parse_partial_symbols (struct objfile *objfile) { const bfd_size_type external_sym_size = debug_swap->external_sym_size; const bfd_size_type external_rfd_size = debug_swap->external_rfd_size; const bfd_size_type external_ext_size = debug_swap->external_ext_size; - void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *)) - = debug_swap->swap_ext_in; - void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) - = debug_swap->swap_sym_in; - void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *)) - = debug_swap->swap_rfd_in; + void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in; + void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; + void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in; int f_idx, s_idx; HDRR *hdr = &debug_info->symbolic_header; /* Running pointers */ @@ -2264,7 +2224,7 @@ parse_partial_symbols (objfile, section_offsets) char *ext_out; char *ext_out_end; EXTR *ext_block; - register EXTR *ext_in; + EXTR *ext_in; EXTR *ext_in_end; SYMR sh; struct partial_symtab *pst; @@ -2330,10 +2290,10 @@ parse_partial_symbols (objfile, section_offsets) Minor hack: -O3 images might claim some global data belongs to FDR -1. We`ll go along with that */ fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst); - old_chain = make_cleanup (free, fdr_to_pst); + old_chain = make_cleanup (xfree, fdr_to_pst); fdr_to_pst++; { - struct partial_symtab *pst = new_psymtab ("", objfile, section_offsets); + struct partial_symtab *pst = new_psymtab ("", objfile); fdr_to_pst[-1].pst = pst; FDR_IDX (pst) = -1; } @@ -2343,12 +2303,12 @@ parse_partial_symbols (objfile, section_offsets) ((struct mdebug_pending **) obstack_alloc (&objfile->psymbol_obstack, hdr->ifdMax * sizeof (struct mdebug_pending *))); - memset ((PTR) pending_list, 0, + memset (pending_list, 0, hdr->ifdMax * sizeof (struct mdebug_pending *)); /* Pass 0 over external syms: swap them in. */ ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR)); - make_cleanup (free, ext_block); + make_cleanup (xfree, ext_block); ext_out = (char *) debug_info->external_ext; ext_out_end = ext_out + hdr->iextMax * external_ext_size; @@ -2378,6 +2338,37 @@ parse_partial_symbols (objfile, section_offsets) fdr_to_pst[f_idx].n_globals = 0; } + /* ECOFF in ELF: + + For ECOFF in ELF, we skip the creation of the minimal symbols. + The ECOFF symbols should be a subset of the Elf symbols, and the + section information of the elf symbols will be more accurate. + FIXME! What about Irix 5's native linker? + + By default, Elf sections which don't exist in ECOFF + get put in ECOFF's absolute section by the gnu linker. + Since absolute sections don't get relocated, we + end up calculating an address different from that of + the symbol's minimal symbol (created earlier from the + Elf symtab). + + To fix this, either : + 1) don't create the duplicate symbol + (assumes ECOFF symtab is a subset of the ELF symtab; + assumes no side-effects result from ignoring ECOFF symbol) + 2) create it, only if lookup for existing symbol in ELF's minimal + symbols fails + (inefficient; + assumes no side-effects result from ignoring ECOFF symbol) + 3) create it, but lookup ELF's minimal symbol and use it's section + during relocation, then modify "uniqify" phase to merge and + eliminate the duplicate symbol + (highly inefficient) + + I've implemented #1 here... + Skip the creation of the minimal symbols based on the ECOFF + symbol table. */ + /* Pass 2 over external syms: fill in external symbols */ ext_in = ext_block; ext_in_end = ext_in + hdr->iextMax; @@ -2387,82 +2378,131 @@ parse_partial_symbols (objfile, section_offsets) CORE_ADDR svalue = ext_in->asym.value; /* The Irix 5 native tools seem to sometimes generate bogus - external symbols. */ + external symbols. */ if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax) { - complain (&bad_ext_ifd_complaint, ext_in->ifd, hdr->ifdMax); + complaint (&symfile_complaints, + "bad ifd for external symbol: %d (max %ld)", ext_in->ifd, + hdr->ifdMax); continue; } if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax) { - complain (&bad_ext_iss_complaint, ext_in->asym.iss, - hdr->issExtMax); + complaint (&symfile_complaints, + "bad iss for external symbol: %ld (max %ld)", + ext_in->asym.iss, hdr->issExtMax); continue; } extern_tab[fdr_to_pst[ext_in->ifd].globals_offset + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in; - if (ext_in->asym.sc == scUndefined || ext_in->asym.sc == scSUndefined - || ext_in->asym.sc == scNil) + + if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil) continue; + + /* Pass 3 over files, over local syms: fill in static symbols */ name = debug_info->ssext + ext_in->asym.iss; + + /* Process ECOFF Symbol Types and Storage Classes */ switch (ext_in->asym.st) { case stProc: - svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT); + /* Beginnning of Procedure */ + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); break; case stStaticProc: + /* Load time only static procs */ ms_type = mst_file_text; - svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); break; case stGlobal: - if (ext_in->asym.sc == scCommon || ext_in->asym.sc == scSCommon) + /* External symbol */ + if (SC_IS_COMMON (ext_in->asym.sc)) { /* The value of a common symbol is its size, not its address. - Ignore it. */ + Ignore it. */ continue; } - else if (ext_in->asym.sc == scData - || ext_in->asym.sc == scSData - || ext_in->asym.sc == scRData - || ext_in->asym.sc == scPData - || ext_in->asym.sc == scXData) + else if (SC_IS_DATA (ext_in->asym.sc)) { ms_type = mst_data; - svalue += ANOFFSET (section_offsets, SECT_OFF_DATA); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); } - else + else if (SC_IS_BSS (ext_in->asym.sc)) { ms_type = mst_bss; - svalue += ANOFFSET (section_offsets, SECT_OFF_BSS); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); } + else if (SC_IS_SBSS (ext_in->asym.sc)) + { + ms_type = mst_bss; + svalue += ANOFFSET (objfile->section_offsets, + get_section_index (objfile, ".sbss")); + } + else + ms_type = mst_abs; break; case stLabel: - if (ext_in->asym.sc == scAbs) - ms_type = mst_abs; - else if (ext_in->asym.sc == scText - || ext_in->asym.sc == scInit - || ext_in->asym.sc == scFini) + /* Label */ + + /* On certain platforms, some extra label symbols can be + generated by the linker. One possible usage for this kind + of symbols is to represent the address of the begining of a + given section. For instance, on Tru64 5.1, the address of + the _ftext label is the start address of the .text section. + + The storage class of these symbols is usually directly + related to the section to which the symbol refers. For + instance, on Tru64 5.1, the storage class for the _fdata + label is scData, refering to the .data section. + + It is actually possible that the section associated to the + storage class of the label does not exist. On True64 5.1 + for instance, the libm.so shared library does not contain + any .data section, although it contains a _fpdata label + which storage class is scData... Since these symbols are + usually useless for the debugger user anyway, we just + discard these symbols. + */ + + if (SC_IS_TEXT (ext_in->asym.sc)) { + if (objfile->sect_index_text == -1) + continue; + ms_type = mst_file_text; - svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); } - else if (ext_in->asym.sc == scData - || ext_in->asym.sc == scSData - || ext_in->asym.sc == scRData - || ext_in->asym.sc == scPData - || ext_in->asym.sc == scXData) + else if (SC_IS_DATA (ext_in->asym.sc)) { + if (objfile->sect_index_data == -1) + continue; + ms_type = mst_file_data; - svalue += ANOFFSET (section_offsets, SECT_OFF_DATA); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); } - else + else if (SC_IS_BSS (ext_in->asym.sc)) { + if (objfile->sect_index_bss == -1) + continue; + ms_type = mst_file_bss; - svalue += ANOFFSET (section_offsets, SECT_OFF_BSS); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); } + else if (SC_IS_SBSS (ext_in->asym.sc)) + { + const int sbss_sect_index = get_section_index (objfile, ".sbss"); + + if (sbss_sect_index == -1) + continue; + + ms_type = mst_file_bss; + svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index); + } + else + ms_type = mst_abs; break; case stLocal: case stNil: @@ -2470,15 +2510,16 @@ parse_partial_symbols (objfile, section_offsets) whose name starts with a `.'. Skip those but complain for all other stLocal symbols. Irix6 puts the section start addresses in stNil symbols, skip - those too. */ + those too. */ if (name[0] == '.') continue; /* Fall through. */ default: ms_type = mst_unknown; - complain (&unknown_ext_complaint, name); + unknown_ext_complaint (name); } - prim_record_minimal_symbol (name, svalue, ms_type, objfile); + if (!ECOFF_IN_ELF (cur_bfd)) + prim_record_minimal_symbol (name, svalue, ms_type, objfile); } /* Pass 3 over files, over local syms: fill in static symbols */ @@ -2490,13 +2531,6 @@ parse_partial_symbols (objfile, section_offsets) cur_fdr = fh = debug_info->fdr + f_idx; - /* If a partial symbol table has already been read for this file, - don't make another one. This works around a problem with some - compilers that emit both DWARF and mdebug sections for a single - module. */ - if (lookup_partial_symtab (fdr_name (fh))) - continue; - if (fh->csym == 0) { fdr_to_pst[f_idx].pst = NULL; @@ -2504,16 +2538,16 @@ parse_partial_symbols (objfile, section_offsets) } /* Determine the start address for this object file from the - file header and relocate it, except for Irix 5.2 zero fh->adr. */ + file header and relocate it, except for Irix 5.2 zero fh->adr. */ if (fh->cpd) { textlow = fh->adr; if (relocatable || textlow != 0) - textlow += ANOFFSET (section_offsets, SECT_OFF_TEXT); + textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); } else textlow = 0; - pst = start_psymtab_common (objfile, section_offsets, + pst = start_psymtab_common (objfile, objfile->section_offsets, fdr_name (fh), textlow, objfile->global_psymbols.next, @@ -2521,7 +2555,7 @@ parse_partial_symbols (objfile, section_offsets) pst->read_symtab_private = ((char *) obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc))); - memset ((PTR) pst->read_symtab_private, 0, sizeof (struct symloc)); + memset (pst->read_symtab_private, 0, sizeof (struct symloc)); save_pst = pst; FDR_IDX (pst) = f_idx; @@ -2535,15 +2569,15 @@ parse_partial_symbols (objfile, section_offsets) /* Set up language for the pst. The language from the FDR is used if it is unambigious (e.g. cfront - with native cc and g++ will set the language to C). - Otherwise we have to deduce the language from the filename. - Native ecoff has every header file in a separate FDR, so - deduce_language_from_filename will return language_unknown for - a header file, which is not what we want. - But the FDRs for the header files are after the FDR for the source - file, so we can assign the language of the source file to the - following header files. Then we save the language in the private - pst data so that we can reuse it when building symtabs. */ + with native cc and g++ will set the language to C). + Otherwise we have to deduce the language from the filename. + Native ecoff has every header file in a separate FDR, so + deduce_language_from_filename will return language_unknown for + a header file, which is not what we want. + But the FDRs for the header files are after the FDR for the source + file, so we can assign the language of the source file to the + following header files. Then we save the language in the private + pst data so that we can reuse it when building symtabs. */ prev_language = psymtab_language; switch (fh->lang) @@ -2562,11 +2596,11 @@ parse_partial_symbols (objfile, section_offsets) pst->texthigh = pst->textlow; /* For stabs-in-ecoff files, the second symbol must be @stab. - This symbol is emitted by mips-tfile to signal that the - current object file uses encapsulated stabs instead of mips - ecoff for local symbols. (It is the second symbol because - the first symbol is the stFile used to signal the start of a - file). */ + This symbol is emitted by mips-tfile to signal that the + current object file uses encapsulated stabs instead of mips + ecoff for local symbols. (It is the second symbol because + the first symbol is the stFile used to signal the start of a + file). */ processing_gcc_compilation = 0; if (fh->csym >= 2) { @@ -2587,7 +2621,7 @@ parse_partial_symbols (objfile, section_offsets) (*swap_sym_in) (cur_bfd, (((char *) debug_info->external_sym) - + (fh->isymBase + cur_sdx) * external_sym_size), + + (fh->isymBase + cur_sdx) * external_sym_size), &sh); type_code = ECOFF_UNMARK_STAB (sh.index); if (!ECOFF_IS_STAB (&sh)) @@ -2596,8 +2630,8 @@ parse_partial_symbols (objfile, section_offsets) { CORE_ADDR procaddr; long isym; - - sh.value += ANOFFSET (section_offsets, SECT_OFF_TEXT); + + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); if (sh.st == stStaticProc) { namestring = debug_info->ss + fh->issBase + sh.iss; @@ -2605,7 +2639,7 @@ parse_partial_symbols (objfile, section_offsets) sh.value, mst_file_text, NULL, - SECT_OFF_TEXT, + SECT_OFF_TEXT (objfile), NULL, objfile); } @@ -2624,9 +2658,9 @@ parse_partial_symbols (objfile, section_offsets) { CORE_ADDR high = procaddr + sh.value; - /* Kludge for Irix 5.2 zero fh->adr. */ + /* Kludge for Irix 5.2 zero fh->adr. */ if (!relocatable - && (pst->textlow == 0 || procaddr < pst->textlow)) + && (pst->textlow == 0 || procaddr < pst->textlow)) pst->textlow = procaddr; if (high > pst->texthigh) pst->texthigh = high; @@ -2648,24 +2682,26 @@ parse_partial_symbols (objfile, section_offsets) case scPData: case scXData: namestring = debug_info->ss + fh->issBase + sh.iss; - sh.value += ANOFFSET (section_offsets, SECT_OFF_DATA); + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); prim_record_minimal_symbol_and_info (namestring, sh.value, mst_file_data, NULL, - SECT_OFF_DATA, + SECT_OFF_DATA (objfile), NULL, objfile); break; default: + /* FIXME! Shouldn't this use cases for bss, + then have the default be abs? */ namestring = debug_info->ss + fh->issBase + sh.iss; - sh.value += ANOFFSET (section_offsets, SECT_OFF_BSS); + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); prim_record_minimal_symbol_and_info (namestring, sh.value, mst_file_bss, NULL, - SECT_OFF_BSS, + SECT_OFF_BSS (objfile), NULL, objfile); break; @@ -2673,16 +2709,573 @@ parse_partial_symbols (objfile, section_offsets) } continue; } -#define SET_NAMESTRING() \ - namestring = debug_info->ss + fh->issBase + sh.iss -#define CUR_SYMBOL_TYPE type_code -#define CUR_SYMBOL_VALUE sh.value -#define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\ - pst = save_pst -#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set) (void)0 -#define HANDLE_RBRAC(val) \ - if ((val) > save_pst->texthigh) save_pst->texthigh = (val); -#include "partial-stab.h" + /* Handle stabs continuation */ + { + char *stabstring = debug_info->ss + fh->issBase + sh.iss; + int len = strlen (stabstring); + while (stabstring[len - 1] == '\\') + { + SYMR sh2; + char *stabstring1 = stabstring; + char *stabstring2; + int len2; + + /* Ignore continuation char from 1st string */ + len--; + + /* Read next stabstring */ + cur_sdx++; + (*swap_sym_in) (cur_bfd, + (((char *) debug_info->external_sym) + + (fh->isymBase + cur_sdx) + * external_sym_size), + &sh2); + stabstring2 = debug_info->ss + fh->issBase + sh2.iss; + len2 = strlen (stabstring2); + + /* Concatinate stabstring2 with stabstring1 */ + if (stabstring + && stabstring != debug_info->ss + fh->issBase + sh.iss) + stabstring = xrealloc (stabstring, len + len2 + 1); + else + { + stabstring = xmalloc (len + len2 + 1); + strcpy (stabstring, stabstring1); + } + strcpy (stabstring + len, stabstring2); + len += len2; + } + + switch (type_code) + { + char *p; + /* + * Standard, external, non-debugger, symbols + */ + + case N_TEXT | N_EXT: + case N_NBTEXT | N_EXT: + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + goto record_it; + + case N_DATA | N_EXT: + case N_NBDATA | N_EXT: + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); + goto record_it; + + case N_BSS: + case N_BSS | N_EXT: + case N_NBBSS | N_EXT: + case N_SETV | N_EXT: /* FIXME, is this in BSS? */ + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); + goto record_it; + + case N_ABS | N_EXT: + record_it: + continue; + + /* Standard, local, non-debugger, symbols */ + + case N_NBTEXT: + + /* We need to be able to deal with both N_FN or N_TEXT, + because we have no way of knowing whether the sys-supplied ld + or GNU ld was used to make the executable. Sequents throw + in another wrinkle -- they renumbered N_FN. */ + + case N_FN: + case N_FN_SEQ: + case N_TEXT: + continue; + + case N_DATA: + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); + goto record_it; + + case N_UNDF | N_EXT: + continue; /* Just undefined, not COMMON */ + + case N_UNDF: + continue; + + /* Lots of symbol types we can just ignore. */ + + case N_ABS: + case N_NBDATA: + case N_NBBSS: + continue; + + /* Keep going . . . */ + + /* + * Special symbol types for GNU + */ + case N_INDR: + case N_INDR | N_EXT: + case N_SETA: + case N_SETA | N_EXT: + case N_SETT: + case N_SETT | N_EXT: + case N_SETD: + case N_SETD | N_EXT: + case N_SETB: + case N_SETB | N_EXT: + case N_SETV: + continue; + + /* + * Debugger symbols + */ + + case N_SO: + { + CORE_ADDR valu; + static int prev_so_symnum = -10; + static int first_so_symnum; + char *p; + int prev_textlow_not_set; + + valu = sh.value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + + prev_textlow_not_set = textlow_not_set; + +#ifdef SOFUN_ADDRESS_MAYBE_MISSING + /* A zero value is probably an indication for the SunPRO 3.0 + compiler. end_psymtab explicitly tests for zero, so + don't relocate it. */ + + if (sh.value == 0) + { + textlow_not_set = 1; + valu = 0; + } + else + textlow_not_set = 0; +#else + textlow_not_set = 0; +#endif + past_first_source_file = 1; + + if (prev_so_symnum != symnum - 1) + { /* Here if prev stab wasn't N_SO */ + first_so_symnum = symnum; + + if (pst) + { + pst = (struct partial_symtab *) 0; + includes_used = 0; + dependencies_used = 0; + } + } + + prev_so_symnum = symnum; + + /* End the current partial symtab and start a new one */ + + /* SET_NAMESTRING ();*/ + namestring = stabstring; + + /* Null name means end of .o file. Don't start a new one. */ + if (*namestring == '\000') + continue; + + /* Some compilers (including gcc) emit a pair of initial N_SOs. + The first one is a directory name; the second the file name. + If pst exists, is empty, and has a filename ending in '/', + we assume the previous N_SO was a directory name. */ + + p = strrchr (namestring, '/'); + if (p && *(p + 1) == '\000') + continue; /* Simply ignore directory name SOs */ + + /* Some other compilers (C++ ones in particular) emit useless + SOs for non-existant .c files. We ignore all subsequent SOs that + immediately follow the first. */ + + if (!pst) + pst = save_pst; + continue; + } + + case N_BINCL: + continue; + + case N_SOL: + { + enum language tmp_language; + /* Mark down an include file in the current psymtab */ + + /* SET_NAMESTRING ();*/ + namestring = stabstring; + + tmp_language = deduce_language_from_filename (namestring); + + /* Only change the psymtab's language if we've learned + something useful (eg. tmp_language is not language_unknown). + In addition, to match what start_subfile does, never change + from C++ to C. */ + if (tmp_language != language_unknown + && (tmp_language != language_c + || psymtab_language != language_cplus)) + psymtab_language = tmp_language; + + /* In C++, one may expect the same filename to come round many + times, when code is coming alternately from the main file + and from inline functions in other files. So I check to see + if this is a file we've seen before -- either the main + source file, or a previously included file. + + This seems to be a lot of time to be spending on N_SOL, but + things like "break c-exp.y:435" need to work (I + suppose the psymtab_include_list could be hashed or put + in a binary tree, if profiling shows this is a major hog). */ + if (pst && STREQ (namestring, pst->filename)) + continue; + { + int i; + for (i = 0; i < includes_used; i++) + if (STREQ (namestring, psymtab_include_list[i])) + { + i = -1; + break; + } + if (i == -1) + continue; + } + + psymtab_include_list[includes_used++] = namestring; + if (includes_used >= includes_allocated) + { + char **orig = psymtab_include_list; + + psymtab_include_list = (char **) + alloca ((includes_allocated *= 2) * + sizeof (char *)); + memcpy (psymtab_include_list, orig, + includes_used * sizeof (char *)); + } + continue; + } + case N_LSYM: /* Typedef or automatic variable. */ + case N_STSYM: /* Data seg var -- static */ + case N_LCSYM: /* BSS " */ + case N_ROSYM: /* Read-only data seg var -- static. */ + case N_NBSTS: /* Gould nobase. */ + case N_NBLCS: /* symbols. */ + case N_FUN: + case N_GSYM: /* Global (extern) variable; can be + data or bss (sigh FIXME). */ + + /* Following may probably be ignored; I'll leave them here + for now (until I do Pascal and Modula 2 extensions). */ + + case N_PC: /* I may or may not need this; I + suspect not. */ + case N_M2C: /* I suspect that I can ignore this here. */ + case N_SCOPE: /* Same. */ + + /* SET_NAMESTRING ();*/ + namestring = stabstring; + p = (char *) strchr (namestring, ':'); + if (!p) + continue; /* Not a debugging symbol. */ + + + + /* Main processing section for debugging symbols which + the initial read through the symbol tables needs to worry + about. If we reach this point, the symbol which we are + considering is definitely one we are interested in. + p must also contain the (valid) index into the namestring + which indicates the debugging type symbol. */ + + switch (p[1]) + { + case 'S': + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); +#ifdef STATIC_TRANSFORM_NAME + namestring = STATIC_TRANSFORM_NAME (namestring); +#endif + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_STATIC, + &objfile->static_psymbols, + 0, sh.value, + psymtab_language, objfile); + continue; + case 'G': + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); + /* The addresses in these entries are reported to be + wrong. See the code that reads 'G's for symtabs. */ + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_STATIC, + &objfile->global_psymbols, + 0, sh.value, + psymtab_language, objfile); + continue; + + case 'T': + /* When a 'T' entry is defining an anonymous enum, it + may have a name which is the empty string, or a + single space. Since they're not really defining a + symbol, those shouldn't go in the partial symbol + table. We do pick up the elements of such enums at + 'check_enum:', below. */ + if (p >= namestring + 2 + || (p == namestring + 1 + && namestring[0] != ' ')) + { + add_psymbol_to_list (namestring, p - namestring, + STRUCT_DOMAIN, LOC_TYPEDEF, + &objfile->static_psymbols, + sh.value, 0, + psymtab_language, objfile); + if (p[2] == 't') + { + /* Also a typedef with the same name. */ + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_TYPEDEF, + &objfile->static_psymbols, + sh.value, 0, + psymtab_language, objfile); + p += 1; + } + } + goto check_enum; + case 't': + if (p != namestring) /* a name is there, not just :T... */ + { + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_TYPEDEF, + &objfile->static_psymbols, + sh.value, 0, + psymtab_language, objfile); + } + check_enum: + /* If this is an enumerated type, we need to + add all the enum constants to the partial symbol + table. This does not cover enums without names, e.g. + "enum {a, b} c;" in C, but fortunately those are + rare. There is no way for GDB to find those from the + enum type without spending too much time on it. Thus + to solve this problem, the compiler needs to put out the + enum in a nameless type. GCC2 does this. */ + + /* We are looking for something of the form + ":" ("t" | "T") [ "="] "e" + { ":" ","} ";". */ + + /* Skip over the colon and the 't' or 'T'. */ + p += 2; + /* This type may be given a number. Also, numbers can come + in pairs like (0,26). Skip over it. */ + while ((*p >= '0' && *p <= '9') + || *p == '(' || *p == ',' || *p == ')' + || *p == '=') + p++; + + if (*p++ == 'e') + { + /* The aix4 compiler emits extra crud before the members. */ + if (*p == '-') + { + /* Skip over the type (?). */ + while (*p != ':') + p++; + + /* Skip over the colon. */ + p++; + } + + /* We have found an enumerated type. */ + /* According to comments in read_enum_type + a comma could end it instead of a semicolon. + I don't know where that happens. + Accept either. */ + while (*p && *p != ';' && *p != ',') + { + char *q; + + /* Check for and handle cretinous dbx symbol name + continuation! */ + if (*p == '\\' || (*p == '?' && p[1] == '\0')) + p = next_symbol_text (objfile); + + /* Point to the character after the name + of the enum constant. */ + for (q = p; *q && *q != ':'; q++) + ; + /* Note that the value doesn't matter for + enum constants in psymtabs, just in symtabs. */ + add_psymbol_to_list (p, q - p, + VAR_DOMAIN, LOC_CONST, + &objfile->static_psymbols, 0, + 0, psymtab_language, objfile); + /* Point past the name. */ + p = q; + /* Skip over the value. */ + while (*p && *p != ',') + p++; + /* Advance past the comma. */ + if (*p) + p++; + } + } + continue; + case 'c': + /* Constant, e.g. from "const" in Pascal. */ + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_CONST, + &objfile->static_psymbols, sh.value, + 0, psymtab_language, objfile); + continue; + + case 'f': + if (! pst) + { + int name_len = p - namestring; + char *name = xmalloc (name_len + 1); + memcpy (name, namestring, name_len); + name[name_len] = '\0'; + function_outside_compilation_unit_complaint (name); + xfree (name); + } + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_BLOCK, + &objfile->static_psymbols, + 0, sh.value, + psymtab_language, objfile); + continue; + + /* Global functions were ignored here, but now they + are put into the global psymtab like one would expect. + They're also in the minimal symbol table. */ + case 'F': + if (! pst) + { + int name_len = p - namestring; + char *name = xmalloc (name_len + 1); + memcpy (name, namestring, name_len); + name[name_len] = '\0'; + function_outside_compilation_unit_complaint (name); + xfree (name); + } + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + add_psymbol_to_list (namestring, p - namestring, + VAR_DOMAIN, LOC_BLOCK, + &objfile->global_psymbols, + 0, sh.value, + psymtab_language, objfile); + continue; + + /* Two things show up here (hopefully); static symbols of + local scope (static used inside braces) or extensions + of structure symbols. We can ignore both. */ + case 'V': + case '(': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '-': + case '#': /* for symbol identification (used in live ranges) */ + continue; + + case ':': + /* It is a C++ nested symbol. We don't need to record it + (I don't think); if we try to look up foo::bar::baz, + then symbols for the symtab containing foo should get + read in, I think. */ + /* Someone says sun cc puts out symbols like + /foo/baz/maclib::/usr/local/bin/maclib, + which would get here with a symbol type of ':'. */ + continue; + + default: + /* Unexpected symbol descriptor. The second and subsequent stabs + of a continued stab can show up here. The question is + whether they ever can mimic a normal stab--it would be + nice if not, since we certainly don't want to spend the + time searching to the end of every string looking for + a backslash. */ + + complaint (&symfile_complaints, + "unknown symbol descriptor `%c'", p[1]); + + /* Ignore it; perhaps it is an extension that we don't + know about. */ + continue; + } + + case N_EXCL: + continue; + + case N_ENDM: +#ifdef SOFUN_ADDRESS_MAYBE_MISSING + /* Solaris 2 end of module, finish current partial + symbol table. END_PSYMTAB will set + pst->texthigh to the proper value, which is + necessary if a module compiled without + debugging info follows this module. */ + if (pst) + { + pst = (struct partial_symtab *) 0; + includes_used = 0; + dependencies_used = 0; + } +#endif + continue; + + case N_RBRAC: + if (sh.value > save_pst->texthigh) + save_pst->texthigh = sh.value; + continue; + case N_EINCL: + case N_DSLINE: + case N_BSLINE: + case N_SSYM: /* Claim: Structure or union element. + Hopefully, I can ignore this. */ + case N_ENTRY: /* Alternate entry point; can ignore. */ + case N_MAIN: /* Can definitely ignore this. */ + case N_CATCH: /* These are GNU C++ extensions */ + case N_EHDECL: /* that can safely be ignored here. */ + case N_LENG: + case N_BCOMM: + case N_ECOMM: + case N_ECOML: + case N_FNAME: + case N_SLINE: + case N_RSYM: + case N_PSYM: + case N_LBRAC: + case N_NSYMS: /* Ultrix 4.0: symbol count */ + case N_DEFD: /* GNU Modula-2 */ + case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ + + case N_OBJ: /* useless types from Solaris */ + case N_OPT: + /* These symbols aren't interesting; don't worry about them */ + + continue; + + default: + /* If we haven't found it yet, ignore it. It's probably some + new type we don't know about yet. */ + complaint (&symfile_complaints, "unknown symbol type %s", + local_hex_string (type_code)); /*CUR_SYMBOL_TYPE*/ + continue; + } + if (stabstring + && stabstring != debug_info->ss + fh->issBase + sh.iss) + xfree (stabstring); + } + /* end - Handle continuation */ } } else @@ -2705,8 +3298,7 @@ parse_partial_symbols (objfile, section_offsets) } /* Non absolute static symbols go into the minimal table. */ - if (sh.sc == scUndefined || sh.sc == scSUndefined - || sh.sc == scNil + if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil || (sh.index == indexNil && (sh.st != stStatic || sh.sc == scAbs))) { @@ -2724,18 +3316,18 @@ parse_partial_symbols (objfile, section_offsets) /* The value of a stEnd symbol is the displacement from the corresponding start symbol value, do not relocate it. */ if (sh.st != stEnd) - sh.value += ANOFFSET (section_offsets, SECT_OFF_TEXT); + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); break; case scData: case scSData: case scRData: case scPData: case scXData: - sh.value += ANOFFSET (section_offsets, SECT_OFF_DATA); + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); break; case scBss: case scSBss: - sh.value += ANOFFSET (section_offsets, SECT_OFF_BSS); + sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); break; } @@ -2748,12 +3340,45 @@ parse_partial_symbols (objfile, section_offsets) case stStaticProc: prim_record_minimal_symbol_and_info (name, sh.value, mst_file_text, NULL, - SECT_OFF_TEXT, NULL, + SECT_OFF_TEXT (objfile), NULL, objfile); /* FALLTHROUGH */ case stProc: + /* Ignore all parameter symbol records. */ + if (sh.index >= hdr->iauxMax) + { + /* Should not happen, but does when cross-compiling + with the MIPS compiler. FIXME -- pull later. */ + index_complaint (name); + new_sdx = cur_sdx + 1; /* Don't skip at all */ + } + else + new_sdx = AUX_GET_ISYM (fh->fBigendian, + (debug_info->external_aux + + fh->iauxBase + + sh.index)); + + if (new_sdx <= cur_sdx) + { + /* This should not happen either... FIXME. */ + complaint (&symfile_complaints, + "bad proc end in aux found from symbol %s", + name); + new_sdx = cur_sdx + 1; /* Don't skip backward */ + } + + /* For stProc symbol records, we need to check the + storage class as well, as only (stProc, scText) + entries represent "real" procedures - See the + Compaq document titled "Object File / Symbol Table + Format Specification" for more information. If the + storage class is not scText, we discard the whole + block of symbol records for this stProc. */ + if (sh.st == stProc && sh.sc != scText) + goto skip; + /* Usually there is a local and a global stProc symbol for a function. This means that the function name has already been entered into the mimimal symbol table @@ -2767,37 +3392,17 @@ parse_partial_symbols (objfile, section_offsets) symbol table. */ if (sh.st == stProc) add_psymbol_to_list (name, strlen (name), - VAR_NAMESPACE, LOC_BLOCK, + VAR_DOMAIN, LOC_BLOCK, &objfile->global_psymbols, - 0, sh.value, psymtab_language, objfile); + 0, sh.value, psymtab_language, objfile); else add_psymbol_to_list (name, strlen (name), - VAR_NAMESPACE, LOC_BLOCK, + VAR_DOMAIN, LOC_BLOCK, &objfile->static_psymbols, - 0, sh.value, psymtab_language, objfile); + 0, sh.value, psymtab_language, objfile); - /* Skip over procedure to next one. */ - if (sh.index >= hdr->iauxMax) - { - /* Should not happen, but does when cross-compiling - with the MIPS compiler. FIXME -- pull later. */ - complain (&index_complaint, name); - new_sdx = cur_sdx + 1; /* Don't skip at all */ - } - else - new_sdx = AUX_GET_ISYM (fh->fBigendian, - (debug_info->external_aux - + fh->iauxBase - + sh.index)); procaddr = sh.value; - if (new_sdx <= cur_sdx) - { - /* This should not happen either... FIXME. */ - complain (&aux_index_complaint, name); - new_sdx = cur_sdx + 1; /* Don't skip backward */ - } - cur_sdx = new_sdx; (*swap_sym_in) (cur_bfd, ((char *) debug_info->external_sym @@ -2818,30 +3423,26 @@ parse_partial_symbols (objfile, section_offsets) continue; case stStatic: /* Variable */ - if (sh.sc == scData - || sh.sc == scSData - || sh.sc == scRData - || sh.sc == scPData - || sh.sc == scXData) + if (SC_IS_DATA (sh.sc)) prim_record_minimal_symbol_and_info (name, sh.value, mst_file_data, NULL, - SECT_OFF_DATA, + SECT_OFF_DATA (objfile), NULL, objfile); else prim_record_minimal_symbol_and_info (name, sh.value, mst_file_bss, NULL, - SECT_OFF_BSS, + SECT_OFF_BSS (objfile), NULL, objfile); class = LOC_STATIC; break; - case stIndirect:/* Irix5 forward declaration */ + case stIndirect: /* Irix5 forward declaration */ /* Skip forward declarations from Irix5 cc */ goto skip; - case stTypedef:/* Typedef */ + case stTypedef: /* Typedef */ /* Skip typedefs for forward declarations and opaque structs from alpha and mips cc. */ if (sh.iss == 0 || has_opaque_xref (fh, &sh)) @@ -2856,16 +3457,16 @@ parse_partial_symbols (objfile, section_offsets) case stUnion: case stStruct: case stEnum: - case stBlock: /* { }, str, un, enum*/ + case stBlock: /* { }, str, un, enum */ /* Do not create a partial symbol for cc unnamed aggregates and gcc empty aggregates. */ if ((sh.sc == scInfo - || sh.sc == scCommon || sh.sc == scSCommon) + || SC_IS_COMMON (sh.sc)) && sh.iss != 0 && sh.index != cur_sdx + 2) { add_psymbol_to_list (name, strlen (name), - STRUCT_NAMESPACE, LOC_TYPEDEF, + STRUCT_DOMAIN, LOC_TYPEDEF, &objfile->static_psymbols, 0, (CORE_ADDR) 0, psymtab_language, objfile); @@ -2877,7 +3478,8 @@ parse_partial_symbols (objfile, section_offsets) if (new_sdx <= cur_sdx) { /* This happens with the Ultrix kernel. */ - complain (&block_index_complaint, name); + complaint (&symfile_complaints, + "bad aux index at block symbol %s", name); new_sdx = cur_sdx + 1; /* Don't skip backward */ } cur_sdx = new_sdx; @@ -2897,14 +3499,15 @@ parse_partial_symbols (objfile, section_offsets) default: /* Both complaints are valid: one gives symbol name, the other the offending symbol type. */ - complain (&unknown_sym_complaint, name); - complain (&unknown_st_complaint, sh.st); + complaint (&symfile_complaints, "unknown local symbol %s", + name); + complaint (&symfile_complaints, "with type %d", sh.st); cur_sdx++; continue; } /* Use this gdb symbol */ add_psymbol_to_list (name, strlen (name), - VAR_NAMESPACE, class, + VAR_DOMAIN, class, &objfile->static_psymbols, 0, sh.value, psymtab_language, objfile); skip: @@ -2924,12 +3527,11 @@ parse_partial_symbols (objfile, section_offsets) CORE_ADDR svalue; if (ext_ptr->ifd != f_idx) - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); psh = &ext_ptr->asym; /* Do not add undefined symbols to the partial symbol table. */ - if (psh->sc == scUndefined || psh->sc == scSUndefined - || psh->sc == scNil) + if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil) continue; svalue = psh->value; @@ -2937,18 +3539,18 @@ parse_partial_symbols (objfile, section_offsets) { case scText: case scRConst: - svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); break; case scData: case scSData: case scRData: case scPData: case scXData: - svalue += ANOFFSET (section_offsets, SECT_OFF_DATA); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); break; case scBss: case scSBss: - svalue += ANOFFSET (section_offsets, SECT_OFF_BSS); + svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); break; } @@ -2968,13 +3570,12 @@ parse_partial_symbols (objfile, section_offsets) class = LOC_LABEL; break; default: - complain (&unknown_ext_complaint, - debug_info->ssext + psh->iss); + unknown_ext_complaint (debug_info->ssext + psh->iss); /* Fall through, pretend it's global. */ case stGlobal: /* Global common symbols are resolved by the runtime loader, ignore them. */ - if (psh->sc == scCommon || psh->sc == scSCommon) + if (SC_IS_COMMON (psh->sc)) continue; class = LOC_STATIC; @@ -2982,7 +3583,7 @@ parse_partial_symbols (objfile, section_offsets) } name = debug_info->ssext + psh->iss; add_psymbol_to_list (name, strlen (name), - VAR_NAMESPACE, class, + VAR_DOMAIN, class, &objfile->global_psymbols, 0, svalue, psymtab_language, objfile); @@ -2990,48 +3591,48 @@ parse_partial_symbols (objfile, section_offsets) } /* Link pst to FDR. end_psymtab returns NULL if the psymtab was - empty and put on the free list. */ + empty and put on the free list. */ fdr_to_pst[f_idx].pst = end_psymtab (save_pst, - psymtab_include_list, includes_used, + psymtab_include_list, includes_used, -1, save_pst->texthigh, - dependency_list, dependencies_used, textlow_not_set); + dependency_list, dependencies_used, textlow_not_set); includes_used = 0; dependencies_used = 0; if (objfile->ei.entry_point >= save_pst->textlow && objfile->ei.entry_point < save_pst->texthigh) { - objfile->ei.entry_file_lowpc = save_pst->textlow; - objfile->ei.entry_file_highpc = save_pst->texthigh; + objfile->ei.deprecated_entry_file_lowpc = save_pst->textlow; + objfile->ei.deprecated_entry_file_highpc = save_pst->texthigh; } /* The objfile has its functions reordered if this partial symbol - table overlaps any other partial symbol table. - We cannot assume a reordered objfile if a partial symbol table - is contained within another partial symbol table, as partial symbol - tables for include files with executable code are contained - within the partial symbol table for the including source file, - and we do not want to flag the objfile reordered for these cases. - - This strategy works well for Irix-5.2 shared libraries, but we - might have to use a more elaborate (and slower) algorithm for - other cases. */ + table overlaps any other partial symbol table. + We cannot assume a reordered objfile if a partial symbol table + is contained within another partial symbol table, as partial symbol + tables for include files with executable code are contained + within the partial symbol table for the including source file, + and we do not want to flag the objfile reordered for these cases. + + This strategy works well for Irix-5.2 shared libraries, but we + might have to use a more elaborate (and slower) algorithm for + other cases. */ save_pst = fdr_to_pst[f_idx].pst; if (save_pst != NULL && save_pst->textlow != 0 && !(objfile->flags & OBJF_REORDERED)) { ALL_OBJFILE_PSYMTABS (objfile, pst) - { - if (save_pst != pst - && save_pst->textlow >= pst->textlow - && save_pst->textlow < pst->texthigh - && save_pst->texthigh > pst->texthigh) - { - objfile->flags |= OBJF_REORDERED; - break; - } - } + { + if (save_pst != pst + && save_pst->textlow >= pst->textlow + && save_pst->textlow < pst->texthigh + && save_pst->texthigh > pst->texthigh) + { + objfile->flags |= OBJF_REORDERED; + break; + } + } } } @@ -3041,7 +3642,7 @@ parse_partial_symbols (objfile, section_offsets) fh = f_idx + debug_info->fdr; pst = fdr_to_pst[f_idx].pst; - if (pst == (struct partial_symtab *)NULL) + if (pst == (struct partial_symtab *) NULL) continue; /* This should catch stabs-in-ecoff. */ @@ -3049,7 +3650,7 @@ parse_partial_symbols (objfile, section_offsets) continue; /* Skip the first file indirect entry as it is a self dependency - for source files or a reverse .h -> .c dependency for header files. */ + for source files or a reverse .h -> .c dependency for header files. */ pst->number_of_dependencies = 0; pst->dependencies = ((struct partial_symtab **) @@ -3066,7 +3667,7 @@ parse_partial_symbols (objfile, section_offsets) &rh); if (rh < 0 || rh >= hdr->ifdMax) { - complain (&bad_file_number_complaint, rh); + complaint (&symfile_complaints, "bad file number %ld", rh); continue; } @@ -3075,7 +3676,7 @@ parse_partial_symbols (objfile, section_offsets) continue; /* Do not add to dependeny list if psymtab was empty. */ - if (fdr_to_pst[rh].pst == (struct partial_symtab *)NULL) + if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL) continue; pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst; } @@ -3095,17 +3696,13 @@ parse_partial_symbols (objfile, section_offsets) all the the enum constants to the partial symbol table. */ static void -handle_psymbol_enumerators (objfile, fh, stype, svalue) - struct objfile *objfile; - FDR *fh; - int stype; - CORE_ADDR svalue; +handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, + CORE_ADDR svalue) { const bfd_size_type external_sym_size = debug_swap->external_sym_size; - void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) - = debug_swap->swap_sym_in; + void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; char *ext_sym = ((char *) debug_info->external_sym - + ((fh->isymBase + cur_sdx + 1) * external_sym_size)); + + ((fh->isymBase + cur_sdx + 1) * external_sym_size)); SYMR sh; TIR tir; @@ -3116,12 +3713,12 @@ handle_psymbol_enumerators (objfile, fh, stype, svalue) case stBlock: /* It is an enumerated type if the next symbol entry is a stMember - and its auxiliary index is indexNil or its auxiliary entry - is a plain btNil or btVoid. - Alpha cc -migrate enums are recognized by a zero index and - a zero symbol value. - DU 4.0 cc enums are recognized by a member type of btEnum without - qualifiers and a zero symbol value. */ + and its auxiliary index is indexNil or its auxiliary entry + is a plain btNil or btVoid. + Alpha cc -migrate enums are recognized by a zero index and + a zero symbol value. + DU 4.0 cc enums are recognized by a member type of btEnum without + qualifiers and a zero symbol value. */ (*swap_sym_in) (cur_bfd, ext_sym, &sh); if (sh.st != stMember) return; @@ -3154,18 +3751,19 @@ handle_psymbol_enumerators (objfile, fh, stype, svalue) name = debug_info->ss + cur_fdr->issBase + sh.iss; /* Note that the value doesn't matter for enum constants - in psymtabs, just in symtabs. */ + in psymtabs, just in symtabs. */ add_psymbol_to_list (name, strlen (name), - VAR_NAMESPACE, LOC_CONST, + VAR_DOMAIN, LOC_CONST, &objfile->static_psymbols, 0, (CORE_ADDR) 0, psymtab_language, objfile); ext_sym += external_sym_size; } } +/* Get the next symbol. OBJFILE is unused. */ + static char * -mdebug_next_symbol_text (objfile) - struct objfile *objfile; /* argument objfile is currently unused */ +mdebug_next_symbol_text (struct objfile *objfile) { SYMR sh; @@ -3189,19 +3787,18 @@ mdebug_next_symbol_text (objfile) The flow of control and even the memory allocation differs. FIXME. */ static void -psymtab_to_symtab_1 (pst, filename) - struct partial_symtab *pst; - char *filename; +psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) { bfd_size_type external_sym_size; bfd_size_type external_pdr_size; - void (*swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)); - void (*swap_pdr_in) PARAMS ((bfd *, PTR, PDR *)); + void (*swap_sym_in) (bfd *, void *, SYMR *); + void (*swap_pdr_in) (bfd *, void *, PDR *); int i; - struct symtab *st; + struct symtab *st = NULL; FDR *fh; struct linetable *lines; CORE_ADDR lowest_pdr_addr = 0; + int last_symtab_ended = 0; if (pst->readin) return; @@ -3297,16 +3894,45 @@ psymtab_to_symtab_1 (pst, filename) &sh); name = debug_info->ss + fh->issBase + sh.iss; valu = sh.value; - if (ECOFF_IS_STAB (&sh)) + /* XXX This is a hack. It will go away! */ + if (ECOFF_IS_STAB (&sh) || (name[0] == '#')) { int type_code = ECOFF_UNMARK_STAB (sh.index); /* We should never get non N_STAB symbols here, but they - should be harmless, so keep process_one_symbol from - complaining about them. */ + should be harmless, so keep process_one_symbol from + complaining about them. */ if (type_code & N_STAB) { - process_one_symbol (type_code, 0, valu, name, + /* If we found a trailing N_SO with no name, process + it here instead of in process_one_symbol, so we + can keep a handle to its symtab. The symtab + would otherwise be ended twice, once in + process_one_symbol, and once after this loop. */ + if (type_code == N_SO + && last_source_file + && previous_stab_code != (unsigned char) N_SO + && *name == '\000') + { + valu += ANOFFSET (pst->section_offsets, + SECT_OFF_TEXT (pst->objfile)); + previous_stab_code = N_SO; + st = end_symtab (valu, pst->objfile, + SECT_OFF_TEXT (pst->objfile)); + end_stabs (); + last_symtab_ended = 1; + } + else + { + last_symtab_ended = 0; + process_one_symbol (type_code, 0, valu, name, + pst->section_offsets, pst->objfile); + } + } + /* Similarly a hack. */ + else if (name[0] == '#') + { + process_one_symbol (N_SLINE, 0, valu, name, pst->section_offsets, pst->objfile); } if (type_code == N_FUN) @@ -3314,13 +3940,13 @@ psymtab_to_symtab_1 (pst, filename) /* Make up special symbol to contain procedure specific info */ struct mips_extra_func_info *e = - ((struct mips_extra_func_info *) - obstack_alloc (¤t_objfile->symbol_obstack, - sizeof (struct mips_extra_func_info))); + ((struct mips_extra_func_info *) + obstack_alloc (¤t_objfile->symbol_obstack, + sizeof (struct mips_extra_func_info))); struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME); - memset ((PTR) e, 0, sizeof (struct mips_extra_func_info)); - SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE; + memset (e, 0, sizeof (struct mips_extra_func_info)); + SYMBOL_DOMAIN (s) = LABEL_DOMAIN; SYMBOL_CLASS (s) = LOC_CONST; SYMBOL_TYPE (s) = mdebug_type_void; SYMBOL_VALUE (s) = (long) e; @@ -3339,7 +3965,7 @@ psymtab_to_symtab_1 (pst, filename) else { /* Handle encoded stab line number. */ - valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT); + valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)); record_line (current_subfile, sh.index, valu); } } @@ -3348,20 +3974,20 @@ psymtab_to_symtab_1 (pst, filename) /* These are generated by gcc-2.x, do not complain */ ; else - complain (&stab_unknown_complaint, name); + complaint (&symfile_complaints, "unknown stabs symbol %s", name); } - st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT); - end_stabs (); - /* Sort the symbol table now, we are done adding symbols to it. - We must do this before parse_procedure calls lookup_symbol. */ - sort_symtab_syms (st); + if (! last_symtab_ended) + { + st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile)); + end_stabs (); + } /* There used to be a call to sort_blocks here, but this should not - be necessary for stabs symtabs. And as sort_blocks modifies the - start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, - it did the wrong thing if the first procedure in a file was - generated via asm statements. */ + be necessary for stabs symtabs. And as sort_blocks modifies the + start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, + it did the wrong thing if the first procedure in a file was + generated via asm statements. */ /* Fill in procedure info next. */ if (fh->cpd > 0) @@ -3374,7 +4000,7 @@ psymtab_to_symtab_1 (pst, filename) PDR *pdr_in_end; pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); - old_chain = make_cleanup (free, pr_block); + old_chain = make_cleanup (xfree, pr_block); pdr_ptr = ((char *) debug_info->external_pdr + fh->ipdFirst * external_pdr_size); @@ -3387,7 +4013,7 @@ psymtab_to_symtab_1 (pst, filename) (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); /* Determine lowest PDR address, the PDRs are not always - sorted. */ + sorted. */ if (pdr_in == pr_block) lowest_pdr_addr = pdr_in->adr; else if (pdr_in->adr < lowest_pdr_addr) @@ -3410,19 +4036,15 @@ psymtab_to_symtab_1 (pst, filename) int maxlines; EXTR *ext_ptr; - /* How many symbols will we need */ - /* FIXME, this does not count enum values. */ - f_max = pst->n_global_syms + pst->n_static_syms; if (fh == 0) { maxlines = 0; - st = new_symtab ("unknown", f_max, 0, pst->objfile); + st = new_symtab ("unknown", 0, pst->objfile); } else { - f_max += fh->csym + fh->cpd; maxlines = 2 * fh->cline; - st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile); + st = new_symtab (pst->filename, maxlines, pst->objfile); /* The proper language was already determined when building the psymtab, use it. */ @@ -3442,7 +4064,6 @@ psymtab_to_symtab_1 (pst, filename) BLOCK_START (top_stack->cur_block) = pst->textlow; BLOCK_END (top_stack->cur_block) = 0; top_stack->blocktype = stFile; - top_stack->maxsyms = 2 * f_max; top_stack->cur_type = 0; top_stack->procadr = 0; top_stack->numargs = 0; @@ -3465,7 +4086,7 @@ psymtab_to_symtab_1 (pst, filename) (*swap_sym_in) (cur_bfd, sym_ptr, &sh); c = parse_symbol (&sh, debug_info->external_aux + fh->iauxBase, - sym_ptr, fh->fBigendian, pst->section_offsets); + sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile); sym_ptr += c * external_sym_size; } @@ -3483,7 +4104,7 @@ psymtab_to_symtab_1 (pst, filename) pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); - old_chain = make_cleanup (free, pr_block); + old_chain = make_cleanup (xfree, pr_block); pdr_ptr = ((char *) debug_info->external_pdr + fh->ipdFirst * external_pdr_size); @@ -3520,24 +4141,20 @@ psymtab_to_symtab_1 (pst, filename) LINETABLE (st) = lines; /* .. and our share of externals. - XXX use the global list to speed up things here. how? - FIXME, Maybe quit once we have found the right number of ext's? */ + XXX use the global list to speed up things here. how? + FIXME, Maybe quit once we have found the right number of ext's? */ top_stack->cur_st = st; top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), GLOBAL_BLOCK); top_stack->blocktype = stFile; - top_stack->maxsyms - = (debug_info->symbolic_header.isymMax - + debug_info->symbolic_header.ipdMax - + debug_info->symbolic_header.iextMax); ext_ptr = PST_PRIVATE (pst)->extern_tab; for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++) - parse_external (ext_ptr, fh->fBigendian, pst->section_offsets); + parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile); /* If there are undefined symbols, tell the user. - The alpha has an undefined symbol for every symbol that is - from a shared library, so tell the user only if verbose is on. */ + The alpha has an undefined symbol for every symbol that is + from a shared library, so tell the user only if verbose is on. */ if (info_verbose && n_undef_symbols) { printf_filtered ("File %s contains %d unresolved references:", @@ -3551,9 +4168,6 @@ psymtab_to_symtab_1 (pst, filename) st->primary = 1; - /* Sort the symbol table now, we are done adding symbols to it.*/ - sort_symtab_syms (st); - sort_blocks (st); } @@ -3569,9 +4183,7 @@ psymtab_to_symtab_1 (pst, filename) to an opaque aggregate type, else 0. */ static int -has_opaque_xref (fh, sh) - FDR *fh; - SYMR *sh; +has_opaque_xref (FDR *fh, SYMR *sh) { TIR tir; union aux_ext *ax; @@ -3603,14 +4215,8 @@ has_opaque_xref (fh, sh) Return value says how many aux symbols we ate. */ static int -cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) - int fd; - union aux_ext *ax; - struct type **tpp; - enum type_code type_code; /* Use to alloc new type if none is found. */ - char **pname; - int bigend; - char *sym_name; +cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_code, /* Use to alloc new type if none is found. */ + char **pname, int bigend, char *sym_name) { RNDXR rn[1]; unsigned int rf; @@ -3621,7 +4227,7 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) int xref_fd; struct mdebug_pending *pend; - *tpp = (struct type *)NULL; + *tpp = (struct type *) NULL; (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn); @@ -3642,8 +4248,7 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) if (rf == -1) { *pname = ""; - *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); - TYPE_FLAGS (*tpp) |= TYPE_FLAG_STUB; + *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile); return result; } @@ -3664,8 +4269,7 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) { /* File indirect entry is corrupt. */ *pname = ""; - complain (&bad_rfd_entry_complaint, - sym_name, xref_fd, rn->index); + bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); return result; } @@ -3685,12 +4289,11 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect && sh.st != stStruct && sh.st != stUnion && sh.st != stEnum)) - && (sh.st != stBlock || (sh.sc != scCommon && sh.sc != scSCommon))) + && (sh.st != stBlock || !SC_IS_COMMON (sh.sc))) { /* File indirect entry is corrupt. */ *pname = ""; - complain (&bad_rfd_entry_complaint, - sym_name, xref_fd, rn->index); + bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); return result; } @@ -3710,14 +4313,14 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) /* alpha cc puts out a stTypedef with a sh.iss of zero for two cases: a) forward declarations of structs/unions/enums which are not - defined in this compilation unit. - For these the type will be void. This is a bad design decision - as cross referencing across compilation units is impossible - due to the missing name. + defined in this compilation unit. + For these the type will be void. This is a bad design decision + as cross referencing across compilation units is impossible + due to the missing name. b) forward declarations of structs/unions/enums/typedefs which - are defined later in this file or in another file in the same - compilation unit. Irix5 cc uses a stIndirect symbol for this. - Simply cross reference those again to get the true type. + are defined later in this file or in another file in the same + compilation unit. Irix5 cc uses a stIndirect symbol for this. + Simply cross reference those again to get the true type. The forward references are not entered in the pending list and in the symbol table. */ @@ -3726,13 +4329,14 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) + fh->iauxBase + sh.index)->a_ti, &tir); if (tir.tq0 != tqNil) - complain (&illegal_forward_tq0_complaint, sym_name); + complaint (&symfile_complaints, + "illegal tq0 in forward typedef for %s", sym_name); switch (tir.bt) { case btVoid: *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); - *pname = ""; + *pname = ""; break; case btStruct: @@ -3747,23 +4351,25 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) case btTypedef: /* Follow a forward typedef. This might recursively - call cross_ref till we get a non typedef'ed type. - FIXME: This is not correct behaviour, but gdb currently - cannot handle typedefs without type copying. Type - copying is impossible as we might have mutual forward - references between two files and the copied type would not - get filled in when we later parse its definition. */ + call cross_ref till we get a non typedef'ed type. + FIXME: This is not correct behaviour, but gdb currently + cannot handle typedefs without type copying. Type + copying is impossible as we might have mutual forward + references between two files and the copied type would not + get filled in when we later parse its definition. */ *tpp = parse_type (xref_fd, debug_info->external_aux + fh->iauxBase, sh.index, - (int *)NULL, + (int *) NULL, fh->fBigendian, debug_info->ss + fh->issBase + sh.iss); add_pending (fh, esh, *tpp); break; default: - complain (&illegal_forward_bt_complaint, tir.bt, sym_name); + complaint (&symfile_complaints, + "illegal bt %d in forward typedef for %s", tir.bt, + sym_name); *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); break; @@ -3782,7 +4388,7 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) *tpp = parse_type (xref_fd, debug_info->external_aux + fh->iauxBase, sh.index, - (int *)NULL, + (int *) NULL, fh->fBigendian, debug_info->ss + fh->issBase + sh.iss); } @@ -3807,83 +4413,46 @@ cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name) keeping the symtab sorted */ static struct symbol * -mylookup_symbol (name, block, namespace, class) - char *name; - register struct block *block; - namespace_enum namespace; - enum address_class class; +mylookup_symbol (char *name, struct block *block, + domain_enum domain, enum address_class class) { - register int bot, top, inc; - register struct symbol *sym; + struct dict_iterator iter; + int inc; + struct symbol *sym; - bot = 0; - top = BLOCK_NSYMS (block); inc = name[0]; - while (bot < top) + ALL_BLOCK_SYMBOLS (block, iter, sym) { - sym = BLOCK_SYM (block, bot); - if (SYMBOL_NAME (sym)[0] == inc - && SYMBOL_NAMESPACE (sym) == namespace + if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc + && SYMBOL_DOMAIN (sym) == domain && SYMBOL_CLASS (sym) == class - && strcmp (SYMBOL_NAME (sym), name) == 0) + && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0) return sym; - bot++; } + block = BLOCK_SUPERBLOCK (block); if (block) - return mylookup_symbol (name, block, namespace, class); + return mylookup_symbol (name, block, domain, class); return 0; } -/* Add a new symbol S to a block B. - Infrequently, we will need to reallocate the block to make it bigger. - We only detect this case when adding to top_stack->cur_block, since - that's the only time we know how big the block is. FIXME. */ +/* Add a new symbol S to a block B. */ static void -add_symbol (s, b) - struct symbol *s; - struct block *b; +add_symbol (struct symbol *s, struct block *b) { - int nsyms = BLOCK_NSYMS (b)++; - struct block *origb; - struct parse_stack *stackp; - - if (b == top_stack->cur_block && - nsyms >= top_stack->maxsyms) - { - complain (&block_overflow_complaint, SYMBOL_NAME (s)); - /* In this case shrink_block is actually grow_block, since - BLOCK_NSYMS(b) is larger than its current size. */ - origb = b; - b = shrink_block (top_stack->cur_block, top_stack->cur_st); - - /* Now run through the stack replacing pointers to the - original block. shrink_block has already done this - for the blockvector and BLOCK_FUNCTION. */ - for (stackp = top_stack; stackp; stackp = stackp->next) - { - if (stackp->cur_block == origb) - { - stackp->cur_block = b; - stackp->maxsyms = BLOCK_NSYMS (b); - } - } - } - BLOCK_SYM (b, nsyms) = s; + dict_add_symbol (BLOCK_DICT (b), s); } /* Add a new block B to a symtab S */ static void -add_block (b, s) - struct block *b; - struct symtab *s; +add_block (struct block *b, struct symtab *s) { struct blockvector *bv = BLOCKVECTOR (s); - bv = (struct blockvector *) xrealloc ((PTR) bv, + bv = (struct blockvector *) xrealloc ((void *) bv, (sizeof (struct blockvector) + BLOCKVECTOR_NBLOCKS (bv) * sizeof (bv->block))); @@ -3909,11 +4478,7 @@ add_block (b, s) This is another reason why -ggdb debugging format is preferable. */ static int -add_line (lt, lineno, adr, last) - struct linetable *lt; - int lineno; - CORE_ADDR adr; - int last; +add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last) { /* DEC c89 sometimes produces zero linenos which confuse gdb. Change them to something sensible. */ @@ -3935,11 +4500,9 @@ add_line (lt, lineno, adr, last) /* Blocks with a smaller low bound should come first */ static int -compare_blocks (arg1, arg2) - const PTR arg1; - const PTR arg2; +compare_blocks (const void *arg1, const void *arg2) { - register int addr_diff; + int addr_diff; struct block **b1 = (struct block **) arg1; struct block **b2 = (struct block **) arg2; @@ -3954,8 +4517,7 @@ compare_blocks (arg1, arg2) as required by some MI search routines */ static void -sort_blocks (s) - struct symtab *s; +sort_blocks (struct symtab *s) { struct blockvector *bv = BLOCKVECTOR (s); @@ -3981,8 +4543,8 @@ sort_blocks (s) compare_blocks); { - register CORE_ADDR high = 0; - register int i, j = BLOCKVECTOR_NBLOCKS (bv); + CORE_ADDR high = 0; + int i, j = BLOCKVECTOR_NBLOCKS (bv); for (i = FIRST_LOCAL_BLOCK; i < j; i++) if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i))) @@ -4002,15 +4564,11 @@ sort_blocks (s) /* Constructor/restructor/destructor procedures */ -/* Allocate a new symtab for NAME. Needs an estimate of how many symbols - MAXSYMS and linenumbers MAXLINES we'll put in it */ +/* Allocate a new symtab for NAME. Needs an estimate of how many + linenumbers MAXLINES we'll put in it */ static struct symtab * -new_symtab (name, maxsyms, maxlines, objfile) - char *name; - int maxsyms; - int maxlines; - struct objfile *objfile; +new_symtab (char *name, int maxlines, struct objfile *objfile) { struct symtab *s = allocate_symtab (name, objfile); @@ -4018,36 +4576,35 @@ new_symtab (name, maxsyms, maxlines, objfile) /* All symtabs must have at least two blocks */ BLOCKVECTOR (s) = new_bvect (2); - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms); - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms); + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) + = new_block (NON_FUNCTION_BLOCK); + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) + = new_block (NON_FUNCTION_BLOCK); BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); s->free_code = free_linetable; s->debugformat = obsavestring ("ECOFF", 5, - &objfile -> symbol_obstack); + &objfile->symbol_obstack); return (s); } /* Allocate a new partial_symtab NAME */ static struct partial_symtab * -new_psymtab (name, objfile, section_offsets) - char *name; - struct objfile *objfile; - struct section_offsets *section_offsets; +new_psymtab (char *name, struct objfile *objfile) { struct partial_symtab *psymtab; psymtab = allocate_psymtab (name, objfile); - psymtab->section_offsets = section_offsets; + psymtab->section_offsets = objfile->section_offsets; /* Keep a backpointer to the file's symbols */ psymtab->read_symtab_private = ((char *) obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc))); - memset ((PTR) psymtab->read_symtab_private, 0, sizeof (struct symloc)); + memset (psymtab->read_symtab_private, 0, sizeof (struct symloc)); CUR_BFD (psymtab) = cur_bfd; DEBUG_SWAP (psymtab) = debug_swap; DEBUG_INFO (psymtab) = debug_info; @@ -4064,8 +4621,7 @@ new_psymtab (name, objfile, section_offsets) proper size to allocate. */ static struct linetable * -new_linetable (size) - int size; +new_linetable (int size) { struct linetable *l; @@ -4082,11 +4638,10 @@ new_linetable (size) calculating the proper size to allocate. */ static struct linetable * -shrink_linetable (lt) - struct linetable *lt; +shrink_linetable (struct linetable *lt) { - return (struct linetable *) xrealloc ((PTR) lt, + return (struct linetable *) xrealloc ((void *) lt, (sizeof (struct linetable) + ((lt->nitems - 1) * sizeof (lt->item)))); @@ -4095,8 +4650,7 @@ shrink_linetable (lt) /* Allocate and zero a new blockvector of NBLOCKS blocks. */ static struct blockvector * -new_bvect (nblocks) - int nblocks; +new_bvect (int nblocks) { struct blockvector *bv; int size; @@ -4109,71 +4663,46 @@ new_bvect (nblocks) return bv; } -/* Allocate and zero a new block of MAXSYMS symbols */ +/* Allocate and zero a new block, and set its BLOCK_DICT. If function + is non-zero, assume the block is associated to a function, and make + sure that the symbols are stored linearly; otherwise, store them + hashed. */ static struct block * -new_block (maxsyms) - int maxsyms; +new_block (enum block_type type) { - int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *); - - return (struct block *) xzalloc (size); -} - -/* Ooops, too big. Shrink block B in symtab S to its minimal size. - Shrink_block can also be used by add_symbol to grow a block. */ + /* FIXME: carlton/2003-09-11: This should use allocate_block to + allocate the block. Which, in turn, suggests that the block + should be allocated on an obstack. */ + struct block *retval = xzalloc (sizeof (struct block)); -static struct block * -shrink_block (b, s) - struct block *b; - struct symtab *s; -{ - struct block *new; - struct blockvector *bv = BLOCKVECTOR (s); - int i; + if (type == FUNCTION_BLOCK) + BLOCK_DICT (retval) = dict_create_linear_expandable (); + else + BLOCK_DICT (retval) = dict_create_hashed_expandable (); - /* Just reallocate it and fix references to the old one */ - - new = (struct block *) xrealloc ((PTR) b, - (sizeof (struct block) - + ((BLOCK_NSYMS (b) - 1) - * sizeof (struct symbol *)))); - - /* Should chase pointers to old one. Fortunately, that`s just - the block`s function and inferior blocks */ - if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b) - SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new; - for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) - if (BLOCKVECTOR_BLOCK (bv, i) == b) - BLOCKVECTOR_BLOCK (bv, i) = new; - else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b) - BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new; - return new; + return retval; } /* Create a new symbol with printname NAME */ static struct symbol * -new_symbol (name) - char *name; +new_symbol (char *name) { struct symbol *s = ((struct symbol *) obstack_alloc (¤t_objfile->symbol_obstack, sizeof (struct symbol))); - memset ((PTR) s, 0, sizeof (*s)); - SYMBOL_NAME (s) = obsavestring (name, strlen (name), - ¤t_objfile->symbol_obstack); + memset (s, 0, sizeof (*s)); SYMBOL_LANGUAGE (s) = psymtab_language; - SYMBOL_INIT_DEMANGLED_NAME (s, ¤t_objfile->symbol_obstack); + SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile); return s; } /* Create a new type with printname NAME */ static struct type * -new_type (name) - char *name; +new_type (char *name) { struct type *t; @@ -4189,14 +4718,19 @@ new_type (name) it as normal. */ void -elfmdebug_build_psymtabs (objfile, swap, sec, section_offsets) - struct objfile *objfile; - const struct ecoff_debug_swap *swap; - asection *sec; - struct section_offsets *section_offsets; +elfmdebug_build_psymtabs (struct objfile *objfile, + const struct ecoff_debug_swap *swap, asection *sec) { bfd *abfd = objfile->obfd; struct ecoff_debug_info *info; + struct cleanup *back_to; + + /* FIXME: It's not clear whether we should be getting minimal symbol + information from .mdebug in an ELF file, or whether we will. + Re-initialize the minimal symbol reader in case we do. */ + + init_minimal_symbol_collection (); + back_to = make_cleanup_discard_minimal_symbols (); info = ((struct ecoff_debug_info *) obstack_alloc (&objfile->psymbol_obstack, @@ -4206,7 +4740,10 @@ elfmdebug_build_psymtabs (objfile, swap, sec, section_offsets) error ("Error reading ECOFF debugging information: %s", bfd_errmsg (bfd_get_error ())); - mdebug_build_psymtabs (objfile, swap, info, section_offsets); + mdebug_build_psymtabs (objfile, swap, info); + + install_minimal_symbols (objfile); + do_cleanups (back_to); } @@ -4228,7 +4765,7 @@ elfmdebug_build_psymtabs (objfile, swap, sec, section_offsets) #ifdef TM_MIPS_H void -fixup_sigtramp () +fixup_sigtramp (void) { struct symbol *s; struct symtab *st; @@ -4239,16 +4776,16 @@ fixup_sigtramp () /* We have to handle the following cases here: a) The Mips library has a sigtramp label within sigvec. b) Irix has a _sigtramp which we want to use, but it also has sigvec. */ - s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL); + s = lookup_symbol ("sigvec", 0, VAR_DOMAIN, 0, NULL); if (s != 0) { b0 = SYMBOL_BLOCK_VALUE (s); - s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL); + s = lookup_symbol ("sigtramp", b0, VAR_DOMAIN, 0, NULL); } if (s == 0) { /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */ - s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL); + s = lookup_symbol ("_sigtramp", 0, VAR_DOMAIN, 0, NULL); } /* But maybe this program uses its own version of sigvec */ @@ -4274,14 +4811,14 @@ fixup_sigtramp () * needed info. Note we make it a nested procedure of sigvec, * which is the way the (assembly) code is actually written. */ - SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; + SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = LOC_BLOCK; SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL, st->objfile); TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void; /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */ - b = new_block (1); + b = new_block (NON_FUNCTION_BLOCK); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_START (b) = sigtramp_address; BLOCK_END (b) = sigtramp_end; @@ -4293,8 +4830,8 @@ fixup_sigtramp () /* Make a MIPS_EFI_SYMBOL_NAME entry for it */ { struct mips_extra_func_info *e = - ((struct mips_extra_func_info *) - xzalloc (sizeof (struct mips_extra_func_info))); + ((struct mips_extra_func_info *) + xzalloc (sizeof (struct mips_extra_func_info))); e->numargs = 0; /* the kernel thinks otherwise */ e->pdr.frameoffset = 32; @@ -4318,19 +4855,19 @@ fixup_sigtramp () current_objfile = st->objfile; /* Keep new_symbol happy */ s = new_symbol (MIPS_EFI_SYMBOL_NAME); SYMBOL_VALUE (s) = (long) e; - SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE; + SYMBOL_DOMAIN (s) = LABEL_DOMAIN; SYMBOL_CLASS (s) = LOC_CONST; SYMBOL_TYPE (s) = mdebug_type_void; current_objfile = NULL; } - BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s; + dict_add_symbol (BLOCK_DICT (b), s); } -#endif /* TM_MIPS_H */ +#endif /* TM_MIPS_H */ void -_initialize_mdebugread () +_initialize_mdebugread (void) { mdebug_type_void = init_type (TYPE_CODE_VOID, 1, @@ -4388,7 +4925,7 @@ _initialize_mdebugread () init_type (TYPE_CODE_INT, 8, 0, "long long", (struct objfile *) NULL); - mdebug_type_unsigned_long_long_64 = + mdebug_type_unsigned_long_long_64 = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, "unsigned long long", (struct objfile *) NULL);