X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fcoffread.c;h=84b3761cf55e7c0fc75c8d03c07fd13aaead2f07;hb=84f0252a038f4c2ceb70d076f58159eaa8e3dfab;hp=29ec6651ff4818c6e2c60b708f8215862c2ba8dd;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/coffread.c b/gdb/coffread.c index 29ec6651ff..84b3761cf5 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -1,5 +1,6 @@ /* Read coff symbol tables and convert to internal format, for GDB. - Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998 + Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu). @@ -42,8 +43,9 @@ #include "stabsread.h" #include "complaints.h" #include "target.h" +#include "gdb_assert.h" -extern void _initialize_coffread PARAMS ((void)); +extern void _initialize_coffread (void); struct coff_symfile_info { @@ -68,14 +70,6 @@ struct coff_symfile_info #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK)) -/* Convert from an sdb register number to an internal gdb register number. - This should be defined in tm.h, if REGISTER_NAMES is not set up - to map one to one onto the sdb register numbers. */ - -#ifndef SDB_REG_TO_REGNUM -#define SDB_REG_TO_REGNUM(value) (value) -#endif - /* Core address of start and end of text of current source file. This comes from a ".text" symbol where x_nlinno > 0. */ @@ -176,74 +170,50 @@ struct coff_symbol unsigned int c_type; }; -static struct type *coff_read_struct_type PARAMS ((int, int, int)); - -static struct type *decode_base_type PARAMS ((struct coff_symbol *, - unsigned int, - union internal_auxent *)); - -static struct type *decode_type PARAMS ((struct coff_symbol *, unsigned int, - union internal_auxent *)); - -static struct type *decode_function_type PARAMS ((struct coff_symbol *, - unsigned int, - union internal_auxent *)); - -static struct type *coff_read_enum_type PARAMS ((int, int, int)); - -static struct symbol *process_coff_symbol PARAMS ((struct coff_symbol *, - union internal_auxent *, - struct objfile *)); - -static void patch_opaque_types PARAMS ((struct symtab *)); - -static void patch_type PARAMS ((struct type *, struct type *)); +extern void stabsread_clear_cache (void); -static void enter_linenos PARAMS ((long, int, int, struct section_offsets *)); +static struct type *coff_read_struct_type (int, int, int); -static void free_linetab PARAMS ((void)); +static struct type *decode_base_type (struct coff_symbol *, + unsigned int, union internal_auxent *); -static int init_lineno PARAMS ((bfd *, long, int)); +static struct type *decode_type (struct coff_symbol *, unsigned int, + union internal_auxent *); -static char *getsymname PARAMS ((struct internal_syment *)); +static struct type *decode_function_type (struct coff_symbol *, + unsigned int, + union internal_auxent *); -static char *coff_getfilename PARAMS ((union internal_auxent *)); +static struct type *coff_read_enum_type (int, int, int); -static void free_stringtab PARAMS ((void)); +static struct symbol *process_coff_symbol (struct coff_symbol *, + union internal_auxent *, + struct objfile *); -static int init_stringtab PARAMS ((bfd *, long)); +static void patch_opaque_types (struct symtab *); -static void read_one_sym PARAMS ((struct coff_symbol *, - struct internal_syment *, - union internal_auxent *)); +static void enter_linenos (long, int, int, struct objfile *); -static void coff_symtab_read PARAMS ((long, int, struct objfile *)); +static void free_linetab (void); -static void find_linenos PARAMS ((bfd *, sec_ptr, PTR)); +static void free_linetab_cleanup (void *ignore); -static void coff_symfile_init PARAMS ((struct objfile *)); +static int init_lineno (bfd *, long, int); -static void coff_new_init PARAMS ((struct objfile *)); +static char *getsymname (struct internal_syment *); -static void coff_symfile_read PARAMS ((struct objfile *, int)); +static char *coff_getfilename (union internal_auxent *); -static void coff_symfile_finish PARAMS ((struct objfile *)); +static void free_stringtab (void); -static void record_minimal_symbol PARAMS ((char *, CORE_ADDR, - enum minimal_symbol_type, - struct objfile *)); +static void free_stringtab_cleanup (void *ignore); -static void coff_end_symtab PARAMS ((struct objfile *)); +static int init_stringtab (bfd *, long); -static void complete_symtab PARAMS ((char *, CORE_ADDR, unsigned int)); +static void read_one_sym (struct coff_symbol *, + struct internal_syment *, union internal_auxent *); -static void coff_start_symtab PARAMS ((char *)); - -static struct type *coff_alloc_type PARAMS ((int)); - -static struct type **coff_lookup_type PARAMS ((int)); - -static void coff_locate_sections PARAMS ((bfd *, asection *, PTR)); +static void coff_symtab_read (long, unsigned int, struct objfile *); /* We are called once per section from coff_symfile_read. We need to examine each section we are passed, check to see @@ -256,10 +226,7 @@ static void coff_locate_sections PARAMS ((bfd *, asection *, PTR)); -kingdon). */ static void -coff_locate_sections (abfd, sectp, csip) - bfd *abfd; - asection *sectp; - PTR csip; +coff_locate_sections (bfd *abfd, asection *sectp, void *csip) { register struct coff_symfile_info *csi; const char *name; @@ -303,13 +270,13 @@ coff_locate_sections (abfd, sectp, csip) /* 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 (free, n); + make_cleanup (xfree, n); } } } /* Return the section_offsets* that CS points to. */ -static int cs_to_section PARAMS ((struct coff_symbol *, struct objfile *)); +static int cs_to_section (struct coff_symbol *, struct objfile *); struct find_targ_sec_arg { @@ -317,13 +284,8 @@ struct find_targ_sec_arg asection **resultp; }; -static void find_targ_sec PARAMS ((bfd *, asection *, void *)); - static void -find_targ_sec (abfd, sect, obj) - bfd *abfd; - asection *sect; - PTR obj; +find_targ_sec (bfd *abfd, asection *sect, void *obj) { struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj; if (sect->target_index == args->targ_index) @@ -332,13 +294,11 @@ find_targ_sec (abfd, sect, obj) /* Return the section number (SECT_OFF_*) that CS points to. */ static int -cs_to_section (cs, objfile) - struct coff_symbol *cs; - struct objfile *objfile; +cs_to_section (struct coff_symbol *cs, struct objfile *objfile) { asection *sect = NULL; struct find_targ_sec_arg args; - int off = SECT_OFF_TEXT; + int off = SECT_OFF_TEXT (objfile); args.targ_index = cs->c_secnum; args.resultp = § @@ -347,23 +307,22 @@ cs_to_section (cs, objfile) { /* 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; + off = SECT_OFF_TEXT (objfile); else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD) - off = SECT_OFF_DATA; + off = SECT_OFF_DATA (objfile); else - off = SECT_OFF_BSS; + /* Just return the bfd section index. */ + off = sect->index; } return off; } /* Return the address of the section of a COFF symbol. */ -static CORE_ADDR cs_section_address PARAMS ((struct coff_symbol *, bfd *)); +static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *); static CORE_ADDR -cs_section_address (cs, abfd) - struct coff_symbol *cs; - bfd *abfd; +cs_section_address (struct coff_symbol *cs, bfd *abfd) { asection *sect = NULL; struct find_targ_sec_arg args; @@ -385,8 +344,7 @@ cs_section_address (cs, abfd) or for associating a new type with the index. */ static struct type ** -coff_lookup_type (index) - register int index; +coff_lookup_type (register int index) { if (index >= type_vector_length) { @@ -410,8 +368,7 @@ coff_lookup_type (index) This can create an empty (zeroed) type object. */ static struct type * -coff_alloc_type (index) - int index; +coff_alloc_type (int index) { register struct type **type_addr = coff_lookup_type (index); register struct type *type = *type_addr; @@ -432,8 +389,7 @@ coff_alloc_type (index) it indicates the start of data for one original source file. */ static void -coff_start_symtab (name) - char *name; +coff_start_symtab (char *name) { start_symtab ( /* We fill in the filename later. start_symtab puts @@ -455,13 +411,10 @@ coff_start_symtab (name) text address for the file, and SIZE is the number of bytes of text. */ static void -complete_symtab (name, start_addr, size) - char *name; - CORE_ADDR start_addr; - unsigned int size; +complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size) { if (last_source_file != NULL) - free (last_source_file); + xfree (last_source_file); last_source_file = savestring (name, strlen (name)); current_source_start_addr = start_addr; current_source_end_addr = start_addr + size; @@ -480,14 +433,13 @@ complete_symtab (name, start_addr, size) struct symtab for that file and put it in the list of all such. */ static void -coff_end_symtab (objfile) - struct objfile *objfile; +coff_end_symtab (struct objfile *objfile) { struct symtab *symtab; last_source_start_addr = current_source_start_addr; - symtab = end_symtab (current_source_end_addr, objfile, 0); + symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile)); if (symtab != NULL) free_named_symtabs (symtab->filename); @@ -497,11 +449,8 @@ coff_end_symtab (objfile) } static void -record_minimal_symbol (name, address, type, objfile) - char *name; - CORE_ADDR address; - enum minimal_symbol_type type; - struct objfile *objfile; +record_minimal_symbol (char *name, CORE_ADDR address, + enum minimal_symbol_type type, struct objfile *objfile) { /* We don't want TDESC entry points in the minimal symbol table */ if (name[0] == '@') @@ -524,14 +473,14 @@ record_minimal_symbol (name, address, type, objfile) The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */ static void -coff_symfile_init (objfile) - struct objfile *objfile; +coff_symfile_init (struct objfile *objfile) { /* Allocate struct to keep track of stab reading. */ objfile->sym_stab_info = (struct dbx_symfile_info *) xmmalloc (objfile->md, sizeof (struct dbx_symfile_info)); - memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info)); + memset (objfile->sym_stab_info, 0, + sizeof (struct dbx_symfile_info)); /* Allocate struct to keep track of the symfile */ objfile->sym_private = xmmalloc (objfile->md, @@ -553,10 +502,7 @@ coff_symfile_init (objfile) /* ARGSUSED */ static void -find_linenos (abfd, asect, vpinfo) - bfd *abfd; - sec_ptr asect; - PTR vpinfo; +find_linenos (bfd *abfd, sec_ptr asect, void *vpinfo) { struct coff_symfile_info *info; int size, count; @@ -593,9 +539,7 @@ static bfd *symfile_bfd; /* ARGSUSED */ static void -coff_symfile_read (objfile, mainline) - struct objfile *objfile; - int mainline; +coff_symfile_read (struct objfile *objfile, int mainline) { struct coff_symfile_info *info; struct dbx_symfile_info *dbxinfo; @@ -603,12 +547,14 @@ coff_symfile_read (objfile, mainline) coff_data_type *cdata = coff_data (abfd); char *name = bfd_get_filename (abfd); register int val; - int num_symbols; + unsigned int num_symbols; int symtab_offset; int stringtab_offset; struct cleanup *back_to; int stabstrsize; - + int len; + char * target; + info = (struct coff_symfile_info *) objfile->sym_private; dbxinfo = objfile->sym_stab_info; symfile_bfd = abfd; /* Kludge for swap routines */ @@ -634,23 +580,25 @@ coff_symfile_read (objfile, mainline) temp_sym = (char *) xmalloc (cdata->local_symesz + cdata->local_auxesz); temp_aux = temp_sym + cdata->local_symesz; - back_to = make_cleanup ((make_cleanup_func) free_current_contents, &temp_sym); + 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 from the section address, rather than as absolute addresses. FIXME: We should use BFD to read the symbol table, and thus avoid this problem. */ - pe_file = strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0; + pe_file = + strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0 + || strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0; /* End of warning */ /* Read the line number table, all at once. */ info->min_lineno_offset = 0; info->max_lineno_offset = 0; - bfd_map_over_sections (abfd, find_linenos, (PTR) info); + bfd_map_over_sections (abfd, find_linenos, (void *) info); - make_cleanup ((make_cleanup_func) free_linetab, 0); + make_cleanup (free_linetab_cleanup, 0 /*ignore*/); val = init_lineno (abfd, info->min_lineno_offset, info->max_lineno_offset - info->min_lineno_offset); if (val < 0) @@ -658,13 +606,13 @@ coff_symfile_read (objfile, mainline) /* Now read the string table, all at once. */ - make_cleanup ((make_cleanup_func) free_stringtab, 0); + make_cleanup (free_stringtab_cleanup, 0 /*ignore*/); val = init_stringtab (abfd, stringtab_offset); if (val < 0) error ("\"%s\": can't get string table", name); init_minimal_symbol_collection (); - make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0); + make_cleanup_discard_minimal_symbols (); /* Now that the executable file is positioned at symbol table, process it and define symbols accordingly. */ @@ -685,19 +633,16 @@ coff_symfile_read (objfile, mainline) install_minimal_symbols (objfile); - bfd_map_over_sections (abfd, coff_locate_sections, (PTR) info); + bfd_map_over_sections (abfd, coff_locate_sections, (void *) info); if (info->stabsects) { if (!info->stabstrsect) { - error_begin (); - fprintf_filtered - (gdb_stderr, - ("The debugging information in `%s' is corrupted.\n" - "The file has a `.stabs' section, but no `.stabstr' section.\n"), - name); - return_to_top_level (RETURN_ERROR); + error (("The debugging information in `%s' is corrupted.\n" + "The file has a `.stabs' section, but no `.stabstr' " + "section."), + name); } /* FIXME: dubious. Why can't we use something normal like @@ -712,13 +657,17 @@ coff_symfile_read (objfile, mainline) info->stabsects, info->stabstrsect->filepos, stabstrsize); } + if (dwarf2_has_info (abfd)) + { + /* DWARF2 sections. */ + dwarf2_build_psymtabs (objfile, mainline); + } do_cleanups (back_to); } static void -coff_new_init (ignore) - struct objfile *ignore; +coff_new_init (struct objfile *ignore) { } @@ -728,13 +677,15 @@ coff_new_init (ignore) objfile struct from the global list of known objfiles. */ static void -coff_symfile_finish (objfile) - struct objfile *objfile; +coff_symfile_finish (struct objfile *objfile) { if (objfile->sym_private != NULL) { - mfree (objfile->md, objfile->sym_private); + xmfree (objfile->md, objfile->sym_private); } + + /* Let stabs reader clean up */ + stabsread_clear_cache (); } @@ -744,10 +695,8 @@ coff_symfile_finish (objfile) We read them one at a time using read_one_sym (). */ static void -coff_symtab_read (symtab_offset, nsyms, objfile) - long symtab_offset; - int nsyms; - struct objfile *objfile; +coff_symtab_read (long symtab_offset, unsigned int nsyms, + struct objfile *objfile) { register struct context_stack *new; struct coff_symbol coff_symbol; @@ -765,7 +714,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) char *filestring = ""; int depth = 0; int fcn_first_line = 0; - CORE_ADDR fcn_first_line_addr; + CORE_ADDR fcn_first_line_addr = 0; int fcn_last_line = 0; int fcn_start_addr = 0; long fcn_line_ptr = 0; @@ -800,7 +749,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) memset (opaque_type_chain, 0, sizeof opaque_type_chain); if (type_vector) /* Get rid of previous one */ - free ((PTR) type_vector); + xfree (type_vector); type_vector_length = 160; type_vector = (struct type **) xmalloc (type_vector_length * sizeof (struct type *)); @@ -834,7 +783,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF) { /* Record all functions -- external and static -- in minsyms. */ - tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); record_minimal_symbol (cs->c_name, tmpaddr, mst_text, objfile); fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr; @@ -899,7 +848,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) followed by a later file with no symbols. */ if (in_source_file) complete_symtab (filestring, - cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT), + cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), main_aux.x_scn.x_scnlen); in_source_file = 0; } @@ -960,46 +909,45 @@ coff_symtab_read (symtab_offset, nsyms, objfile) || cs->c_sclass == C_THUMBEXT) tmpaddr += ANOFFSET (objfile->section_offsets, sec); - switch (sec) + if (sec == SECT_OFF_TEXT (objfile)) { - case SECT_OFF_TEXT: - case SECT_OFF_RODATA: ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC || cs->c_sclass == C_THUMBEXT ? mst_text : mst_file_text; -#ifdef SMASH_TEXT_ADDRESS - if (tmpaddr & 1) /* FIXME: delete this line */ - SMASH_TEXT_ADDRESS (tmpaddr); -#endif - break; - case SECT_OFF_DATA: + tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr); + } + else if (sec == SECT_OFF_DATA (objfile)) + { ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? mst_data : mst_file_data; - break; - case SECT_OFF_BSS: + } + else if (sec == SECT_OFF_BSS (objfile)) + { ms_type = cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? mst_data : mst_file_data; - break; - default: - ms_type = mst_unknown; - break; } + else + ms_type = mst_unknown; } if (cs->c_name[0] != '@' /* Skip tdesc symbols */ ) { struct minimal_symbol *msym; + /* FIXME: cagney/2001-02-01: The nasty (int) -> (long) + -> (void*) cast is to ensure that that the value of + cs->c_sclass can be correctly stored in a void + pointer in MSYMBOL_INFO. Better solutions + welcome. */ + gdb_assert (sizeof (void *) >= sizeof (cs->c_sclass)); msym = prim_record_minimal_symbol_and_info - (cs->c_name, tmpaddr, ms_type, (char *) cs->c_sclass, sec, - NULL, objfile); -#ifdef COFF_MAKE_MSYMBOL_SPECIAL + (cs->c_name, tmpaddr, ms_type, (void *) (long) cs->c_sclass, + sec, NULL, objfile); if (msym) COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym); -#endif } if (SDB_TYPE (cs->c_type)) { @@ -1036,6 +984,8 @@ coff_symtab_read (symtab_offset, nsyms, objfile) } else if (STREQ (cs->c_name, ".ef")) { + if (!within_function) + error ("Bad coff function information\n"); /* the value of .ef is the address of epilogue code; not useful for gdb. */ /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno @@ -1076,7 +1026,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) fcn_first_line_addr); else enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line, - objfile->section_offsets); + objfile); finish_block (new->name, &local_symbols, new->old_blocks, new->start_addr, @@ -1090,11 +1040,11 @@ coff_symtab_read (symtab_offset, nsyms, objfile) of the epilogue. */ cs->c_value + FUNCTION_EPILOGUE_SIZE - + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT), + + 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), + + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), #endif objfile ); @@ -1106,7 +1056,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) if (STREQ (cs->c_name, ".bb")) { tmpaddr = cs->c_value; - tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); push_context (++depth, tmpaddr); } else if (STREQ (cs->c_name, ".eb")) @@ -1126,7 +1076,7 @@ coff_symtab_read (symtab_offset, nsyms, objfile) if (local_symbols && context_stack_depth > 0) { tmpaddr = - cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); /* Make a block for the local symbols within. */ finish_block (0, &local_symbols, new->old_blocks, new->start_addr, tmpaddr, objfile); @@ -1160,26 +1110,25 @@ coff_symtab_read (symtab_offset, nsyms, objfile) in internal_auxent form, and skip any other auxents. */ static void -read_one_sym (cs, sym, aux) - register struct coff_symbol *cs; - register struct internal_syment *sym; - register union internal_auxent *aux; +read_one_sym (register struct coff_symbol *cs, + register struct internal_syment *sym, + register union internal_auxent *aux) { int i; cs->c_symnum = symnum; - bfd_read (temp_sym, local_symesz, 1, nlist_bfd_global); + bfd_bread (temp_sym, local_symesz, nlist_bfd_global); bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym); cs->c_naux = sym->n_numaux & 0xff; if (cs->c_naux >= 1) { - bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global); + bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); 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_read (temp_aux, local_auxesz, 1, nlist_bfd_global); + bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); } cs->c_name = getsymname (sym); cs->c_value = sym->n_value; @@ -1230,9 +1179,7 @@ read_one_sym (cs, sym, aux) static char *stringtab = NULL; static int -init_stringtab (abfd, offset) - bfd *abfd; - long offset; +init_stringtab (bfd *abfd, long offset) { long length; int val; @@ -1248,7 +1195,7 @@ init_stringtab (abfd, offset) if (bfd_seek (abfd, offset, 0) < 0) return -1; - val = bfd_read ((char *) lengthbuf, sizeof lengthbuf, 1, abfd); + val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd); length = bfd_h_get_32 (symfile_bfd, lengthbuf); /* If no string table is needed, then the file may end immediately @@ -1263,7 +1210,8 @@ init_stringtab (abfd, offset) if (length == sizeof length) /* Empty table -- just the count */ return 0; - val = bfd_read (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1, abfd); + val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, + abfd); if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0') return -1; @@ -1271,16 +1219,21 @@ init_stringtab (abfd, offset) } static void -free_stringtab () +free_stringtab (void) { if (stringtab) - free (stringtab); + xfree (stringtab); stringtab = NULL; } +static void +free_stringtab_cleanup (void *ignore) +{ + free_stringtab (); +} + static char * -getsymname (symbol_entry) - struct internal_syment *symbol_entry; +getsymname (struct internal_syment *symbol_entry) { static char buffer[SYMNMLEN + 1]; char *result; @@ -1305,8 +1258,7 @@ getsymname (symbol_entry) is only good for temporary use. */ static char * -coff_getfilename (aux_entry) - union internal_auxent *aux_entry; +coff_getfilename (union internal_auxent *aux_entry) { static char buffer[BUFSIZ]; register char *temp; @@ -1340,10 +1292,7 @@ static unsigned long linetab_size; them into GDB's data structures. */ static int -init_lineno (abfd, offset, size) - bfd *abfd; - long offset; - int size; +init_lineno (bfd *abfd, long offset, int size) { int val; @@ -1361,7 +1310,7 @@ init_lineno (abfd, offset, size) /* Allocate the desired table, plus a sentinel */ linetab = (char *) xmalloc (size + local_linesz); - val = bfd_read (linetab, size, 1, abfd); + val = bfd_bread (linetab, size, abfd); if (val != size) return -1; @@ -1372,23 +1321,26 @@ init_lineno (abfd, offset, size) } static void -free_linetab () +free_linetab (void) { if (linetab) - free (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 static void -enter_linenos (file_offset, first_line, last_line, section_offsets) - long file_offset; - register int first_line; - register int last_line; - struct section_offsets *section_offsets; +enter_linenos (long file_offset, register int first_line, + register int last_line, struct objfile *objfile) { register char *rawptr; struct internal_lineno lptr; @@ -1418,16 +1370,14 @@ enter_linenos (file_offset, first_line, last_line, section_offsets) if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line) record_line (current_subfile, first_line + L_LNNO32 (&lptr), lptr.l_addr.l_paddr - + ANOFFSET (section_offsets, SECT_OFF_TEXT)); + + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))); else break; } } static void -patch_type (type, real_type) - struct type *type; - struct type *real_type; +patch_type (struct type *type, struct type *real_type) { register struct type *target = TYPE_TARGET_TYPE (type); register struct type *real_target = TYPE_TARGET_TYPE (real_type); @@ -1442,7 +1392,7 @@ patch_type (type, real_type) if (TYPE_NAME (real_target)) { if (TYPE_NAME (target)) - free (TYPE_NAME (target)); + xfree (TYPE_NAME (target)); TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL); } } @@ -1451,8 +1401,7 @@ patch_type (type, real_type) so that they can be used to print out opaque data structures properly. */ static void -patch_opaque_types (s) - struct symtab *s; +patch_opaque_types (struct symtab *s) { register struct block *b; register int i; @@ -1513,10 +1462,9 @@ patch_opaque_types (s) } static struct symbol * -process_coff_symbol (cs, aux, objfile) - register struct coff_symbol *cs; - register union internal_auxent *aux; - struct objfile *objfile; +process_coff_symbol (register struct coff_symbol *cs, + register union internal_auxent *aux, + struct objfile *objfile) { register struct symbol *sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, @@ -1538,7 +1486,7 @@ process_coff_symbol (cs, aux, objfile) if (ISFCN (cs->c_type)) { - SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + 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)); @@ -1568,7 +1516,7 @@ process_coff_symbol (cs, aux, objfile) case C_EXT: SYMBOL_CLASS (sym) = LOC_STATIC; SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); add_symbol_to_list (sym, &global_symbols); break; @@ -1577,7 +1525,7 @@ process_coff_symbol (cs, aux, objfile) case C_STAT: SYMBOL_CLASS (sym) = LOC_STATIC; SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); + SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); if (within_function) { /* Static symbol of local scope */ @@ -1607,7 +1555,7 @@ process_coff_symbol (cs, aux, objfile) SYMBOL_CLASS (sym) = LOC_ARG; add_symbol_to_list (sym, &local_symbols); #if !defined (BELIEVE_PCC_PROMOTION) - if (TARGET_BYTE_ORDER == BIG_ENDIAN) + 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 @@ -1740,10 +1688,8 @@ process_coff_symbol (cs, aux, objfile) /* Decode a coff type specifier; return the type that is meant. */ static struct type * -decode_type (cs, c_type, aux) - register struct coff_symbol *cs; - unsigned int c_type; - register union internal_auxent *aux; +decode_type (register struct coff_symbol *cs, unsigned int c_type, + register union internal_auxent *aux) { register struct type *type = 0; unsigned int new_c_type; @@ -1821,10 +1767,8 @@ decode_type (cs, c_type, aux) return the type that the function returns. */ static struct type * -decode_function_type (cs, c_type, aux) - register struct coff_symbol *cs; - unsigned int c_type; - register union internal_auxent *aux; +decode_function_type (register struct coff_symbol *cs, unsigned int c_type, + register union internal_auxent *aux) { if (aux->x_sym.x_tagndx.l == 0) cs->c_naux = 0; /* auxent refers to function, not base type */ @@ -1835,10 +1779,8 @@ decode_function_type (cs, c_type, aux) /* basic C types */ static struct type * -decode_base_type (cs, c_type, aux) - register struct coff_symbol *cs; - unsigned int c_type; - register union internal_auxent *aux; +decode_base_type (register struct coff_symbol *cs, unsigned int c_type, + register union internal_auxent *aux) { struct type *type; @@ -1989,10 +1931,7 @@ decode_base_type (cs, c_type, aux) object describing the type. */ static struct type * -coff_read_struct_type (index, length, lastsym) - int index; - int length; - int lastsym; +coff_read_struct_type (int index, int length, int lastsym) { struct nextfield { @@ -2087,10 +2026,7 @@ coff_read_struct_type (index, length, lastsym) /* ARGSUSED */ static struct type * -coff_read_enum_type (index, length, lastsym) - int index; - int length; - int lastsym; +coff_read_enum_type (int index, int length, int lastsym) { register struct symbol *sym; register struct type *type; @@ -2207,7 +2143,7 @@ static struct sym_fns coff_sym_fns = }; void -_initialize_coffread () +_initialize_coffread (void) { add_symtab_fns (&coff_sym_fns); }