X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fmdebugread.c;h=04678168113d29665c0335c2ad07df7a02484a59;hb=8464be768129e057bc92e27de51317b99717da8f;hp=3fa06e5c06bab48df89a4cba2a8ba0b4312ab055;hpb=d6a843b5945deb4cb2df9b07c4f9b19e6fba01de;p=binutils-gdb.git diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index 3fa06e5c06b..04678168113 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1,7 +1,7 @@ /* Read a symbol table in ECOFF format (Third-Eye). Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008 + 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Original version contributed by Alessandro Forin (af@cs.cmu.edu) at @@ -57,6 +57,7 @@ #include "mdebugread.h" #include "gdb_stat.h" #include "gdb_string.h" +#include "psympriv.h" #include "bfd.h" @@ -207,34 +208,6 @@ static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs; static char stabs_symbol[] = STABS_SYMBOL; -/* Types corresponding to mdebug format bt* basic types. */ - -static struct type *mdebug_type_void; -static struct type *mdebug_type_char; -static struct type *mdebug_type_short; -static struct type *mdebug_type_int_32; -#define mdebug_type_int mdebug_type_int_32 -static struct type *mdebug_type_int_64; -static struct type *mdebug_type_long_32; -static struct type *mdebug_type_long_64; -static struct type *mdebug_type_long_long_64; -static struct type *mdebug_type_unsigned_char; -static struct type *mdebug_type_unsigned_short; -static struct type *mdebug_type_unsigned_int_32; -static struct type *mdebug_type_unsigned_int_64; -static struct type *mdebug_type_unsigned_long_32; -static struct type *mdebug_type_unsigned_long_64; -static struct type *mdebug_type_unsigned_long_long_64; -static struct type *mdebug_type_adr_32; -static struct type *mdebug_type_adr_64; -static struct type *mdebug_type_float; -static struct type *mdebug_type_double; -static struct type *mdebug_type_complex; -static struct type *mdebug_type_double_complex; -static struct type *mdebug_type_fixed_dec; -static struct type *mdebug_type_float_dec; -static struct type *mdebug_type_string; - /* Nonzero if we have seen ecoff debugging info for a file. */ static int found_ecoff_debugging_info; @@ -298,7 +271,6 @@ static char *mdebug_next_symbol_text (struct objfile *); static void mdebug_psymtab_to_symtab (struct partial_symtab *pst) { - if (!pst) return; @@ -555,6 +527,16 @@ add_pending (FDR *fh, char *sh, struct type *t) aux symbols are big-endian or little-endian. Return count of SYMR's handled (normally one). */ +static int +mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) +{ + return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); +} + +static const struct symbol_register_ops mdebug_register_funcs = { + mdebug_reg_to_regnum +}; + static int parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, struct section_offsets *section_offsets, struct objfile *objfile) @@ -635,16 +617,16 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, goto data; case stLocal: /* local variable, goes into current block */ + b = top_stack->cur_block; + s = new_symbol (name); + SYMBOL_VALUE (s) = svalue; if (sh->sc == scRegister) { class = LOC_REGISTER; - svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue); + SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; } else class = LOC_LOCAL; - b = top_stack->cur_block; - s = new_symbol (name); - SYMBOL_VALUE (s) = svalue; data: /* Common code for symbols describing data */ SYMBOL_DOMAIN (s) = VAR_DOMAIN; @@ -654,7 +636,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, /* Type could be missing if file is compiled without debugging info. */ if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil || sh->index == indexNil) - SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_data_symbol; + SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol; else SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); /* Value of a data symbol is its memory address */ @@ -677,7 +659,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, case scRegister: /* Pass by value in register. */ SYMBOL_CLASS (s) = LOC_REGISTER; - svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue); + SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; break; case scVar: /* Pass by reference on stack. */ @@ -686,7 +668,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, case scVarRegister: /* Pass by reference in register. */ SYMBOL_CLASS (s) = LOC_REGPARM_ADDR; - svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue); + SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; break; default: /* Pass by value on stack. */ @@ -703,7 +685,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, 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; + SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int; add_symbol (s, top_stack->cur_st, top_stack->cur_block); break; @@ -746,7 +728,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, SYMBOL_CLASS (s) = LOC_BLOCK; /* Type of the return value */ if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) - t = mdebug_type_int; + t = objfile_type (objfile)->builtin_int; else { t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name); @@ -770,6 +752,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (sh->st == stProc) { struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); + /* The next test should normally be true, but provides a hook for nested functions (which we don't want to make global). */ @@ -1015,8 +998,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (sh->iss == 0 || name[0] == '.' || name[0] == '\0') TYPE_TAG_NAME (t) = NULL; else - TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack, - "", "", name); + TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack, name, + (char *) NULL); TYPE_CODE (t) = type_code; TYPE_LENGTH (t) = sh->value; @@ -1156,12 +1139,12 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); SYMBOL_DOMAIN (s) = LABEL_DOMAIN; SYMBOL_CLASS (s) = LOC_CONST; - SYMBOL_TYPE (s) = mdebug_type_void; + SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void; e = ((struct mdebug_extra_func_info *) obstack_alloc (¤t_objfile->objfile_obstack, sizeof (struct mdebug_extra_func_info))); memset (e, 0, sizeof (struct mdebug_extra_func_info)); - SYMBOL_VALUE (s) = (long) e; + SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; e->numargs = top_stack->numargs; e->pdr.framereg = -1; add_symbol (s, top_stack->cur_st, top_stack->cur_block); @@ -1171,6 +1154,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) { struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i); + if (BLOCK_SUPERBLOCK (b_bad) == b && BLOCK_START (b_bad) == top_stack->procadr && BLOCK_END (b_bad) == top_stack->procadr) @@ -1191,6 +1175,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (nparams > 0) { struct dict_iterator iter; + TYPE_NFIELDS (ftype) = nparams; TYPE_FIELDS (ftype) = (struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field)); @@ -1350,6 +1335,179 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, return count; } +/* Basic types. */ + +static const struct objfile_data *basic_type_data; + +static struct type * +basic_type (int bt, struct objfile *objfile) +{ + struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct type **map_bt = objfile_data (objfile, basic_type_data); + struct type *tp; + + if (bt >= btMax) + return NULL; + + if (!map_bt) + { + map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack, + btMax, struct type *); + set_objfile_data (objfile, basic_type_data, map_bt); + } + + if (map_bt[bt]) + return map_bt[bt]; + + switch (bt) + { + case btNil: + tp = objfile_type (objfile)->builtin_void; + break; + + case btAdr: + tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED, + "adr_32", objfile); + TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; + break; + + case btChar: + tp = init_type (TYPE_CODE_INT, 1, 0, + "char", objfile); + break; + + case btUChar: + tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, + "unsigned char", objfile); + break; + + case btShort: + tp = init_type (TYPE_CODE_INT, 2, 0, + "short", objfile); + break; + + case btUShort: + tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, + "unsigned short", objfile); + break; + + case btInt: + tp = init_type (TYPE_CODE_INT, 4, 0, + "int", objfile); + break; + + case btUInt: + tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, + "unsigned int", objfile); + break; + + case btLong: + tp = init_type (TYPE_CODE_INT, 4, 0, + "long", objfile); + break; + + case btULong: + tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, + "unsigned long", objfile); + break; + + case btFloat: + tp = init_type (TYPE_CODE_FLT, + gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "float", objfile); + break; + + case btDouble: + tp = init_type (TYPE_CODE_FLT, + gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "double", objfile); + break; + + case btComplex: + tp = init_type (TYPE_CODE_COMPLEX, + 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "complex", objfile); + TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile); + break; + + case btDComplex: + tp = init_type (TYPE_CODE_COMPLEX, + 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "double complex", objfile); + TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile); + break; + + case btFixedDec: + /* We use TYPE_CODE_INT to print these as integers. Does this do any + good? Would we be better off with TYPE_CODE_ERROR? Should + TYPE_CODE_ERROR print things in hex if it knows the size? */ + tp = init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "fixed decimal", objfile); + break; + + case btFloatDec: + tp = init_type (TYPE_CODE_ERROR, + gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, + "floating decimal", objfile); + break; + + case btString: + /* Is a "string" the way btString means it the same as TYPE_CODE_STRING? + FIXME. */ + tp = init_type (TYPE_CODE_STRING, 1, 0, + "string", objfile); + break; + + case btVoid: + tp = objfile_type (objfile)->builtin_void; + break; + + case btLong64: + tp = init_type (TYPE_CODE_INT, 8, 0, + "long", objfile); + break; + + case btULong64: + tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, + "unsigned long", objfile); + break; + + case btLongLong64: + tp = init_type (TYPE_CODE_INT, 8, 0, + "long long", objfile); + break; + + case btULongLong64: + tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, + "unsigned long long", objfile); + break; + + case btAdr64: + tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED, + "adr_64", objfile); + TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; + break; + + case btInt64: + tp = init_type (TYPE_CODE_INT, 8, 0, + "int", objfile); + break; + + case btUInt64: + tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, + "unsigned int", objfile); + break; + + default: + tp = NULL; + break; + } + + map_bt[bt] = tp; + return tp; +} + /* Parse the type information provided in the raw AX entries for the symbol SH. Return the bitfield size in BS, in case. We must byte-swap the AX entries before we use them; BIGEND says whether @@ -1359,78 +1517,27 @@ static struct type * 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_unsigned_short, /* btUShort */ - &mdebug_type_int_32, /* btInt */ - &mdebug_type_unsigned_int_32, /* btUInt */ - &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_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 */ - &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_unsigned_int_64, /* btUInt64 */ - }; - TIR t[1]; struct type *tp = 0; enum type_code type_code = TYPE_CODE_UNDEF; /* Handle undefined types, they have indexNil. */ if (aux_index == indexNil) - return mdebug_type_int; + return basic_type (btInt, current_objfile); /* Handle corrupt aux indices. */ if (aux_index >= (debug_info->fdr + fd)->caux) { index_complaint (sym_name); - return mdebug_type_int; + return basic_type (btInt, current_objfile); } ax += aux_index; /* Use aux as a type information record, map its basic type. */ (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); - if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt))) + tp = basic_type (t->bt, current_objfile); + if (tp == NULL) { - basic_type_complaint (t->bt, sym_name); - return mdebug_type_int; - } - if (map_bt[t->bt]) - { - tp = *map_bt[t->bt]; - } - else - { - tp = NULL; /* Cannot use builtin types -- build our own */ switch (t->bt) { @@ -1461,7 +1568,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, break; default: basic_type_complaint (t->bt, sym_name); - return mdebug_type_int; + return basic_type (btInt, current_objfile); } } @@ -1471,6 +1578,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, if (t->fBitfield) { int width = AUX_GET_WIDTH (bigend, ax); + /* Inhibit core dumps if TIR is corrupted. */ if (bs == (int *) NULL) { @@ -1478,9 +1586,9 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, as short and unsigned short types with a field width of 8. Enum types also have a field width which we ignore for now. */ if (t->bt == btShort && width == 8) - tp = mdebug_type_char; + tp = basic_type (btChar, current_objfile); else if (t->bt == btUShort && width == 8) - tp = mdebug_type_unsigned_char; + tp = basic_type (btUChar, current_objfile); else if (t->bt == btEnum) ; else @@ -1515,7 +1623,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, { complaint (&symfile_complaints, _("unable to cross ref btIndirect for %s"), sym_name); - return mdebug_type_int; + return basic_type (btInt, current_objfile); } xref_fh = get_rfd (fd, rf); xref_fd = xref_fh - debug_info->fdr; @@ -1558,7 +1666,6 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, } else { - /* Usually, TYPE_CODE(tp) is already type_code. The main exception is if we guessed wrong re struct/union/enum. But for struct vs. union a wrong guess is harmless, so @@ -1632,23 +1739,19 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, { complaint (&symfile_complaints, _("unable to cross ref btTypedef for %s"), sym_name); - tp = mdebug_type_int; + tp = basic_type (btInt, current_objfile); } } /* Deal with range types */ if (t->bt == btRange) { - TYPE_NFIELDS (tp) = 2; - TYPE_FIELDS (tp) = ((struct field *) - TYPE_ALLOC (tp, 2 * sizeof (struct field))); - TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"), - ¤t_objfile->objfile_obstack); - TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax); + TYPE_NFIELDS (tp) = 0; + TYPE_RANGE_DATA (tp) = ((struct range_bounds *) + TYPE_ZALLOC (tp, sizeof (struct range_bounds))); + TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax); ax++; - TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"), - ¤t_objfile->objfile_obstack); - TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax); + TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); ax++; } @@ -1745,7 +1848,7 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, { complaint (&symfile_complaints, _("illegal array index type for %s, assuming int"), sym_name); - indx = mdebug_type_int; + indx = objfile_type (current_objfile)->builtin_int; } /* Get the bounds, and create the array type. */ @@ -1814,10 +1917,8 @@ static void parse_procedure (PDR *pr, struct symtab *search_symtab, struct partial_symtab *pst) { - struct gdbarch *gdbarch = get_objfile_arch (pst->objfile); struct symbol *s, *i; struct block *b; - struct mdebug_extra_func_info *e; char *sh_name; /* Simple rule to find files linked "-x" */ @@ -1869,6 +1970,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab, 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_DOMAIN, 0); cur_fdr = save_cur_fdr; #else @@ -1898,7 +2000,8 @@ parse_procedure (PDR *pr, struct symtab *search_symtab, 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); + SYMBOL_TYPE (s) + = lookup_function_type (objfile_type (pst->objfile)->builtin_int); add_symbol (s, top_stack->cur_st, top_stack->cur_block); /* Wont have symbols for this one */ b = new_block (2); @@ -1917,9 +2020,10 @@ parse_procedure (PDR *pr, struct symtab *search_symtab, if (i) { - e = (struct mdebug_extra_func_info *) SYMBOL_VALUE (i); + struct mdebug_extra_func_info *e; + + e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i); e->pdr = *pr; - e->pdr.isym = (long) s; /* GDB expects the absolute function start address for the procedure descriptor in e->pdr.adr. @@ -1952,7 +2056,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab, if (processing_gcc_compilation == 0 && found_ecoff_debugging_info == 0 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID) - SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_text_symbol; + SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol; } /* Parse the external symbol ES. Just call parse_symbol() after @@ -2300,6 +2404,7 @@ parse_partial_symbols (struct objfile *objfile) fdr_to_pst++; { struct partial_symtab *pst = new_psymtab ("", objfile); + fdr_to_pst[-1].pst = pst; FDR_IDX (pst) = -1; } @@ -2559,9 +2664,8 @@ parse_partial_symbols (struct objfile *objfile) textlow, objfile->global_psymbols.next, objfile->static_psymbols.next); - pst->read_symtab_private = ((char *) - obstack_alloc (&objfile->objfile_obstack, - sizeof (struct symloc))); + pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, + sizeof (struct symloc)); memset (pst->read_symtab_private, 0, sizeof (struct symloc)); save_pst = pst; @@ -2709,6 +2813,7 @@ parse_partial_symbols (struct objfile *objfile) { char *stabstring = debug_info->ss + fh->issBase + sh.iss; int len = strlen (stabstring); + while (stabstring[len - 1] == '\\') { SYMR sh2; @@ -2745,6 +2850,7 @@ parse_partial_symbols (struct objfile *objfile) switch (type_code) { char *p; + /* * Standard, external, non-debugger, symbols */ @@ -2851,7 +2957,7 @@ parse_partial_symbols (struct objfile *objfile) past_first_source_file = 1; if (prev_so_symnum != symnum - 1) - { /* Here if prev stab wasn't N_SO */ + { /* Here if prev stab wasn't N_SO */ first_so_symnum = symnum; if (pst) @@ -2897,6 +3003,7 @@ parse_partial_symbols (struct objfile *objfile) case N_SOL: { enum language tmp_language; + /* Mark down an include file in the current psymtab */ /* SET_NAMESTRING ();*/ @@ -2925,8 +3032,10 @@ parse_partial_symbols (struct objfile *objfile) in a binary tree, if profiling shows this is a major hog). */ if (pst && strcmp (namestring, pst->filename) == 0) continue; + { int i; + for (i = 0; i < includes_used; i++) if (strcmp (namestring, psymtab_include_list[i]) == 0) @@ -2993,7 +3102,7 @@ parse_partial_symbols (struct objfile *objfile) namestring = gdbarch_static_transform_name (gdbarch, namestring); - add_psymbol_to_list (namestring, p - namestring, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_STATIC, &objfile->static_psymbols, 0, sh.value, @@ -3003,7 +3112,7 @@ parse_partial_symbols (struct objfile *objfile) 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, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_STATIC, &objfile->global_psymbols, 0, sh.value, @@ -3021,7 +3130,7 @@ parse_partial_symbols (struct objfile *objfile) || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list (namestring, p - namestring, + add_psymbol_to_list (namestring, p - namestring, 1, STRUCT_DOMAIN, LOC_TYPEDEF, &objfile->static_psymbols, sh.value, 0, @@ -3030,6 +3139,7 @@ parse_partial_symbols (struct objfile *objfile) { /* Also a typedef with the same name. */ add_psymbol_to_list (namestring, p - namestring, + 1, VAR_DOMAIN, LOC_TYPEDEF, &objfile->static_psymbols, sh.value, 0, @@ -3041,7 +3151,7 @@ parse_partial_symbols (struct objfile *objfile) case 't': if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list (namestring, p - namestring, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_TYPEDEF, &objfile->static_psymbols, sh.value, 0, @@ -3103,7 +3213,7 @@ parse_partial_symbols (struct objfile *objfile) ; /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (p, q - p, + add_psymbol_to_list (p, q - p, 1, VAR_DOMAIN, LOC_CONST, &objfile->static_psymbols, 0, 0, psymtab_language, objfile); @@ -3120,7 +3230,7 @@ parse_partial_symbols (struct objfile *objfile) continue; case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (namestring, p - namestring, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_CONST, &objfile->static_psymbols, sh.value, 0, psymtab_language, objfile); @@ -3131,13 +3241,14 @@ parse_partial_symbols (struct objfile *objfile) { 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, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_BLOCK, &objfile->static_psymbols, 0, sh.value, @@ -3152,13 +3263,14 @@ parse_partial_symbols (struct objfile *objfile) { 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, + add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_BLOCK, &objfile->global_psymbols, 0, sh.value, @@ -3387,12 +3499,12 @@ parse_partial_symbols (struct objfile *objfile) symbol table, and the MAIN__ symbol via the minimal symbol table. */ if (sh.st == stProc) - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, VAR_DOMAIN, LOC_BLOCK, &objfile->global_psymbols, 0, sh.value, psymtab_language, objfile); else - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, VAR_DOMAIN, LOC_BLOCK, &objfile->static_psymbols, 0, sh.value, psymtab_language, objfile); @@ -3461,7 +3573,7 @@ parse_partial_symbols (struct objfile *objfile) && sh.iss != 0 && sh.index != cur_sdx + 2) { - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, STRUCT_DOMAIN, LOC_TYPEDEF, &objfile->static_psymbols, 0, (CORE_ADDR) 0, @@ -3502,7 +3614,7 @@ parse_partial_symbols (struct objfile *objfile) continue; } /* Use this gdb symbol */ - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, VAR_DOMAIN, class, &objfile->static_psymbols, 0, sh.value, psymtab_language, objfile); @@ -3578,7 +3690,7 @@ parse_partial_symbols (struct objfile *objfile) break; } name = debug_info->ssext + psh->iss; - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, VAR_DOMAIN, class, &objfile->global_psymbols, 0, svalue, @@ -3741,7 +3853,7 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (name, strlen (name), + add_psymbol_to_list (name, strlen (name), 1, VAR_DOMAIN, LOC_CONST, &objfile->static_psymbols, 0, (CORE_ADDR) 0, psymtab_language, objfile); @@ -3861,6 +3973,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) if (processing_gcc_compilation != 0) { + struct gdbarch *gdbarch = get_objfile_arch (pst->objfile); /* This symbol table contains stabs-in-ecoff entries. */ @@ -3929,16 +4042,16 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) /* Make up special symbol to contain procedure specific info */ struct mdebug_extra_func_info *e = - ((struct mdebug_extra_func_info *) - obstack_alloc (¤t_objfile->objfile_obstack, - sizeof (struct mdebug_extra_func_info))); + ((struct mdebug_extra_func_info *) + obstack_alloc (¤t_objfile->objfile_obstack, + sizeof (struct mdebug_extra_func_info))); struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); memset (e, 0, sizeof (struct mdebug_extra_func_info)); SYMBOL_DOMAIN (s) = LABEL_DOMAIN; SYMBOL_CLASS (s) = LOC_CONST; - SYMBOL_TYPE (s) = mdebug_type_void; - SYMBOL_VALUE (s) = (long) e; + SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void; + SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; e->pdr.framereg = -1; add_symbol_to_list (s, &local_symbols); } @@ -3955,7 +4068,8 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) { /* Handle encoded stab line number. */ valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)); - record_line (current_subfile, sh.index, valu); + record_line (current_subfile, sh.index, + gdbarch_addr_bits_remove (gdbarch, valu)); } } else if (sh.st == stProc || sh.st == stStaticProc @@ -4021,7 +4135,6 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) { /* This symbol table contains ordinary ecoff entries. */ - int f_max; int maxlines; EXTR *ext_ptr; @@ -4574,8 +4687,7 @@ new_symtab (char *name, int maxlines, struct objfile *objfile) BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); s->free_code = free_linetable; - s->debugformat = obsavestring ("ECOFF", 5, - &objfile->objfile_obstack); + s->debugformat = "ECOFF"; return (s); } @@ -4591,9 +4703,8 @@ new_psymtab (char *name, struct objfile *objfile) /* Keep a backpointer to the file's symbols */ - psymtab->read_symtab_private = ((char *) - obstack_alloc (&objfile->objfile_obstack, - sizeof (struct symloc))); + psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, + sizeof (struct symloc)); memset (psymtab->read_symtab_private, 0, sizeof (struct symloc)); CUR_BFD (psymtab) = cur_bfd; DEBUG_SWAP (psymtab) = debug_swap; @@ -4630,7 +4741,6 @@ new_linetable (int size) static struct linetable * shrink_linetable (struct linetable *lt) { - return (struct linetable *) xrealloc ((void *) lt, (sizeof (struct linetable) + ((lt->nitems - 1) @@ -4684,8 +4794,8 @@ new_symbol (char *name) sizeof (struct symbol))); memset (s, 0, sizeof (*s)); - SYMBOL_LANGUAGE (s) = psymtab_language; - SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile); + SYMBOL_SET_LANGUAGE (s, psymtab_language); + SYMBOL_SET_NAMES (s, name, strlen (name), 1, current_objfile); return s; } @@ -4698,7 +4808,7 @@ new_type (char *name) t = alloc_type (current_objfile); TYPE_NAME (t) = name; - TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default; + INIT_CPLUS_SPECIFIC (t); return t; } @@ -4739,115 +4849,5 @@ elfmdebug_build_psymtabs (struct objfile *objfile, void _initialize_mdebugread (void) { - mdebug_type_void = - init_type (TYPE_CODE_VOID, 1, - 0, - "void", (struct objfile *) NULL); - mdebug_type_char = - init_type (TYPE_CODE_INT, 1, - 0, - "char", (struct objfile *) NULL); - mdebug_type_unsigned_char = - init_type (TYPE_CODE_INT, 1, - TYPE_FLAG_UNSIGNED, - "unsigned char", (struct objfile *) NULL); - mdebug_type_short = - init_type (TYPE_CODE_INT, 2, - 0, - "short", (struct objfile *) NULL); - mdebug_type_unsigned_short = - init_type (TYPE_CODE_INT, 2, - TYPE_FLAG_UNSIGNED, - "unsigned short", (struct objfile *) NULL); - mdebug_type_int_32 = - init_type (TYPE_CODE_INT, 4, - 0, - "int", (struct objfile *) NULL); - mdebug_type_unsigned_int_32 = - init_type (TYPE_CODE_INT, 4, - TYPE_FLAG_UNSIGNED, - "unsigned int", (struct objfile *) NULL); - mdebug_type_int_64 = - init_type (TYPE_CODE_INT, 8, - 0, - "int", (struct objfile *) NULL); - mdebug_type_unsigned_int_64 = - init_type (TYPE_CODE_INT, 8, - TYPE_FLAG_UNSIGNED, - "unsigned int", (struct objfile *) NULL); - mdebug_type_long_32 = - init_type (TYPE_CODE_INT, 4, - 0, - "long", (struct objfile *) NULL); - mdebug_type_unsigned_long_32 = - init_type (TYPE_CODE_INT, 4, - TYPE_FLAG_UNSIGNED, - "unsigned long", (struct objfile *) NULL); - mdebug_type_long_64 = - init_type (TYPE_CODE_INT, 8, - 0, - "long", (struct objfile *) NULL); - mdebug_type_unsigned_long_64 = - init_type (TYPE_CODE_INT, 8, - TYPE_FLAG_UNSIGNED, - "unsigned long", (struct objfile *) NULL); - mdebug_type_long_long_64 = - init_type (TYPE_CODE_INT, 8, - 0, - "long long", (struct objfile *) NULL); - mdebug_type_unsigned_long_long_64 = - init_type (TYPE_CODE_INT, 8, - TYPE_FLAG_UNSIGNED, - "unsigned long long", (struct objfile *) NULL); - mdebug_type_adr_32 = - init_type (TYPE_CODE_PTR, 4, - TYPE_FLAG_UNSIGNED, - "adr_32", (struct objfile *) NULL); - TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void; - mdebug_type_adr_64 = - init_type (TYPE_CODE_PTR, 8, - TYPE_FLAG_UNSIGNED, - "adr_64", (struct objfile *) NULL); - TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void; - mdebug_type_float = - init_type (TYPE_CODE_FLT, - gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "float", (struct objfile *) NULL); - mdebug_type_double = - init_type (TYPE_CODE_FLT, - gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "double", (struct objfile *) NULL); - mdebug_type_complex = - init_type (TYPE_CODE_COMPLEX, - 2 * gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "complex", (struct objfile *) NULL); - TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float; - mdebug_type_double_complex = - init_type (TYPE_CODE_COMPLEX, - 2 * gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "double complex", (struct objfile *) NULL); - TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double; - - /* Is a "string" the way btString means it the same as TYPE_CODE_STRING? - FIXME. */ - mdebug_type_string = - init_type (TYPE_CODE_STRING, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "string", - (struct objfile *) NULL); - - /* We use TYPE_CODE_INT to print these as integers. Does this do any - good? Would we be better off with TYPE_CODE_ERROR? Should - TYPE_CODE_ERROR print things in hex if it knows the size? */ - mdebug_type_fixed_dec = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "fixed decimal", - (struct objfile *) NULL); - - mdebug_type_float_dec = - init_type (TYPE_CODE_ERROR, - gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "floating decimal", - (struct objfile *) NULL); + basic_type_data = register_objfile_data (); }