X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcoffread.c;h=1e5cb56fe1a9c853659ba264670007bb3c10de51;hb=1b36a34b7a279d934ee183f3d97562d49b612cc5;hp=669e33de459b82f46ab907f07cd5fdce1773d088;hpb=fbcebcb1cea20cfda8a5f7b8fe48555c83a48160;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/coffread.c b/gdb/coffread.c index 669e33de45..1e5cb56fe1 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -1,6 +1,6 @@ /* Read coff symbol tables and convert to internal format, for GDB. Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu). @@ -8,7 +8,7 @@ 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 + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,9 +17,7 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "symtab.h" @@ -139,19 +137,24 @@ struct coff_symbol extern void stabsread_clear_cache (void); -static struct type *coff_read_struct_type (int, int, int); +static struct type *coff_read_struct_type (int, int, int, + struct objfile *); static struct type *decode_base_type (struct coff_symbol *, - unsigned int, union internal_auxent *); + unsigned int, union internal_auxent *, + struct objfile *); static struct type *decode_type (struct coff_symbol *, unsigned int, - union internal_auxent *); + union internal_auxent *, + struct objfile *); static struct type *decode_function_type (struct coff_symbol *, unsigned int, - union internal_auxent *); + union internal_auxent *, + struct objfile *); -static struct type *coff_read_enum_type (int, int, int); +static struct type *coff_read_enum_type (int, int, int, + struct objfile *); static struct symbol *process_coff_symbol (struct coff_symbol *, union internal_auxent *, @@ -200,7 +203,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip) csi = (struct coff_symfile_info *) csip; name = bfd_get_section_name (abfd, sectp); - if (DEPRECATED_STREQ (name, ".text")) + if (strcmp (name, ".text") == 0) { csi->textaddr = bfd_section_vma (abfd, sectp); csi->textsize += bfd_section_size (abfd, sectp); @@ -209,7 +212,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip) { csi->textsize += bfd_section_size (abfd, sectp); } - else if (DEPRECATED_STREQ (name, ".stabstr")) + else if (strcmp (name, ".stabstr") == 0) { csi->stabstrsect = sectp; } @@ -277,19 +280,9 @@ static int cs_to_section (struct coff_symbol *cs, struct objfile *objfile) { asection *sect = cs_to_bfd_section (cs, objfile); - int off = SECT_OFF_TEXT (objfile); - if (sect != NULL) - { - /* This is the section. Figure out what SECT_OFF_* code it is. */ - if (bfd_get_section_flags (abfd, sect) & SEC_CODE) - off = SECT_OFF_TEXT (objfile); - else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD) - off = SECT_OFF_DATA (objfile); - else - /* Just return the bfd section index. */ - off = sect->index; - } - return off; + if (sect == NULL) + return SECT_OFF_TEXT (objfile); + return sect->index; } /* Return the address of the section of a COFF symbol. */ @@ -371,7 +364,7 @@ coff_start_symtab (char *name) this pointer into last_source_file and we put it in subfiles->name, which end_symtab frees; that's why it must be malloc'd. */ - savestring (name, strlen (name)), + xstrdup (name), /* We never know the directory name for COFF. */ NULL, /* The start address is irrelevant, since we set @@ -390,7 +383,7 @@ complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size) { if (last_source_file != NULL) xfree (last_source_file); - last_source_file = savestring (name, strlen (name)); + last_source_file = xstrdup (name); current_source_start_addr = start_addr; current_source_end_addr = start_addr + size; } @@ -428,7 +421,7 @@ record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address, bfd_section = cs_to_bfd_section (cs, objfile); return prim_record_minimal_symbol_and_info (cs->c_name, address, type, - NULL, section, bfd_section, objfile); + section, bfd_section, objfile); } /* coff_symfile_init () @@ -677,6 +670,8 @@ coff_symfile_finish (struct objfile *objfile) /* Let stabs reader clean up */ stabsread_clear_cache (); + + dwarf2_free_objfile (objfile); } @@ -689,6 +684,7 @@ static void coff_symtab_read (long symtab_offset, unsigned int nsyms, struct objfile *objfile) { + struct gdbarch *gdbarch = get_objfile_arch (objfile); struct context_stack *new; struct coff_symbol coff_symbol; struct coff_symbol *cs = &coff_symbol; @@ -711,6 +707,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, long fcn_line_ptr = 0; int val; CORE_ADDR tmpaddr; + struct minimal_symbol *msym; /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous.... it's hard to know I've really worked around it. The fix should be @@ -761,6 +758,11 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, coff_end_symtab (objfile); coff_start_symtab ("_globals_"); + /* coff_start_symtab will set the language of this symtab to + language_unknown, since such a ``file name'' is not + recognized. Override that with the minimal language to + allow printing values in this symtab. */ + current_subfile->language = language_minimal; complete_symtab ("_globals_", 0, 0); /* done with all files, everything from here on out is globals */ } @@ -832,7 +834,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, case C_THUMBSTATFUNC: if (cs->c_name[0] == '.') { - if (DEPRECATED_STREQ (cs->c_name, ".text")) + if (strcmp (cs->c_name, ".text") == 0) { /* FIXME: don't wire in ".text" as section name or symbol name! */ @@ -903,6 +905,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, } else { + asection *bfd_section = cs_to_bfd_section (cs, objfile); sec = cs_to_section (cs, objfile); tmpaddr = cs->c_value; /* Statics in a PE file also get relocated */ @@ -912,36 +915,34 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, || (pe_file && (cs->c_sclass == C_STAT))) tmpaddr += ANOFFSET (objfile->section_offsets, sec); - if (sec == SECT_OFF_TEXT (objfile)) + if (bfd_section->flags & SEC_CODE) { ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC || cs->c_sclass == C_THUMBEXT ? mst_text : mst_file_text; - tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr); + tmpaddr = gdbarch_smash_text_address (gdbarch, tmpaddr); } - else if (sec == SECT_OFF_DATA (objfile)) + else if (bfd_section->flags & SEC_ALLOC + && bfd_section->flags & SEC_LOAD) { ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? mst_data : mst_file_data; } - else if (sec == SECT_OFF_BSS (objfile)) + else if (bfd_section->flags & SEC_ALLOC) { ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? - mst_data : mst_file_data; + mst_bss : mst_file_bss; } else ms_type = mst_unknown; } - { - struct minimal_symbol *msym; - msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile); - if (msym) - COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym); - } + msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile); + if (msym) + gdbarch_coff_make_msymbol_special (gdbarch, cs->c_sclass, msym); if (SDB_TYPE (cs->c_type)) { @@ -955,7 +956,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, break; case C_FCN: - if (DEPRECATED_STREQ (cs->c_name, ".bf")) + if (strcmp (cs->c_name, ".bf") == 0) { within_function = 1; @@ -977,7 +978,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, new->name = process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile); } - else if (DEPRECATED_STREQ (cs->c_name, ".ef")) + else if (strcmp (cs->c_name, ".ef") == 0) { if (!within_function) error (_("Bad coff function information.")); @@ -1030,22 +1031,9 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, finish_block (new->name, &local_symbols, new->old_blocks, new->start_addr, -#if defined (FUNCTION_EPILOGUE_SIZE) - /* This macro should be defined only on - machines where the - fcn_aux_saved.x_sym.x_misc.x_fsize - field is always zero. - So use the .bf record information that - points to the epilogue and add the size - of the epilogue. */ - cs->c_value - + FUNCTION_EPILOGUE_SIZE - + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), -#else fcn_cs_saved.c_value + fcn_aux_saved.x_sym.x_misc.x_fsize + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), -#endif objfile ); within_function = 0; @@ -1053,13 +1041,13 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, break; case C_BLOCK: - if (DEPRECATED_STREQ (cs->c_name, ".bb")) + if (strcmp (cs->c_name, ".bb") == 0) { tmpaddr = cs->c_value; tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); push_context (++depth, tmpaddr); } - else if (DEPRECATED_STREQ (cs->c_name, ".eb")) + else if (strcmp (cs->c_name, ".eb") == 0) { if (context_stack_depth <= 0) { /* We attempted to pop an empty context stack */ @@ -1098,7 +1086,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms, if ((nsyms == 0) && (pe_file)) { - /* We've got no debugging symbols, but it's is a portable + /* We've got no debugging symbols, but it's a portable executable, so try to read the export table */ read_pe_exported_syms (objfile); } @@ -1126,20 +1114,29 @@ read_one_sym (struct coff_symbol *cs, union internal_auxent *aux) { int i; + bfd_size_type bytes; cs->c_symnum = symnum; - bfd_bread (temp_sym, local_symesz, nlist_bfd_global); + bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global); + if (bytes != local_symesz) + error ("%s: error reading symbols", current_objfile->name); bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym); cs->c_naux = sym->n_numaux & 0xff; if (cs->c_naux >= 1) { - bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); + bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); + if (bytes != local_auxesz) + error ("%s: error reading symbols", current_objfile->name); bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass, 0, cs->c_naux, (char *) aux); /* If more than one aux entry, read past it (only the first aux is important). */ for (i = 1; i < cs->c_naux; i++) - bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); + { + bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); + if (bytes != local_auxesz) + error ("%s: error reading symbols", current_objfile->name); + } } cs->c_name = getsymname (sym); cs->c_value = sym->n_value; @@ -1437,15 +1434,15 @@ patch_opaque_types (struct symtab *s) TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0) { - char *name = DEPRECATED_SYMBOL_NAME (real_sym); + char *name = SYMBOL_LINKAGE_NAME (real_sym); int hash = hashname (name); struct symbol *sym, *prev; prev = 0; for (sym = opaque_type_chain[hash]; sym;) { - if (name[0] == DEPRECATED_SYMBOL_NAME (sym)[0] && - strcmp (name + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0) + if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0] && + strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0) { if (prev) { @@ -1490,7 +1487,7 @@ process_coff_symbol (struct coff_symbol *cs, memset (sym, 0, sizeof (struct symbol)); name = cs->c_name; name = EXTERNAL_NAME (name, objfile->obfd); - SYMBOL_LANGUAGE (sym) = language_auto; + SYMBOL_LANGUAGE (sym) = current_subfile->language; SYMBOL_SET_NAMES (sym, name, strlen (name), objfile); /* default assumptions */ @@ -1502,7 +1499,7 @@ process_coff_symbol (struct coff_symbol *cs, { SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); SYMBOL_TYPE (sym) = - lookup_function_type (decode_function_type (cs, cs->c_type, aux)); + lookup_function_type (decode_function_type (cs, cs->c_type, aux, objfile)); SYMBOL_CLASS (sym) = LOC_BLOCK; if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT @@ -1514,7 +1511,7 @@ process_coff_symbol (struct coff_symbol *cs, } else { - SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux); + SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile); switch (cs->c_sclass) { case C_NULL: @@ -1557,7 +1554,8 @@ process_coff_symbol (struct coff_symbol *cs, #endif case C_REG: SYMBOL_CLASS (sym) = LOC_REGISTER; - SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value); + SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum + (current_gdbarch, cs->c_value); add_symbol_to_list (sym, &local_symbols); break; @@ -1567,52 +1565,16 @@ process_coff_symbol (struct coff_symbol *cs, case C_ARG: SYMBOL_CLASS (sym) = LOC_ARG; + SYMBOL_IS_ARGUMENT (sym) = 1; add_symbol_to_list (sym, &local_symbols); -#if !defined (BELIEVE_PCC_PROMOTION) - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) - { - /* If PCC says a parameter is a short or a char, - aligned on an int boundary, realign it to the - "little end" of the int. */ - struct type *temptype; - temptype = lookup_fundamental_type (current_objfile, - FT_INTEGER); - if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype) - && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT - && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype)) - { - SYMBOL_VALUE (sym) += - TYPE_LENGTH (temptype) - - TYPE_LENGTH (SYMBOL_TYPE (sym)); - } - } -#endif break; case C_REGPARM: - SYMBOL_CLASS (sym) = LOC_REGPARM; - SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value); + SYMBOL_CLASS (sym) = LOC_REGISTER; + SYMBOL_IS_ARGUMENT (sym) = 1; + SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum + (current_gdbarch, cs->c_value); add_symbol_to_list (sym, &local_symbols); -#if !defined (BELIEVE_PCC_PROMOTION) - /* FIXME: This should retain the current type, since it's just - a register value. gnu@adobe, 26Feb93 */ - { - /* If PCC says a parameter is a short or a char, - it is really an int. */ - struct type *temptype; - temptype = - lookup_fundamental_type (current_objfile, FT_INTEGER); - if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype) - && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT) - { - SYMBOL_TYPE (sym) = - (TYPE_UNSIGNED (SYMBOL_TYPE (sym)) - ? lookup_fundamental_type (current_objfile, - FT_UNSIGNED_INTEGER) - : temptype); - } - } -#endif break; case C_TPDEF: @@ -1647,7 +1609,7 @@ process_coff_symbol (struct coff_symbol *cs, } else TYPE_NAME (SYMBOL_TYPE (sym)) = - concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL); + concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL); } /* Keep track of any type which points to empty structured type, @@ -1660,7 +1622,7 @@ process_coff_symbol (struct coff_symbol *cs, TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) != TYPE_CODE_UNDEF) { - int i = hashname (DEPRECATED_SYMBOL_NAME (sym)); + int i = hashname (SYMBOL_LINKAGE_NAME (sym)); SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i]; opaque_type_chain[i] = sym; @@ -1678,11 +1640,11 @@ process_coff_symbol (struct coff_symbol *cs, names for anonymous enums, structures, and unions, like "~0fake" or ".0fake". Thanks, but no thanks... */ if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0) - if (DEPRECATED_SYMBOL_NAME (sym) != NULL - && *DEPRECATED_SYMBOL_NAME (sym) != '~' - && *DEPRECATED_SYMBOL_NAME (sym) != '.') + if (SYMBOL_LINKAGE_NAME (sym) != NULL + && *SYMBOL_LINKAGE_NAME (sym) != '~' + && *SYMBOL_LINKAGE_NAME (sym) != '.') TYPE_TAG_NAME (SYMBOL_TYPE (sym)) = - concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL); + concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL); add_symbol_to_list (sym, &file_symbols); break; @@ -1698,7 +1660,7 @@ process_coff_symbol (struct coff_symbol *cs, static struct type * decode_type (struct coff_symbol *cs, unsigned int c_type, - union internal_auxent *aux) + union internal_auxent *aux, struct objfile *objfile) { struct type *type = 0; unsigned int new_c_type; @@ -1708,12 +1670,12 @@ decode_type (struct coff_symbol *cs, unsigned int c_type, new_c_type = DECREF (c_type); if (ISPTR (c_type)) { - type = decode_type (cs, new_c_type, aux); + type = decode_type (cs, new_c_type, aux, objfile); type = lookup_pointer_type (type); } else if (ISFCN (c_type)) { - type = decode_type (cs, new_c_type, aux); + type = decode_type (cs, new_c_type, aux, objfile); type = lookup_function_type (type); } else if (ISARY (c_type)) @@ -1735,8 +1697,8 @@ decode_type (struct coff_symbol *cs, unsigned int c_type, *dim = *(dim + 1); *dim = 0; - base_type = decode_type (cs, new_c_type, aux); - index_type = lookup_fundamental_type (current_objfile, FT_INTEGER); + base_type = decode_type (cs, new_c_type, aux, objfile); + index_type = builtin_type_int32; range_type = create_range_type ((struct type *) NULL, index_type, 0, n - 1); type = @@ -1771,7 +1733,7 @@ decode_type (struct coff_symbol *cs, unsigned int c_type, } } - return decode_base_type (cs, BTYPE (c_type), aux); + return decode_base_type (cs, BTYPE (c_type), aux, objfile); } /* Decode a coff type specifier for function definition; @@ -1779,58 +1741,60 @@ decode_type (struct coff_symbol *cs, unsigned int c_type, static struct type * decode_function_type (struct coff_symbol *cs, unsigned int c_type, - union internal_auxent *aux) + union internal_auxent *aux, struct objfile *objfile) { if (aux->x_sym.x_tagndx.l == 0) cs->c_naux = 0; /* auxent refers to function, not base type */ - return decode_type (cs, DECREF (c_type), aux); + return decode_type (cs, DECREF (c_type), aux, objfile); } /* basic C types */ static struct type * decode_base_type (struct coff_symbol *cs, unsigned int c_type, - union internal_auxent *aux) + union internal_auxent *aux, struct objfile *objfile) { + struct gdbarch *gdbarch = get_objfile_arch (objfile); struct type *type; switch (c_type) { case T_NULL: /* shows up with "void (*foo)();" structure members */ - return lookup_fundamental_type (current_objfile, FT_VOID); + return builtin_type (gdbarch)->builtin_void; #ifdef T_VOID case T_VOID: /* Intel 960 COFF has this symbol and meaning. */ - return lookup_fundamental_type (current_objfile, FT_VOID); + return builtin_type (gdbarch)->builtin_void; #endif case T_CHAR: - return lookup_fundamental_type (current_objfile, FT_CHAR); + return builtin_type (gdbarch)->builtin_char; case T_SHORT: - return lookup_fundamental_type (current_objfile, FT_SHORT); + return builtin_type (gdbarch)->builtin_short; case T_INT: - return lookup_fundamental_type (current_objfile, FT_INTEGER); + return builtin_type (gdbarch)->builtin_int; case T_LONG: if (cs->c_sclass == C_FIELD - && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT) - return lookup_fundamental_type (current_objfile, FT_LONG_LONG); + && aux->x_sym.x_misc.x_lnsz.x_size + > gdbarch_long_bit (gdbarch)) + return builtin_type (gdbarch)->builtin_long_long; else - return lookup_fundamental_type (current_objfile, FT_LONG); + return builtin_type (gdbarch)->builtin_long; case T_FLOAT: - return lookup_fundamental_type (current_objfile, FT_FLOAT); + return builtin_type (gdbarch)->builtin_float; case T_DOUBLE: - return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT); + return builtin_type (gdbarch)->builtin_double; case T_LNGDBL: - return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT); + return builtin_type (gdbarch)->builtin_long_double; case T_STRUCT: if (cs->c_naux != 1) @@ -1852,7 +1816,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type, { type = coff_read_struct_type (cs->c_symnum, aux->x_sym.x_misc.x_lnsz.x_size, - aux->x_sym.x_fcnary.x_fcn.x_endndx.l); + aux->x_sym.x_fcnary.x_fcn.x_endndx.l, + objfile); } return type; @@ -1875,7 +1840,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type, { type = coff_read_struct_type (cs->c_symnum, aux->x_sym.x_misc.x_lnsz.x_size, - aux->x_sym.x_fcnary.x_fcn.x_endndx.l); + aux->x_sym.x_fcnary.x_fcn.x_endndx.l, + objfile); } TYPE_CODE (type) = TYPE_CODE_UNION; return type; @@ -1899,7 +1865,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type, { type = coff_read_enum_type (cs->c_symnum, aux->x_sym.x_misc.x_lnsz.x_size, - aux->x_sym.x_fcnary.x_fcn.x_endndx.l); + aux->x_sym.x_fcnary.x_fcn.x_endndx.l, + objfile); } return type; @@ -1908,23 +1875,24 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type, break; case T_UCHAR: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR); + return builtin_type (gdbarch)->builtin_unsigned_char; case T_USHORT: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT); + return builtin_type (gdbarch)->builtin_unsigned_short; case T_UINT: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER); + return builtin_type (gdbarch)->builtin_unsigned_int; case T_ULONG: if (cs->c_sclass == C_FIELD - && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT) - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG); + && aux->x_sym.x_misc.x_lnsz.x_size + > gdbarch_long_bit (gdbarch)) + return builtin_type (gdbarch)->builtin_unsigned_long_long; else - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG); + return builtin_type (gdbarch)->builtin_unsigned_long; } complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name); - return lookup_fundamental_type (current_objfile, FT_VOID); + return builtin_type (gdbarch)->builtin_void; } /* This page contains subroutines of read_type. */ @@ -1933,7 +1901,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type, object describing the type. */ static struct type * -coff_read_struct_type (int index, int length, int lastsym) +coff_read_struct_type (int index, int length, int lastsym, + struct objfile *objfile) { struct nextfield { @@ -1962,7 +1931,7 @@ coff_read_struct_type (int index, int length, int lastsym) { read_one_sym (ms, &sub_sym, &sub_aux); name = ms->c_name; - name = EXTERNAL_NAME (name, current_objfile->obfd); + name = EXTERNAL_NAME (name, objfile->obfd); switch (ms->c_sclass) { @@ -1976,13 +1945,11 @@ coff_read_struct_type (int index, int length, int lastsym) /* Save the data. */ list->field.name = - obsavestring (name, - strlen (name), - ¤t_objfile->objfile_obstack); - FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); - FIELD_BITPOS (list->field) = 8 * ms->c_value; + obsavestring (name, strlen (name), &objfile->objfile_obstack); + FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, + objfile); + SET_FIELD_BITPOS (list->field, 8 * ms->c_value); FIELD_BITSIZE (list->field) = 0; - FIELD_STATIC_KIND (list->field) = 0; nfields++; break; @@ -1995,13 +1962,11 @@ coff_read_struct_type (int index, int length, int lastsym) /* Save the data. */ list->field.name = - obsavestring (name, - strlen (name), - ¤t_objfile->objfile_obstack); - FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); - FIELD_BITPOS (list->field) = ms->c_value; + obsavestring (name, strlen (name), &objfile->objfile_obstack); + FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, + objfile); + SET_FIELD_BITPOS (list->field, ms->c_value); FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size; - FIELD_STATIC_KIND (list->field) = 0; nfields++; break; @@ -2029,8 +1994,10 @@ coff_read_struct_type (int index, int length, int lastsym) Also defines the symbols that represent the values of the type. */ static struct type * -coff_read_enum_type (int index, int length, int lastsym) +coff_read_enum_type (int index, int length, int lastsym, + struct objfile *objfile) { + struct gdbarch *gdbarch = get_objfile_arch (objfile); struct symbol *sym; struct type *type; int nsyms = 0; @@ -2058,19 +2025,18 @@ coff_read_enum_type (int index, int length, int lastsym) { read_one_sym (ms, &sub_sym, &sub_aux); name = ms->c_name; - name = EXTERNAL_NAME (name, current_objfile->obfd); + name = EXTERNAL_NAME (name, objfile->obfd); switch (ms->c_sclass) { case C_MOE: sym = (struct symbol *) obstack_alloc - (¤t_objfile->objfile_obstack, - sizeof (struct symbol)); + (&objfile->objfile_obstack, sizeof (struct symbol)); memset (sym, 0, sizeof (struct symbol)); - DEPRECATED_SYMBOL_NAME (sym) = - obsavestring (name, strlen (name), - ¤t_objfile->objfile_obstack); + SYMBOL_SET_LINKAGE_NAME (sym, + obsavestring (name, strlen (name), + &objfile->objfile_obstack)); SYMBOL_CLASS (sym) = LOC_CONST; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_VALUE (sym) = ms->c_value; @@ -2091,8 +2057,8 @@ coff_read_enum_type (int index, int length, int lastsym) if (length > 0) TYPE_LENGTH (type) = length; - else - TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */ + else /* Assume ints. */ + TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; TYPE_CODE (type) = TYPE_CODE_ENUM; TYPE_NFIELDS (type) = nsyms; TYPE_FIELDS (type) = (struct field *) @@ -2116,19 +2082,18 @@ coff_read_enum_type (int index, int length, int lastsym) { struct symbol *xsym = syms->symbol[j]; SYMBOL_TYPE (xsym) = type; - TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym); - TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym); + TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym); + SET_FIELD_BITPOS (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym)); if (SYMBOL_VALUE (xsym) < 0) unsigned_enum = 0; TYPE_FIELD_BITSIZE (type, n) = 0; - TYPE_FIELD_STATIC_KIND (type, n) = 0; } if (syms == osyms) break; } if (unsigned_enum) - TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (type) = 1; return type; } @@ -2143,6 +2108,9 @@ static struct sym_fns coff_sym_fns = coff_symfile_read, /* sym_read: read a symbol file into symtab */ coff_symfile_finish, /* sym_finish: finished with file, cleanup */ default_symfile_offsets, /* sym_offsets: xlate external to internal form */ + default_symfile_segments, /* sym_segments: Get segment information from + a file. */ + NULL, /* sym_read_linetable */ NULL /* next: pointer to next struct sym_fns */ };