X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fcoffread.c;h=e591651df37b59e65518a8750dae4aac69a654f3;hb=d3ecddab5fc036fb57588a9bfff73575dc419052;hp=bc266fb60e30bd378572be76e98ae0e12b418503;hpb=e86ca25fd6cc06488c9dda936cf83f0fcdf6b58b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/coffread.c b/gdb/coffread.c index bc266fb60e..e591651df3 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -1,5 +1,5 @@ /* Read coff symbol tables and convert to internal format, for GDB. - Copyright (C) 1987-2018 Free Software Foundation, Inc. + Copyright (C) 1987-2019 Free Software Foundation, Inc. Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu). This file is part of GDB. @@ -30,8 +30,7 @@ #include "coff/internal.h" /* Internal format of COFF symbols in BFD */ #include "libcoff.h" /* FIXME secret internal data from BFD */ #include "objfiles.h" -#include "buildsym.h" -#include "gdb-stabs.h" +#include "buildsym-legacy.h" #include "stabsread.h" #include "complaints.h" #include "target.h" @@ -43,26 +42,26 @@ #include "psymtab.h" #include "build-id.h" -/* Key for COFF-associated data. */ - -static const struct objfile_data *coff_objfile_data_key; - /* The objfile we are currently reading. */ static struct objfile *coffread_objfile; struct coff_symfile_info { - file_ptr min_lineno_offset; /* Where in file lowest line#s are. */ - file_ptr max_lineno_offset; /* 1+last byte of line#s in file. */ - - CORE_ADDR textaddr; /* Addr of .text section. */ - unsigned int textsize; /* Size of .text section. */ - struct stab_section_list *stabsects; /* .stab sections. */ - asection *stabstrsect; /* Section pointer for .stab section. */ - char *stabstrdata; + file_ptr min_lineno_offset = 0; /* Where in file lowest line#s are. */ + file_ptr max_lineno_offset = 0; /* 1+last byte of line#s in file. */ + + CORE_ADDR textaddr = 0; /* Addr of .text section. */ + unsigned int textsize = 0; /* Size of .text section. */ + std::vector *stabsects; /* .stab sections. */ + asection *stabstrsect = nullptr; /* Section pointer for .stab section. */ + char *stabstrdata = nullptr; }; +/* Key for COFF-associated data. */ + +static const struct objfile_key coff_objfile_data_key; + /* Translate an external name string into a user-visible name. */ #define EXTERNAL_NAME(string, abfd) \ (string[0] == bfd_get_symbol_leading_char (abfd) \ @@ -155,6 +154,12 @@ static int type_vector_length; #define INITIAL_TYPE_VECTOR_LENGTH 160 +static char *linetab = NULL; +static long linetab_offset; +static unsigned long linetab_size; + +static char *stringtab = NULL; + extern void stabsread_clear_cache (void); static struct type *coff_read_struct_type (int, int, int, @@ -185,21 +190,13 @@ static void patch_opaque_types (struct symtab *); static void enter_linenos (long, int, int, struct objfile *); -static void free_linetab (void); - -static void free_linetab_cleanup (void *ignore); - -static int init_lineno (bfd *, long, int); +static int init_lineno (bfd *, long, int, gdb::unique_xmalloc_ptr *); static char *getsymname (struct internal_syment *); static const char *coff_getfilename (union internal_auxent *); -static void free_stringtab (void); - -static void free_stringtab_cleanup (void *ignore); - -static int init_stringtab (bfd *, long); +static int init_stringtab (bfd *, long, gdb::unique_xmalloc_ptr *); static void read_one_sym (struct coff_symbol *, struct internal_syment *, @@ -225,15 +222,15 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip) const char *name; csi = (struct coff_symfile_info *) csip; - name = bfd_get_section_name (abfd, sectp); + name = bfd_section_name (sectp); if (strcmp (name, ".text") == 0) { - csi->textaddr = bfd_section_vma (abfd, sectp); - csi->textsize += bfd_section_size (abfd, sectp); + csi->textaddr = bfd_section_vma (sectp); + csi->textsize += bfd_section_size (sectp); } else if (startswith (name, ".text")) { - csi->textsize += bfd_section_size (abfd, sectp); + csi->textsize += bfd_section_size (sectp); } else if (strcmp (name, ".stabstr") == 0) { @@ -249,21 +246,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip) if (!isdigit (*s)) break; if (*s == '\0') - { - struct stab_section_list *n, **pn; - - n = XNEW (struct stab_section_list); - n->section = sectp; - n->next = NULL; - for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next) - ; - *pn = n; - - /* This will be run after coffstab_build_psymtabs is called - in coff_symfile_read, at which point we no longer need - the information. */ - make_cleanup (xfree, n); - } + csi->stabsects->push_back (sectp); } } @@ -324,7 +307,7 @@ cs_section_address (struct coff_symbol *cs, bfd *abfd) args.resultp = § bfd_map_over_sections (abfd, find_targ_sec, &args); if (sect != NULL) - addr = bfd_get_section_vma (abfd, sect); + addr = bfd_section_vma (sect); return addr; } @@ -383,15 +366,13 @@ coff_alloc_type (int index) static void coff_start_symtab (struct objfile *objfile, const char *name) { + within_function = 0; start_symtab (objfile, - /* We fill in the filename later. start_symtab puts 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. */ - xstrdup (name), + name, /* We never know the directory name for COFF. */ NULL, - /* The start address is irrelevant, since we set - last_source_start_addr in coff_end_symtab. */ + /* The start address is irrelevant, since we call + set_last_source_start_addr in coff_end_symtab. */ 0, /* Let buildsym.c deduce the language for this symtab. */ language_unknown); @@ -420,7 +401,7 @@ complete_symtab (const char *name, CORE_ADDR start_addr, unsigned int size) static void coff_end_symtab (struct objfile *objfile) { - last_source_start_addr = current_source_start_addr; + set_last_source_start_addr (current_source_start_addr); end_symtab (current_source_end_addr, SECT_OFF_TEXT (objfile)); @@ -436,7 +417,7 @@ static int is_import_fixup_symbol (struct coff_symbol *cs, enum minimal_symbol_type type) { - /* The following is a bit of a heuristic using the characterictics + /* The following is a bit of a heuristic using the characteristics of these fixup symbols, but should work well in practice... */ int i; @@ -475,13 +456,13 @@ record_minimal_symbol (minimal_symbol_reader &reader, { /* Because the value of these symbols is within a function code range, these symbols interfere with the symbol-from-address - reverse lookup; this manifests itselfs in backtraces, or any + reverse lookup; this manifests itself in backtraces, or any other commands that prints symbolic addresses. Just pretend these symbols do not exist. */ return NULL; } - return reader.record_with_info (cs->c_name, address, type, section); + return reader.record_full (cs->c_name, true, address, type, section); } /* coff_symfile_init () @@ -501,16 +482,8 @@ record_minimal_symbol (minimal_symbol_reader &reader, static void coff_symfile_init (struct objfile *objfile) { - struct dbx_symfile_info *dbx; - struct coff_symfile_info *coff; - - /* Allocate struct to keep track of stab reading. */ - dbx = XCNEW (struct dbx_symfile_info); - set_objfile_data (objfile, dbx_objfile_data_key, dbx); - /* Allocate struct to keep track of the symfile. */ - coff = XCNEW (struct coff_symfile_info); - set_objfile_data (objfile, coff_objfile_data_key, coff); + coff_objfile_data_key.emplace (objfile); /* COFF objects may be reordered, so set OBJF_REORDERED. If we find this causes a significant slowdown in gdb then we could @@ -564,18 +537,20 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) struct coff_symfile_info *info; bfd *abfd = objfile->obfd; coff_data_type *cdata = coff_data (abfd); - char *name = bfd_get_filename (abfd); + const char *filename = bfd_get_filename (abfd); int val; unsigned int num_symbols; int symtab_offset; int stringtab_offset; - struct cleanup *back_to; int stabstrsize; - info = (struct coff_symfile_info *) objfile_data (objfile, - coff_objfile_data_key); + info = coff_objfile_data_key.get (objfile); symfile_bfd = abfd; /* Kludge for swap routines. */ + std::vector stabsects; + scoped_restore restore_stabsects + = make_scoped_restore (&info->stabsects, &stabsects); + /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ num_symbols = bfd_get_symcount (abfd); /* How many syms */ symtab_offset = cdata->sym_filepos; /* Symbol table file offset */ @@ -594,10 +569,10 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) /* Allocate space for raw symbol and aux entries, based on their space requirements as reported by BFD. */ - temp_sym = (char *) xmalloc - (cdata->local_symesz + cdata->local_auxesz); + gdb::def_vector temp_storage (cdata->local_symesz + + cdata->local_auxesz); + temp_sym = temp_storage.data (); temp_aux = temp_sym + cdata->local_symesz; - back_to = make_cleanup (free_current_contents, &temp_sym); /* We need to know whether this is a PE file, because in PE files, unlike standard COFF files, symbol values are stored as offsets @@ -627,24 +602,27 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) can avoid spurious error messages (and maybe run a little faster!) by not even reading the line number table unless we have symbols. */ + scoped_restore restore_linetab = make_scoped_restore (&linetab); + gdb::unique_xmalloc_ptr linetab_storage; if (num_symbols > 0) { /* Read the line number table, all at once. */ bfd_map_over_sections (abfd, find_linenos, (void *) info); - make_cleanup (free_linetab_cleanup, 0 /*ignore*/); val = init_lineno (abfd, info->min_lineno_offset, - info->max_lineno_offset - info->min_lineno_offset); + info->max_lineno_offset - info->min_lineno_offset, + &linetab_storage); if (val < 0) - error (_("\"%s\": error reading line numbers."), name); + error (_("\"%s\": error reading line numbers."), filename); } /* Now read the string table, all at once. */ - make_cleanup (free_stringtab_cleanup, 0 /*ignore*/); - val = init_stringtab (abfd, stringtab_offset); + scoped_restore restore_stringtab = make_scoped_restore (&stringtab); + gdb::unique_xmalloc_ptr stringtab_storage; + val = init_stringtab (abfd, stringtab_offset, &stringtab_storage); if (val < 0) - error (_("\"%s\": can't get string table"), name); + error (_("\"%s\": can't get string table"), filename); minimal_symbol_reader reader (objfile); @@ -660,11 +638,9 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) if (pe_file) { - struct minimal_symbol *msym; - - ALL_OBJFILE_MSYMBOLS (objfile, msym) + for (minimal_symbol *msym : objfile->msymbols ()) { - const char *name = MSYMBOL_LINKAGE_NAME (msym); + const char *name = msym->linkage_name (); /* If the minimal symbols whose name are prefixed by "__imp_" or "_imp_", get rid of the prefix, and search the minimal @@ -702,24 +678,24 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) if (!(objfile->flags & OBJF_READNEVER)) bfd_map_over_sections (abfd, coff_locate_sections, (void *) info); - if (info->stabsects) + if (!info->stabsects->empty()) { if (!info->stabstrsect) { error (_("The debugging information in `%s' is corrupted.\nThe " "file has a `.stabs' section, but no `.stabstr' section."), - name); + filename); } /* FIXME: dubious. Why can't we use something normal like bfd_get_section_contents? */ bfd_seek (abfd, abfd->where, 0); - stabstrsize = bfd_section_size (abfd, info->stabstrsect); + stabstrsize = bfd_section_size (info->stabstrsect); coffstab_build_psymtabs (objfile, info->textaddr, info->textsize, - info->stabsects, + *info->stabsects, info->stabstrsect->filepos, stabstrsize); } if (dwarf2_has_info (objfile, NULL)) @@ -740,14 +716,12 @@ coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) if (!debugfile.empty ()) { - gdb_bfd_ref_ptr abfd (symfile_bfd_open (debugfile.c_str ())); + gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (debugfile.c_str ())); - symbol_file_add_separate (abfd.get (), debugfile.c_str (), + symbol_file_add_separate (debug_bfd.get (), debugfile.c_str (), symfile_flags, objfile); } } - - do_cleanups (back_to); } static void @@ -766,8 +740,6 @@ coff_symfile_finish (struct objfile *objfile) { /* Let stabs reader clean up. */ stabsread_clear_cache (); - - dwarf2_free_objfile (objfile); } @@ -782,7 +754,7 @@ coff_symtab_read (minimal_symbol_reader &reader, struct objfile *objfile) { struct gdbarch *gdbarch = get_objfile_arch (objfile); - struct context_stack *newobj; + struct context_stack *newobj = nullptr; struct coff_symbol coff_symbol; struct coff_symbol *cs = &coff_symbol; static struct internal_syment main_sym; @@ -805,6 +777,8 @@ coff_symtab_read (minimal_symbol_reader &reader, CORE_ADDR tmpaddr; struct minimal_symbol *msym; + scoped_free_pendings free_pending; + /* 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 harmless, anyway). The symptom of the bug is that the first @@ -856,7 +830,7 @@ coff_symtab_read (minimal_symbol_reader &reader, 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; + get_current_subfile ()->language = language_minimal; complete_symtab ("_globals_", 0, 0); /* Done with all files, everything from here on out is globals. */ @@ -876,8 +850,10 @@ coff_symtab_read (minimal_symbol_reader &reader, int section = cs_to_section (cs, objfile); tmpaddr = cs->c_value; - record_minimal_symbol (reader, cs, tmpaddr, mst_text, - section, objfile); + /* Don't record unresolved symbols. */ + if (!(cs->c_secnum <= 0 && cs->c_value == 0)) + record_minimal_symbol (reader, cs, tmpaddr, mst_text, + section, objfile); fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr; fcn_start_addr = tmpaddr; @@ -1089,7 +1065,7 @@ coff_symtab_read (minimal_symbol_reader &reader, /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno contains number of lines to '}' */ - if (context_stack_depth <= 0) + if (outermost_context_p ()) { /* We attempted to pop an empty context stack. */ complaint (_("`.ef' symbol without matching `.bf' " "symbol ignored starting at symnum %d"), @@ -1098,9 +1074,9 @@ coff_symtab_read (minimal_symbol_reader &reader, break; } - newobj = pop_context (); + struct context_stack cstk = pop_context (); /* Stack must be empty now. */ - if (context_stack_depth > 0 || newobj == NULL) + if (!outermost_context_p () || newobj == NULL) { complaint (_("Unmatched .ef symbol(s) ignored " "starting at symnum %d"), @@ -1126,15 +1102,15 @@ coff_symtab_read (minimal_symbol_reader &reader, of the closing '}', and for which we do not have any other statement-line-number. */ if (fcn_last_line == 1) - record_line (current_subfile, fcn_first_line, + record_line (get_current_subfile (), fcn_first_line, gdbarch_addr_bits_remove (gdbarch, fcn_first_line_addr)); else enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line, objfile); - finish_block (newobj->name, &local_symbols, newobj->old_blocks, - NULL, newobj->start_addr, + finish_block (cstk.name, cstk.old_blocks, + NULL, cstk.start_addr, fcn_cs_saved.c_value + fcn_aux_saved.x_sym.x_misc.x_fsize + ANOFFSET (objfile->section_offsets, @@ -1153,7 +1129,7 @@ coff_symtab_read (minimal_symbol_reader &reader, } else if (strcmp (cs->c_name, ".eb") == 0) { - if (context_stack_depth <= 0) + if (outermost_context_p ()) { /* We attempted to pop an empty context stack. */ complaint (_("`.eb' symbol without matching `.bb' " "symbol ignored starting at symnum %d"), @@ -1161,25 +1137,25 @@ coff_symtab_read (minimal_symbol_reader &reader, break; } - newobj = pop_context (); - if (depth-- != newobj->depth) + struct context_stack cstk = pop_context (); + if (depth-- != cstk.depth) { complaint (_("Mismatched .eb symbol ignored " "starting at symnum %d"), symnum); break; } - if (local_symbols && context_stack_depth > 0) + if (*get_local_symbols () && !outermost_context_p ()) { tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); /* Make a block for the local symbols within. */ - finish_block (0, &local_symbols, newobj->old_blocks, NULL, - newobj->start_addr, tmpaddr); + finish_block (0, cstk.old_blocks, NULL, + cstk.start_addr, tmpaddr); } /* Now pop locals of block just finished. */ - local_symbols = newobj->locals; + *get_local_symbols () = cstk.locals; } break; @@ -1202,11 +1178,11 @@ coff_symtab_read (minimal_symbol_reader &reader, /* Patch up any opaque types (references to types that are not defined in the file where they are referenced, e.g. "struct foo *bar"). */ { - struct compunit_symtab *cu; - struct symtab *s; - - ALL_OBJFILE_FILETABS (objfile, cu, s) - patch_opaque_types (s); + for (compunit_symtab *cu : objfile->compunits ()) + { + for (symtab *s : compunit_filetabs (cu)) + patch_opaque_types (s); + } } coffread_objfile = NULL; @@ -1297,17 +1273,13 @@ read_one_sym (struct coff_symbol *cs, /* Support for string table handling. */ -static char *stringtab = NULL; - static int -init_stringtab (bfd *abfd, long offset) +init_stringtab (bfd *abfd, long offset, gdb::unique_xmalloc_ptr *storage) { long length; int val; unsigned char lengthbuf[4]; - free_stringtab (); - /* If the file is stripped, the offset might be zero, indicating no string table. Just return with `stringtab' set to null. */ if (offset == 0) @@ -1324,7 +1296,8 @@ init_stringtab (bfd *abfd, long offset) if (val != sizeof lengthbuf || length < sizeof lengthbuf) return 0; - stringtab = (char *) xmalloc (length); + storage->reset ((char *) xmalloc (length)); + stringtab = storage->get (); /* This is in target format (probably not very useful, and not currently used), not host format. */ memcpy (stringtab, lengthbuf, sizeof lengthbuf); @@ -1339,20 +1312,6 @@ init_stringtab (bfd *abfd, long offset) return 0; } -static void -free_stringtab (void) -{ - if (stringtab) - xfree (stringtab); - stringtab = NULL; -} - -static void -free_stringtab_cleanup (void *ignore) -{ - free_stringtab (); -} - static char * getsymname (struct internal_syment *symbol_entry) { @@ -1406,24 +1365,19 @@ coff_getfilename (union internal_auxent *aux_entry) /* Support for line number handling. */ -static char *linetab = NULL; -static long linetab_offset; -static unsigned long linetab_size; - /* Read in all the line numbers for fast lookups later. Leave them in external (unswapped) format in memory; we'll swap them as we enter them into GDB's data structures. */ static int -init_lineno (bfd *abfd, long offset, int size) +init_lineno (bfd *abfd, long offset, int size, + gdb::unique_xmalloc_ptr *storage) { int val; linetab_offset = offset; linetab_size = size; - free_linetab (); - if (size == 0) return 0; @@ -1431,9 +1385,10 @@ init_lineno (bfd *abfd, long offset, int size) return -1; /* Allocate the desired table, plus a sentinel. */ - linetab = (char *) xmalloc (size + local_linesz); + storage->reset ((char *) xmalloc (size + local_linesz)); + linetab = storage->get (); - val = bfd_bread (linetab, size, abfd); + val = bfd_bread (storage->get (), size, abfd); if (val != size) return -1; @@ -1443,20 +1398,6 @@ init_lineno (bfd *abfd, long offset, int size) return 0; } -static void -free_linetab (void) -{ - if (linetab) - xfree (linetab); - linetab = NULL; -} - -static void -free_linetab_cleanup (void *ignore) -{ - free_linetab (); -} - #if !defined (L_LNNO32) #define L_LNNO32(lp) ((lp)->l_lnno) #endif @@ -1502,7 +1443,7 @@ enter_linenos (long file_offset, int first_line, CORE_ADDR addr = lptr.l_addr.l_paddr; addr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); - record_line (current_subfile, + record_line (get_current_subfile (), first_line + L_LNNO32 (&lptr), gdbarch_addr_bits_remove (gdbarch, addr)); } @@ -1544,7 +1485,7 @@ patch_type (struct type *type, struct type *real_type) static void patch_opaque_types (struct symtab *s) { - struct block *b; + const struct block *b; struct block_iterator iter; struct symbol *real_sym; @@ -1561,15 +1502,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) { - const char *name = SYMBOL_LINKAGE_NAME (real_sym); + const char *name = real_sym->linkage_name (); int hash = hashname (name); struct symbol *sym, *prev; prev = 0; for (sym = opaque_type_chain[hash]; sym;) { - if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0] - && strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0) + if (name[0] == sym->linkage_name ()[0] + && strcmp (name + 1, sym->linkage_name () + 1) == 0) { if (prev) { @@ -1625,9 +1566,9 @@ process_coff_symbol (struct coff_symbol *cs, name = cs->c_name; name = EXTERNAL_NAME (name, objfile->obfd); - SYMBOL_SET_LANGUAGE (sym, current_subfile->language, - &objfile->objfile_obstack); - SYMBOL_SET_NAMES (sym, name, strlen (name), 1, objfile); + sym->set_language (get_current_subfile ()->language, + &objfile->objfile_obstack); + SYMBOL_SET_NAMES (sym, name, true, objfile); /* default assumptions */ SYMBOL_VALUE (sym) = cs->c_value; @@ -1645,10 +1586,10 @@ process_coff_symbol (struct coff_symbol *cs, SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK; if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT || cs->c_sclass == C_THUMBSTATFUNC) - add_symbol_to_list (sym, &file_symbols); + add_symbol_to_list (sym, get_file_symbols ()); else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT || cs->c_sclass == C_THUMBEXTFUNC) - add_symbol_to_list (sym, &global_symbols); + add_symbol_to_list (sym, get_global_symbols ()); } else { @@ -1660,35 +1601,37 @@ process_coff_symbol (struct coff_symbol *cs, case C_AUTO: SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL; - add_symbol_to_list (sym, &local_symbols); + add_symbol_to_list (sym, get_local_symbols ()); break; case C_THUMBEXT: case C_THUMBEXTFUNC: case C_EXT: SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile)); - add_symbol_to_list (sym, &global_symbols); + SET_SYMBOL_VALUE_ADDRESS (sym, + (CORE_ADDR) cs->c_value + + ANOFFSET (objfile->section_offsets, + SECT_OFF_TEXT (objfile))); + add_symbol_to_list (sym, get_global_symbols ()); break; case C_THUMBSTAT: case C_THUMBSTATFUNC: case C_STAT: SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile)); + SET_SYMBOL_VALUE_ADDRESS (sym, + (CORE_ADDR) cs->c_value + + ANOFFSET (objfile->section_offsets, + SECT_OFF_TEXT (objfile))); if (within_function) { /* Static symbol of local scope. */ - add_symbol_to_list (sym, &local_symbols); + add_symbol_to_list (sym, get_local_symbols ()); } else { /* Static symbol at top level of file. */ - add_symbol_to_list (sym, &file_symbols); + add_symbol_to_list (sym, get_file_symbols ()); } break; @@ -1698,7 +1641,7 @@ process_coff_symbol (struct coff_symbol *cs, case C_REG: SYMBOL_ACLASS_INDEX (sym) = coff_register_index; SYMBOL_VALUE (sym) = cs->c_value; - add_symbol_to_list (sym, &local_symbols); + add_symbol_to_list (sym, get_local_symbols ()); break; case C_THUMBLABEL: @@ -1708,14 +1651,14 @@ process_coff_symbol (struct coff_symbol *cs, case C_ARG: SYMBOL_ACLASS_INDEX (sym) = LOC_ARG; SYMBOL_IS_ARGUMENT (sym) = 1; - add_symbol_to_list (sym, &local_symbols); + add_symbol_to_list (sym, get_local_symbols ()); break; case C_REGPARM: SYMBOL_ACLASS_INDEX (sym) = coff_register_index; SYMBOL_IS_ARGUMENT (sym) = 1; SYMBOL_VALUE (sym) = cs->c_value; - add_symbol_to_list (sym, &local_symbols); + add_symbol_to_list (sym, get_local_symbols ()); break; case C_TPDEF: @@ -1750,7 +1693,7 @@ process_coff_symbol (struct coff_symbol *cs, } else TYPE_NAME (SYMBOL_TYPE (sym)) = - xstrdup (SYMBOL_LINKAGE_NAME (sym)); + xstrdup (sym->linkage_name ()); } /* Keep track of any type which points to empty structured @@ -1764,12 +1707,12 @@ process_coff_symbol (struct coff_symbol *cs, && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) != TYPE_CODE_UNDEF) { - int i = hashname (SYMBOL_LINKAGE_NAME (sym)); + int i = hashname (sym->linkage_name ()); SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i]; opaque_type_chain[i] = sym; } - add_symbol_to_list (sym, &file_symbols); + add_symbol_to_list (sym, get_file_symbols ()); break; case C_STRTAG: @@ -1782,13 +1725,12 @@ process_coff_symbol (struct coff_symbol *cs, names for anonymous enums, structures, and unions, like "~0fake" or ".0fake". Thanks, but no thanks... */ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - if (SYMBOL_LINKAGE_NAME (sym) != NULL - && *SYMBOL_LINKAGE_NAME (sym) != '~' - && *SYMBOL_LINKAGE_NAME (sym) != '.') - TYPE_NAME (SYMBOL_TYPE (sym)) = - concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL); + if (sym->linkage_name () != NULL + && *sym->linkage_name () != '~' + && *sym->linkage_name () != '.') + TYPE_NAME (SYMBOL_TYPE (sym)) = xstrdup (sym->linkage_name ()); - add_symbol_to_list (sym, &file_symbols); + add_symbol_to_list (sym, get_file_symbols ()); break; default: @@ -1842,11 +1784,9 @@ decode_type (struct coff_symbol *cs, unsigned int c_type, base_type = decode_type (cs, new_c_type, aux, objfile); index_type = objfile_type (objfile)->builtin_int; range_type - = create_static_range_type ((struct type *) NULL, - index_type, 0, n - 1); + = create_static_range_type (NULL, index_type, 0, n - 1); type = - create_array_type ((struct type *) NULL, - base_type, range_type); + create_array_type (NULL, base_type, range_type); } return type; } @@ -2079,9 +2019,7 @@ coff_read_struct_type (int index, int length, int lastsym, list = newobj; /* Save the data. */ - list->field.name - = (const char *) obstack_copy0 (&objfile->objfile_obstack, - name, strlen (name)); + list->field.name = obstack_strdup (&objfile->objfile_obstack, name); FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, objfile); SET_FIELD_BITPOS (list->field, 8 * ms->c_value); @@ -2097,9 +2035,7 @@ coff_read_struct_type (int index, int length, int lastsym, list = newobj; /* Save the data. */ - list->field.name - = (const char *) obstack_copy0 (&objfile->objfile_obstack, - name, strlen (name)); + list->field.name = obstack_strdup (&objfile->objfile_obstack, name); FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, objfile); SET_FIELD_BITPOS (list->field, ms->c_value); @@ -2152,9 +2088,9 @@ coff_read_enum_type (int index, int length, int lastsym, type = coff_alloc_type (index); if (within_function) - symlist = &local_symbols; + symlist = get_local_symbols (); else - symlist = &file_symbols; + symlist = get_file_symbols (); osyms = *symlist; o_nsyms = osyms ? osyms->nsyms : 0; @@ -2169,9 +2105,8 @@ coff_read_enum_type (int index, int length, int lastsym, case C_MOE: sym = allocate_symbol (objfile); - name = (char *) obstack_copy0 (&objfile->objfile_obstack, name, - strlen (name)); - SYMBOL_SET_LINKAGE_NAME (sym, name); + name = obstack_strdup (&objfile->objfile_obstack, name); + sym->set_linkage_name (name); SYMBOL_ACLASS_INDEX (sym) = LOC_CONST; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_VALUE (sym) = ms->c_value; @@ -2218,7 +2153,7 @@ 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) = SYMBOL_LINKAGE_NAME (xsym); + TYPE_FIELD_NAME (type, n) = xsym->linkage_name (); SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym)); if (SYMBOL_VALUE (xsym) < 0) unsigned_enum = 0; @@ -2259,22 +2194,11 @@ static const struct sym_fns coff_sym_fns = &psym_functions }; -/* Free the per-objfile COFF data. */ - -static void -coff_free_info (struct objfile *objfile, void *arg) -{ - xfree (arg); -} - void _initialize_coffread (void) { add_symtab_fns (bfd_target_coff_flavour, &coff_sym_fns); - coff_objfile_data_key = register_objfile_data_with_cleanup (NULL, - coff_free_info); - coff_register_index = register_symbol_register_impl (LOC_REGISTER, &coff_register_funcs); }