diff options
Diffstat (limited to 'gdb/coffread.c')
| -rw-r--r-- | gdb/coffread.c | 1490 |
1 files changed, 750 insertions, 740 deletions
diff --git a/gdb/coffread.c b/gdb/coffread.c index 1a63cfb7552..1a923ebff66 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -1,23 +1,24 @@ /* Read coff symbol tables and convert to internal format, for GDB. Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998 - Free Software Foundation, Inc. + Free Software Foundation, Inc. Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu). -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" #include "symtab.h" @@ -44,16 +45,17 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ extern void _initialize_coffread PARAMS ((void)); -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 */ +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; -}; + 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; + }; /* Translate an external name string into a user-visible name. */ #define EXTERNAL_NAME(string, abfd) \ @@ -71,7 +73,7 @@ struct coff_symfile_info { to map one to one onto the sdb register numbers. */ #ifndef SDB_REG_TO_REGNUM -# define SDB_REG_TO_REGNUM(value) (value) +#define SDB_REG_TO_REGNUM(value) (value) #endif /* Core address of start and end of text of current source file. @@ -98,24 +100,24 @@ static char *temp_aux; internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF macros from include/coff/internal.h . */ -static unsigned local_n_btmask; -static unsigned local_n_btshft; -static unsigned local_n_tmask; -static unsigned local_n_tshift; +static unsigned local_n_btmask; +static unsigned local_n_btshft; +static unsigned local_n_tmask; +static unsigned local_n_tshift; #define N_BTMASK local_n_btmask #define N_BTSHFT local_n_btshft #define N_TMASK local_n_tmask #define N_TSHIFT local_n_tshift - + /* Local variables that hold the sizes in the file of various COFF structures. (We only need to know this to read them from the file -- BFD will then translate the data in them, into `internal_xxx' structs in the right byte order, alignment, etc.) */ -static unsigned local_linesz; -static unsigned local_symesz; -static unsigned local_auxesz; +static unsigned local_linesz; +static unsigned local_symesz; +static unsigned local_auxesz; /* This is set if this is a PE format file. */ @@ -128,50 +130,51 @@ static struct symbol *opaque_type_chain[HASHSIZE]; /* Complaints about various problems in the file being read */ -struct complaint ef_complaint = - {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0}; +struct complaint ef_complaint = +{"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0}; -struct complaint ef_stack_complaint = - {"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0}; +struct complaint ef_stack_complaint = +{"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0}; -struct complaint eb_stack_complaint = - {"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0}; +struct complaint eb_stack_complaint = +{"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0}; struct complaint bf_no_aux_complaint = - {"`.bf' symbol %d has no aux entry", 0, 0}; +{"`.bf' symbol %d has no aux entry", 0, 0}; struct complaint ef_no_aux_complaint = - {"`.ef' symbol %d has no aux entry", 0, 0}; +{"`.ef' symbol %d has no aux entry", 0, 0}; struct complaint lineno_complaint = - {"Line number pointer %d lower than start of line numbers", 0, 0}; +{"Line number pointer %d lower than start of line numbers", 0, 0}; struct complaint unexpected_type_complaint = - {"Unexpected type for symbol %s", 0, 0}; +{"Unexpected type for symbol %s", 0, 0}; struct complaint bad_sclass_complaint = - {"Bad n_sclass for symbol %s", 0, 0}; +{"Bad n_sclass for symbol %s", 0, 0}; struct complaint misordered_blocks_complaint = - {"Blocks out of order at address %x", 0, 0}; +{"Blocks out of order at address %x", 0, 0}; struct complaint tagndx_bad_complaint = - {"Symbol table entry for %s has bad tagndx value", 0, 0}; +{"Symbol table entry for %s has bad tagndx value", 0, 0}; -struct complaint eb_complaint = - {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0}; +struct complaint eb_complaint = +{"Mismatched .eb symbol ignored starting at symnum %d", 0, 0}; /* Simplified internal version of coff symbol table information */ -struct coff_symbol { - char *c_name; - int c_symnum; /* symbol number of this entry */ - int c_naux; /* 0 if syment only, 1 if syment + auxent, etc */ - long c_value; - int c_sclass; - int c_secnum; - unsigned int c_type; -}; +struct coff_symbol + { + char *c_name; + int c_symnum; /* symbol number of this entry */ + int c_naux; /* 0 if syment only, 1 if syment + auxent, etc */ + long c_value; + int c_sclass; + int c_secnum; + unsigned int c_type; + }; static struct type *coff_read_struct_type PARAMS ((int, int, int)); @@ -286,7 +289,7 @@ coff_locate_sections (abfd, sectp, csip) /* We can have multiple .stab sections if linked with --split-by-reloc. */ for (s = name + sizeof ".stab" - 1; *s != '\0'; s++) - if (! isdigit (*s)) + if (!isdigit (*s)) break; if (*s == '\0') { @@ -301,8 +304,8 @@ coff_locate_sections (abfd, sectp, csip) *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. */ + in coff_symfile_read, at which point we no longer need + the information. */ make_cleanup (free, n); } } @@ -311,19 +314,21 @@ coff_locate_sections (abfd, sectp, csip) /* Return the section_offsets* that CS points to. */ static int cs_to_section PARAMS ((struct coff_symbol *, struct objfile *)); -struct find_targ_sec_arg { - int targ_index; - asection **resultp; -}; +struct find_targ_sec_arg + { + int targ_index; + asection **resultp; + }; static void find_targ_sec PARAMS ((bfd *, asection *, void *)); -static void find_targ_sec (abfd, sect, obj) +static void +find_targ_sec (abfd, sect, obj) bfd *abfd; asection *sect; PTR obj; { - struct find_targ_sec_arg *args = (struct find_targ_sec_arg *)obj; + struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj; if (sect->target_index == args->targ_index) *args->resultp = sect; } @@ -391,14 +396,14 @@ coff_lookup_type (index) int old_vector_length = type_vector_length; type_vector_length *= 2; - if (index /* is still */ >= type_vector_length) + if (index /* is still */ >= type_vector_length) type_vector_length = index * 2; type_vector = (struct type **) xrealloc ((char *) type_vector, type_vector_length * sizeof (struct type *)); memset (&type_vector[old_vector_length], 0, - (type_vector_length - old_vector_length) * sizeof(struct type *)); + (type_vector_length - old_vector_length) * sizeof (struct type *)); } return &type_vector[index]; } @@ -431,19 +436,19 @@ coff_alloc_type (index) static void coff_start_symtab (name) - char *name; + char *name; { start_symtab ( - /* 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. */ - savestring (name, strlen(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. */ - 0); + /* 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. */ + savestring (name, strlen (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. */ + 0); record_debugformat ("COFF"); } @@ -454,9 +459,9 @@ coff_start_symtab (name) static void complete_symtab (name, start_addr, size) - char *name; - CORE_ADDR start_addr; - unsigned int size; + char *name; + CORE_ADDR start_addr; + unsigned int size; { if (last_source_file != NULL) free (last_source_file); @@ -464,11 +469,11 @@ complete_symtab (name, start_addr, size) current_source_start_addr = start_addr; current_source_end_addr = start_addr + size; - if (current_objfile -> ei.entry_point >= current_source_start_addr && - current_objfile -> ei.entry_point < current_source_end_addr) + if (current_objfile->ei.entry_point >= current_source_start_addr && + current_objfile->ei.entry_point < current_source_end_addr) { - current_objfile -> ei.entry_file_lowpc = current_source_start_addr; - current_objfile -> ei.entry_file_highpc = current_source_end_addr; + current_objfile->ei.entry_file_lowpc = current_source_start_addr; + current_objfile->ei.entry_file_highpc = current_source_end_addr; } } @@ -502,7 +507,8 @@ record_minimal_symbol (name, address, type, objfile) struct objfile *objfile; { /* We don't want TDESC entry points in the minimal symbol table */ - if (name[0] == '@') return; + if (name[0] == '@') + return; prim_record_minimal_symbol (name, address, type, objfile); } @@ -567,7 +573,7 @@ find_linenos (abfd, asect, vpinfo) return; size = count * local_linesz; - info = (struct coff_symfile_info *)vpinfo; + info = (struct coff_symfile_info *) vpinfo; /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ offset = asect->line_filepos; /* End of warning */ @@ -607,30 +613,30 @@ coff_symfile_read (objfile, section_offsets, mainline) struct cleanup *back_to; int stabstrsize; - info = (struct coff_symfile_info *) objfile -> sym_private; + info = (struct coff_symfile_info *) objfile->sym_private; dbxinfo = objfile->sym_stab_info; - symfile_bfd = abfd; /* Kludge for swap routines */ + symfile_bfd = abfd; /* Kludge for swap routines */ /* 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 */ - stringtab_offset = symtab_offset + /* String table file offset */ - num_symbols * cdata->local_symesz; + num_symbols = bfd_get_symcount (abfd); /* How many syms */ + symtab_offset = cdata->sym_filepos; /* Symbol table file offset */ + stringtab_offset = symtab_offset + /* String table file offset */ + num_symbols * cdata->local_symesz; /* Set a few file-statics that give us specific information about the particular COFF file format we're reading. */ local_n_btmask = cdata->local_n_btmask; local_n_btshft = cdata->local_n_btshft; - local_n_tmask = cdata->local_n_tmask; + local_n_tmask = cdata->local_n_tmask; local_n_tshift = cdata->local_n_tshift; - local_linesz = cdata->local_linesz; - local_symesz = cdata->local_symesz; - local_auxesz = cdata->local_auxesz; + local_linesz = cdata->local_linesz; + local_symesz = cdata->local_symesz; + local_auxesz = cdata->local_auxesz; /* 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); + (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); @@ -649,7 +655,7 @@ coff_symfile_read (objfile, section_offsets, mainline) bfd_map_over_sections (abfd, find_linenos, (PTR) info); make_cleanup ((make_cleanup_func) free_linetab, 0); - val = init_lineno (abfd, info->min_lineno_offset, + val = init_lineno (abfd, info->min_lineno_offset, info->max_lineno_offset - info->min_lineno_offset); if (val < 0) error ("\"%s\": error reading line numbers\n", name); @@ -675,7 +681,7 @@ coff_symfile_read (objfile, section_offsets, mainline) { struct symtab *s; - for (s = objfile -> symtabs; s != NULL; s = s -> next) + for (s = objfile->symtabs; s != NULL; s = s->next) sort_symtab_syms (s); } @@ -688,19 +694,19 @@ coff_symfile_read (objfile, section_offsets, mainline) if (info->stabsects) { - if (! info->stabstrsect) + 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"), + "The file has a `.stabs' section, but no `.stabstr' section.\n"), name); return_to_top_level (RETURN_ERROR); } /* FIXME: dubious. Why can't we use something normal like - bfd_get_section_contents? */ + bfd_get_section_contents? */ bfd_seek (abfd, abfd->where, 0); stabstrsize = bfd_section_size (abfd, info->stabstrsect); @@ -731,13 +737,13 @@ static void coff_symfile_finish (objfile) struct objfile *objfile; { - if (objfile -> sym_private != NULL) + if (objfile->sym_private != NULL) { - mfree (objfile -> md, objfile -> sym_private); + mfree (objfile->md, objfile->sym_private); } } - + /* Given pointers to a symbol table in coff style exec file, analyze them and create struct symtab's describing the symbols. NSYMS is the number of symbols in the symbol table. @@ -800,7 +806,7 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile) last_source_file = NULL; memset (opaque_type_chain, 0, sizeof opaque_type_chain); - if (type_vector) /* Get rid of previous one */ + if (type_vector) /* Get rid of previous one */ free ((PTR) type_vector); type_vector_length = 160; type_vector = (struct type **) @@ -848,50 +854,51 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile) switch (cs->c_sclass) { - case C_EFCN: - case C_EXTDEF: - case C_ULABEL: - case C_USTATIC: - case C_LINE: - case C_ALIAS: - case C_HIDDEN: - complain (&bad_sclass_complaint, cs->c_name); - break; - - case C_FILE: - /* c_value field contains symnum of next .file entry in table - or symnum of first global after last .file. */ - next_file_symnum = cs->c_value; - if (cs->c_naux > 0) - filestring = coff_getfilename (&main_aux); - else - filestring = ""; + case C_EFCN: + case C_EXTDEF: + case C_ULABEL: + case C_USTATIC: + case C_LINE: + case C_ALIAS: + case C_HIDDEN: + complain (&bad_sclass_complaint, cs->c_name); + break; - /* Complete symbol table for last object file - containing debugging information. */ - if (last_source_file) - { - coff_end_symtab (objfile); - coff_start_symtab (filestring); - } - in_source_file = 1; - break; + case C_FILE: + /* c_value field contains symnum of next .file entry in table + or symnum of first global after last .file. */ + next_file_symnum = cs->c_value; + if (cs->c_naux > 0) + filestring = coff_getfilename (&main_aux); + else + filestring = ""; + + /* Complete symbol table for last object file + containing debugging information. */ + if (last_source_file) + { + coff_end_symtab (objfile); + coff_start_symtab (filestring); + } + in_source_file = 1; + break; /* C_LABEL is used for labels and static functions. Including it here allows gdb to see static functions when no debug info is available. */ - case C_LABEL: - /* However, labels within a function can make weird backtraces, - so filter them out (from phdm@macqel.be). */ - if (within_function) - break; - case C_STAT: - case C_THUMBLABEL: - case C_THUMBSTAT: - case C_THUMBSTATFUNC: - if (cs->c_name[0] == '.') - { - if (STREQ (cs->c_name, ".text")) { + case C_LABEL: + /* However, labels within a function can make weird backtraces, + so filter them out (from phdm@macqel.be). */ + if (within_function) + break; + case C_STAT: + case C_THUMBLABEL: + case C_THUMBSTAT: + case C_THUMBSTATFUNC: + if (cs->c_name[0] == '.') + { + if (STREQ (cs->c_name, ".text")) + { /* FIXME: don't wire in ".text" as section name or symbol name! */ /* Check for in_source_file deals with case of @@ -899,247 +906,247 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile) followed by a later file with no symbols. */ if (in_source_file) complete_symtab (filestring, - cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT), + cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT), main_aux.x_scn.x_scnlen); in_source_file = 0; } - /* flush rest of '.' symbols */ - break; - } - else if (!SDB_TYPE (cs->c_type) - && cs->c_name[0] == 'L' - && (strncmp (cs->c_name, "LI%", 3) == 0 - || strncmp (cs->c_name, "LF%", 3) == 0 - || strncmp (cs->c_name,"LC%",3) == 0 - || strncmp (cs->c_name,"LP%",3) == 0 - || strncmp (cs->c_name,"LPB%",4) == 0 - || strncmp (cs->c_name,"LBB%",4) == 0 - || strncmp (cs->c_name,"LBE%",4) == 0 - || strncmp (cs->c_name,"LPBX%",5) == 0)) - /* At least on a 3b1, gcc generates swbeg and string labels - that look like this. Ignore them. */ + /* flush rest of '.' symbols */ break; - /* fall in for static symbols that don't start with '.' */ - case C_THUMBEXT: - case C_THUMBEXTFUNC: - case C_EXT: - { - /* Record it in the minimal symbols regardless of - SDB_TYPE. This parallels what we do for other debug - formats, and probably is needed to make - print_address_symbolic work right without the (now - gone) "set fast-symbolic-addr off" kludge. */ + } + else if (!SDB_TYPE (cs->c_type) + && cs->c_name[0] == 'L' + && (strncmp (cs->c_name, "LI%", 3) == 0 + || strncmp (cs->c_name, "LF%", 3) == 0 + || strncmp (cs->c_name, "LC%", 3) == 0 + || strncmp (cs->c_name, "LP%", 3) == 0 + || strncmp (cs->c_name, "LPB%", 4) == 0 + || strncmp (cs->c_name, "LBB%", 4) == 0 + || strncmp (cs->c_name, "LBE%", 4) == 0 + || strncmp (cs->c_name, "LPBX%", 5) == 0)) + /* At least on a 3b1, gcc generates swbeg and string labels + that look like this. Ignore them. */ + break; + /* fall in for static symbols that don't start with '.' */ + case C_THUMBEXT: + case C_THUMBEXTFUNC: + case C_EXT: + { + /* Record it in the minimal symbols regardless of + SDB_TYPE. This parallels what we do for other debug + formats, and probably is needed to make + print_address_symbolic work right without the (now + gone) "set fast-symbolic-addr off" kludge. */ - /* FIXME: should use mst_abs, and not relocate, if absolute. */ - enum minimal_symbol_type ms_type; - int sec; + /* FIXME: should use mst_abs, and not relocate, if absolute. */ + enum minimal_symbol_type ms_type; + int sec; - if (cs->c_secnum == N_UNDEF) - { - /* This is a common symbol. See if the target - environment knows where it has been relocated to. */ - CORE_ADDR reladdr; - if (target_lookup_symbol (cs->c_name, &reladdr)) - { - /* Error in lookup; ignore symbol. */ - break; - } - tmpaddr = reladdr; - /* The address has already been relocated; make sure that - objfile_relocate doesn't relocate it again. */ - sec = -2; - ms_type = cs->c_sclass == C_EXT - || cs->c_sclass == C_THUMBEXT ? - mst_bss : mst_file_bss; - } - else - { - sec = cs_to_section (cs, objfile); - tmpaddr = cs->c_value; - if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC - || cs->c_sclass == C_THUMBEXT) - tmpaddr += ANOFFSET (section_offsets, sec); + if (cs->c_secnum == N_UNDEF) + { + /* This is a common symbol. See if the target + environment knows where it has been relocated to. */ + CORE_ADDR reladdr; + if (target_lookup_symbol (cs->c_name, &reladdr)) + { + /* Error in lookup; ignore symbol. */ + break; + } + tmpaddr = reladdr; + /* The address has already been relocated; make sure that + objfile_relocate doesn't relocate it again. */ + sec = -2; + ms_type = cs->c_sclass == C_EXT + || cs->c_sclass == C_THUMBEXT ? + mst_bss : mst_file_bss; + } + else + { + sec = cs_to_section (cs, objfile); + tmpaddr = cs->c_value; + if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC + || cs->c_sclass == C_THUMBEXT) + tmpaddr += ANOFFSET (section_offsets, sec); - switch (sec) - { - 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; + switch (sec) + { + 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); + if (tmpaddr & 1) /* FIXME: delete this line */ + SMASH_TEXT_ADDRESS (tmpaddr); #endif - break; - case SECT_OFF_DATA: - ms_type = - cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? - mst_data : mst_file_data; - break; - case SECT_OFF_BSS: - ms_type = - cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? - mst_data : mst_file_data; - break; - default: - ms_type = mst_unknown; - break; - } - } + break; + case SECT_OFF_DATA: + ms_type = + cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? + mst_data : mst_file_data; + break; + case SECT_OFF_BSS: + ms_type = + cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? + mst_data : mst_file_data; + break; + default: + ms_type = mst_unknown; + break; + } + } - if (cs->c_name[0] != '@' /* Skip tdesc symbols */) - { - struct minimal_symbol *msym; + if (cs->c_name[0] != '@' /* Skip tdesc symbols */ ) + { + struct minimal_symbol *msym; - msym = prim_record_minimal_symbol_and_info - (cs->c_name, tmpaddr, ms_type, (char *)cs->c_sclass, sec, + 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 - if(msym) - COFF_MAKE_MSYMBOL_SPECIAL(cs->c_sclass, msym); + if (msym) + COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym); #endif + } + if (SDB_TYPE (cs->c_type)) + { + struct symbol *sym; + sym = process_coff_symbol + (cs, &main_aux, section_offsets, objfile); + SYMBOL_VALUE (sym) = tmpaddr; + SYMBOL_SECTION (sym) = sec; + } + } + break; + + case C_FCN: + if (STREQ (cs->c_name, ".bf")) + { + within_function = 1; + + /* value contains address of first non-init type code */ + /* main_aux.x_sym.x_misc.x_lnsz.x_lnno + contains line number of '{' } */ + if (cs->c_naux != 1) + complain (&bf_no_aux_complaint, cs->c_symnum); + fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; + fcn_first_line_addr = cs->c_value; + + /* Might want to check that locals are 0 and + context_stack_depth is zero, and complain if not. */ + + depth = 0; + new = push_context (depth, fcn_start_addr); + fcn_cs_saved.c_name = getsymname (&fcn_sym_saved); + new->name = + process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, + section_offsets, objfile); + } + else if (STREQ (cs->c_name, ".ef")) + { + /* the value of .ef is the address of epilogue code; + not useful for gdb. */ + /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno + contains number of lines to '}' */ + + if (context_stack_depth <= 0) + { /* We attempted to pop an empty context stack */ + complain (&ef_stack_complaint, cs->c_symnum); + within_function = 0; + break; } - if (SDB_TYPE (cs->c_type)) + + new = pop_context (); + /* Stack must be empty now. */ + if (context_stack_depth > 0 || new == NULL) { - struct symbol *sym; - sym = process_coff_symbol - (cs, &main_aux, section_offsets, objfile); - SYMBOL_VALUE (sym) = tmpaddr; - SYMBOL_SECTION (sym) = sec; + complain (&ef_complaint, cs->c_symnum); + within_function = 0; + break; } - } - break; - - case C_FCN: - if (STREQ (cs->c_name, ".bf")) - { - within_function = 1; - - /* value contains address of first non-init type code */ - /* main_aux.x_sym.x_misc.x_lnsz.x_lnno - contains line number of '{' } */ - if (cs->c_naux != 1) - complain (&bf_no_aux_complaint, cs->c_symnum); - fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; - fcn_first_line_addr = cs->c_value; - - /* Might want to check that locals are 0 and - context_stack_depth is zero, and complain if not. */ - - depth = 0; - new = push_context (depth, fcn_start_addr); - fcn_cs_saved.c_name = getsymname (&fcn_sym_saved); - new->name = - process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, - section_offsets, objfile); - } - else if (STREQ (cs->c_name, ".ef")) - { - /* the value of .ef is the address of epilogue code; - not useful for gdb. */ - /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno - contains number of lines to '}' */ - - if (context_stack_depth <= 0) - { /* We attempted to pop an empty context stack */ - complain (&ef_stack_complaint, cs->c_symnum); - within_function = 0; - break; - } + if (cs->c_naux != 1) + { + complain (&ef_no_aux_complaint, cs->c_symnum); + fcn_last_line = 0x7FFFFFFF; + } + else + { + fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; + } + /* fcn_first_line is the line number of the opening '{'. + Do not record it - because it would affect gdb's idea + of the line number of the first statement of the function - + except for one-line functions, for which it is also the line + number of all the statements and 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, + fcn_first_line_addr); + else + enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line, + section_offsets); - new = pop_context (); - /* Stack must be empty now. */ - if (context_stack_depth > 0 || new == NULL) - { - complain (&ef_complaint, cs->c_symnum); - within_function = 0; - break; - } - if (cs->c_naux != 1) - { - complain (&ef_no_aux_complaint, cs->c_symnum); - fcn_last_line = 0x7FFFFFFF; - } - else - { - fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; - } - /* fcn_first_line is the line number of the opening '{'. - Do not record it - because it would affect gdb's idea - of the line number of the first statement of the function - - except for one-line functions, for which it is also the line - number of all the statements and 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, - fcn_first_line_addr); - else - enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line, - section_offsets); - - finish_block (new->name, &local_symbols, new->old_blocks, - new->start_addr, + 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 (section_offsets, SECT_OFF_TEXT), + /* 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 (section_offsets, SECT_OFF_TEXT), #else - fcn_cs_saved.c_value - + fcn_aux_saved.x_sym.x_misc.x_fsize - + ANOFFSET (section_offsets, SECT_OFF_TEXT), + fcn_cs_saved.c_value + + fcn_aux_saved.x_sym.x_misc.x_fsize + + ANOFFSET (section_offsets, SECT_OFF_TEXT), #endif - objfile - ); - within_function = 0; - } - break; + objfile + ); + within_function = 0; + } + break; - case C_BLOCK: - if (STREQ (cs->c_name, ".bb")) - { - tmpaddr = cs->c_value; - tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT); - push_context (++depth, tmpaddr); - } - else if (STREQ (cs->c_name, ".eb")) - { - if (context_stack_depth <= 0) - { /* We attempted to pop an empty context stack */ - complain (&eb_stack_complaint, cs->c_symnum); - break; - } + case C_BLOCK: + if (STREQ (cs->c_name, ".bb")) + { + tmpaddr = cs->c_value; + tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT); + push_context (++depth, tmpaddr); + } + else if (STREQ (cs->c_name, ".eb")) + { + if (context_stack_depth <= 0) + { /* We attempted to pop an empty context stack */ + complain (&eb_stack_complaint, cs->c_symnum); + break; + } - new = pop_context (); - if (depth-- != new->depth) - { - complain (&eb_complaint, symnum); - break; - } - if (local_symbols && context_stack_depth > 0) - { - tmpaddr = - cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT); - /* Make a block for the local symbols within. */ - finish_block (0, &local_symbols, new->old_blocks, - new->start_addr, tmpaddr, objfile); - } - /* Now pop locals of block just finished. */ - local_symbols = new->locals; - } - break; + new = pop_context (); + if (depth-- != new->depth) + { + complain (&eb_complaint, symnum); + break; + } + if (local_symbols && context_stack_depth > 0) + { + tmpaddr = + cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT); + /* Make a block for the local symbols within. */ + finish_block (0, &local_symbols, new->old_blocks, + new->start_addr, tmpaddr, objfile); + } + /* Now pop locals of block just finished. */ + local_symbols = new->locals; + } + break; - default: - process_coff_symbol (cs, &main_aux, section_offsets, objfile); - break; + default: + process_coff_symbol (cs, &main_aux, section_offsets, objfile); + break; } } @@ -1162,25 +1169,25 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile) static void read_one_sym (cs, sym, aux) - register struct coff_symbol *cs; - register struct internal_syment *sym; - register union internal_auxent *aux; + 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_coff_swap_sym_in (symfile_bfd, temp_sym, (char *)sym); + 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_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_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); } cs->c_name = getsymname (sym); cs->c_value = sym->n_value; @@ -1192,7 +1199,7 @@ read_one_sym (cs, sym, aux) #if 0 if (cs->c_sclass & 128) - printf("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass); + printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass); #endif symnum += 1 + cs->c_naux; @@ -1232,8 +1239,8 @@ static char *stringtab = NULL; static int init_stringtab (abfd, offset) - bfd *abfd; - long offset; + bfd *abfd; + long offset; { long length; int val; @@ -1249,9 +1256,9 @@ init_stringtab (abfd, offset) if (bfd_seek (abfd, offset, 0) < 0) return -1; - val = bfd_read ((char *)lengthbuf, sizeof lengthbuf, 1, abfd); + val = bfd_read ((char *) lengthbuf, sizeof lengthbuf, 1, abfd); length = bfd_h_get_32 (symfile_bfd, lengthbuf); - + /* If no string table is needed, then the file may end immediately after the symbols. Just return with `stringtab' set to null. */ if (val != sizeof lengthbuf || length < sizeof lengthbuf) @@ -1261,7 +1268,7 @@ init_stringtab (abfd, offset) /* This is in target format (probably not very useful, and not currently used), not host format. */ memcpy (stringtab, lengthbuf, sizeof lengthbuf); - if (length == sizeof length) /* Empty table -- just the count */ + if (length == sizeof length) /* Empty table -- just the count */ return 0; val = bfd_read (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1, abfd); @@ -1281,15 +1288,15 @@ free_stringtab () static char * getsymname (symbol_entry) - struct internal_syment *symbol_entry; + struct internal_syment *symbol_entry; { - static char buffer[SYMNMLEN+1]; + static char buffer[SYMNMLEN + 1]; char *result; if (symbol_entry->_n._n_n._n_zeroes == 0) { /* FIXME: Probably should be detecting corrupt symbol files by - seeing whether offset points to within the stringtab. */ + seeing whether offset points to within the stringtab. */ result = stringtab + symbol_entry->_n._n_n._n_offset; } else @@ -1307,7 +1314,7 @@ getsymname (symbol_entry) static char * coff_getfilename (aux_entry) - union internal_auxent *aux_entry; + union internal_auxent *aux_entry; { static char buffer[BUFSIZ]; register char *temp; @@ -1339,26 +1346,26 @@ 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 (abfd, offset, size) - bfd *abfd; - long offset; - int size; + bfd *abfd; + long offset; + int size; { int val; linetab_offset = offset; linetab_size = size; - free_linetab(); + free_linetab (); if (size == 0) return 0; if (bfd_seek (abfd, offset, 0) < 0) return -1; - + /* Allocate the desired table, plus a sentinel */ linetab = (char *) xmalloc (size + local_linesz); @@ -1395,15 +1402,15 @@ enter_linenos (file_offset, first_line, last_line, section_offsets) struct internal_lineno lptr; if (!linetab) - return ; + return; if (file_offset < linetab_offset) { complain (&lineno_complaint, file_offset); if (file_offset > linetab_size) /* Too big to be an offset? */ return; - file_offset += linetab_offset; /* Try reading at that linetab offset */ + file_offset += linetab_offset; /* Try reading at that linetab offset */ } - + rawptr = &linetab[file_offset - linetab_offset]; /* skip first line entry for each function */ @@ -1411,23 +1418,24 @@ enter_linenos (file_offset, first_line, last_line, section_offsets) /* line numbers start at one for the first line of the function */ first_line--; - for (;;) { - bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr); - rawptr += local_linesz; - /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */ - 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)); - else - break; - } + for (;;) + { + bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr); + rawptr += local_linesz; + /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */ + 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)); + else + break; + } } static void patch_type (type, real_type) - struct type *type; - struct type *real_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); @@ -1457,15 +1465,15 @@ patch_opaque_types (s) register struct block *b; register int i; register struct symbol *real_sym; - + /* Go through the per-file symbols only */ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); for (i = BLOCK_NSYMS (b) - 1; i >= 0; i--) { /* Find completed typedefs to use to fix opaque ones. - Remove syms from the chain when their types are stored, - but search the whole chain, as there may be several syms - from different files with the same name. */ + Remove syms from the chain when their types are stored, + but search the whole chain, as there may be several syms + from different files with the same name. */ real_sym = BLOCK_SYM (b, i); if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF && SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE && @@ -1475,7 +1483,7 @@ patch_opaque_types (s) register char *name = SYMBOL_NAME (real_sym); register int hash = hashname (name); register struct symbol *sym, *prev; - + prev = 0; for (sym = opaque_type_chain[hash]; sym;) { @@ -1490,9 +1498,9 @@ patch_opaque_types (s) { opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym); } - + patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym)); - + if (prev) { sym = SYMBOL_VALUE_CHAIN (prev); @@ -1520,8 +1528,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile) struct objfile *objfile; { register struct symbol *sym - = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, - sizeof (struct symbol)); + = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, + sizeof (struct symbol)); char *name; memset (sym, 0, sizeof (struct symbol)); @@ -1540,8 +1548,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile) if (ISFCN (cs->c_type)) { SYMBOL_VALUE (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT); - SYMBOL_TYPE(sym) = - lookup_function_type (decode_function_type (cs, cs->c_type, aux)); + SYMBOL_TYPE (sym) = + lookup_function_type (decode_function_type (cs, cs->c_type, aux)); SYMBOL_CLASS (sym) = LOC_BLOCK; if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT @@ -1556,181 +1564,183 @@ process_coff_symbol (cs, aux, section_offsets, objfile) SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux); switch (cs->c_sclass) { - case C_NULL: - break; + case C_NULL: + break; - case C_AUTO: - SYMBOL_CLASS (sym) = LOC_LOCAL; - add_symbol_to_list (sym, &local_symbols); - break; + case C_AUTO: + SYMBOL_CLASS (sym) = LOC_LOCAL; + add_symbol_to_list (sym, &local_symbols); + break; - case C_THUMBEXT: - case C_THUMBEXTFUNC: - case C_EXT: - SYMBOL_CLASS (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT); - add_symbol_to_list (sym, &global_symbols); - break; + case C_THUMBEXT: + case C_THUMBEXTFUNC: + case C_EXT: + SYMBOL_CLASS (sym) = LOC_STATIC; + SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; + SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT); + add_symbol_to_list (sym, &global_symbols); + break; - case C_THUMBSTAT: - case C_THUMBSTATFUNC: - case C_STAT: - SYMBOL_CLASS (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT); - if (within_function) { + case C_THUMBSTAT: + case C_THUMBSTATFUNC: + case C_STAT: + SYMBOL_CLASS (sym) = LOC_STATIC; + SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; + SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT); + if (within_function) + { /* Static symbol of local scope */ add_symbol_to_list (sym, &local_symbols); } - else { + else + { /* Static symbol at top level of file */ add_symbol_to_list (sym, &file_symbols); } - break; + break; #ifdef C_GLBLREG /* AMD coff */ - case C_GLBLREG: + case C_GLBLREG: #endif - case C_REG: - SYMBOL_CLASS (sym) = LOC_REGISTER; - SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value); - add_symbol_to_list (sym, &local_symbols); - break; + case C_REG: + SYMBOL_CLASS (sym) = LOC_REGISTER; + SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value); + add_symbol_to_list (sym, &local_symbols); + break; - case C_THUMBLABEL: - case C_LABEL: - break; + case C_THUMBLABEL: + case C_LABEL: + break; - case C_ARG: - SYMBOL_CLASS (sym) = LOC_ARG; - add_symbol_to_list (sym, &local_symbols); + case C_ARG: + SYMBOL_CLASS (sym) = LOC_ARG; + add_symbol_to_list (sym, &local_symbols); #if !defined (BELIEVE_PCC_PROMOTION) - if (TARGET_BYTE_ORDER == BIG_ENDIAN) - { - /* 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)); - } - } + if (TARGET_BYTE_ORDER == BIG_ENDIAN) + { + /* 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; + break; - case C_REGPARM: - SYMBOL_CLASS (sym) = LOC_REGPARM; - SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value); - add_symbol_to_list (sym, &local_symbols); + case C_REGPARM: + SYMBOL_CLASS (sym) = LOC_REGPARM; + SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (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 */ + /* 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) { - /* 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); - } + SYMBOL_TYPE (sym) = + (TYPE_UNSIGNED (SYMBOL_TYPE (sym)) + ? lookup_fundamental_type (current_objfile, + FT_UNSIGNED_INTEGER) + : temptype); } + } #endif - break; - - case C_TPDEF: - SYMBOL_CLASS (sym) = LOC_TYPEDEF; - SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; + break; - /* If type has no name, give it one */ - if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - { - if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR - || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC) - { - /* If we are giving a name to a type such as "pointer to - foo" or "function returning foo", we better not set - the TYPE_NAME. If the program contains "typedef char - *caddr_t;", we don't want all variables of type char - * to print as caddr_t. This is not just a - consequence of GDB's type management; CC and GCC (at - least through version 2.4) both output variables of - either type char * or caddr_t with the type - refering to the C_TPDEF symbol for caddr_t. If a future - compiler cleans this up it GDB is not ready for it - yet, but if it becomes ready we somehow need to - disable this check (without breaking the PCC/GCC2.4 - case). - - Sigh. - - Fortunately, this check seems not to be necessary - for anything except pointers or functions. */ - ; - } - else - TYPE_NAME (SYMBOL_TYPE (sym)) = - concat (SYMBOL_NAME (sym), NULL); - } + case C_TPDEF: + SYMBOL_CLASS (sym) = LOC_TYPEDEF; + SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; + + /* If type has no name, give it one */ + if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) + { + if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR + || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC) + { + /* If we are giving a name to a type such as "pointer to + foo" or "function returning foo", we better not set + the TYPE_NAME. If the program contains "typedef char + *caddr_t;", we don't want all variables of type char + * to print as caddr_t. This is not just a + consequence of GDB's type management; CC and GCC (at + least through version 2.4) both output variables of + either type char * or caddr_t with the type + refering to the C_TPDEF symbol for caddr_t. If a future + compiler cleans this up it GDB is not ready for it + yet, but if it becomes ready we somehow need to + disable this check (without breaking the PCC/GCC2.4 + case). + + Sigh. + + Fortunately, this check seems not to be necessary + for anything except pointers or functions. */ + ; + } + else + TYPE_NAME (SYMBOL_TYPE (sym)) = + concat (SYMBOL_NAME (sym), NULL); + } #ifdef CXUX_TARGET - /* Ignore vendor section for Harris CX/UX targets. */ - else if (cs->c_name[0] == '$') - break; + /* Ignore vendor section for Harris CX/UX targets. */ + else if (cs->c_name[0] == '$') + break; #endif /* CXUX_TARGET */ - /* Keep track of any type which points to empty structured type, - so it can be filled from a definition from another file. A - simple forward reference (TYPE_CODE_UNDEF) is not an - empty structured type, though; the forward references - work themselves out via the magic of coff_lookup_type. */ - if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR && - TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 && - TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) != - TYPE_CODE_UNDEF) - { - register int i = hashname (SYMBOL_NAME (sym)); - - SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i]; - opaque_type_chain[i] = sym; - } - add_symbol_to_list (sym, &file_symbols); - break; + /* Keep track of any type which points to empty structured type, + so it can be filled from a definition from another file. A + simple forward reference (TYPE_CODE_UNDEF) is not an + empty structured type, though; the forward references + work themselves out via the magic of coff_lookup_type. */ + if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR && + TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 && + TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) != + TYPE_CODE_UNDEF) + { + register int i = hashname (SYMBOL_NAME (sym)); - case C_STRTAG: - case C_UNTAG: - case C_ENTAG: - SYMBOL_CLASS (sym) = LOC_TYPEDEF; - SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; - - /* Some compilers try to be helpful by inventing "fake" - names for anonymous enums, structures, and unions, like - "~0fake" or ".0fake". Thanks, but no thanks... */ - if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0) - if (SYMBOL_NAME(sym) != NULL - && *SYMBOL_NAME(sym) != '~' - && *SYMBOL_NAME(sym) != '.') - TYPE_TAG_NAME (SYMBOL_TYPE (sym)) = - concat (SYMBOL_NAME (sym), NULL); + SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i]; + opaque_type_chain[i] = sym; + } + add_symbol_to_list (sym, &file_symbols); + break; - add_symbol_to_list (sym, &file_symbols); - break; + case C_STRTAG: + case C_UNTAG: + case C_ENTAG: + SYMBOL_CLASS (sym) = LOC_TYPEDEF; + SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; + + /* Some compilers try to be helpful by inventing "fake" + names for anonymous enums, structures, and unions, like + "~0fake" or ".0fake". Thanks, but no thanks... */ + if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0) + if (SYMBOL_NAME (sym) != NULL + && *SYMBOL_NAME (sym) != '~' + && *SYMBOL_NAME (sym) != '.') + TYPE_TAG_NAME (SYMBOL_TYPE (sym)) = + concat (SYMBOL_NAME (sym), NULL); + + add_symbol_to_list (sym, &file_symbols); + break; - default: - break; + default: + break; } } return sym; @@ -1826,7 +1836,7 @@ decode_function_type (cs, c_type, aux) register union internal_auxent *aux; { if (aux->x_sym.x_tagndx.l == 0) - cs->c_naux = 0; /* auxent refers to function, not base type */ + cs->c_naux = 0; /* auxent refers to function, not base type */ return decode_type (cs, DECREF (c_type), aux); } @@ -1843,140 +1853,140 @@ decode_base_type (cs, c_type, aux) switch (c_type) { - case T_NULL: - /* shows up with "void (*foo)();" structure members */ - return lookup_fundamental_type (current_objfile, FT_VOID); + case T_NULL: + /* shows up with "void (*foo)();" structure members */ + return lookup_fundamental_type (current_objfile, FT_VOID); #if 0 /* DGUX actually defines both T_ARG and T_VOID to the same value. */ #ifdef T_ARG - case T_ARG: - /* Shows up in DGUX, I think. Not sure where. */ - return lookup_fundamental_type (current_objfile, FT_VOID); /* shouldn't show up here */ + case T_ARG: + /* Shows up in DGUX, I think. Not sure where. */ + return lookup_fundamental_type (current_objfile, FT_VOID); /* shouldn't show up here */ #endif #endif /* 0 */ #ifdef T_VOID - case T_VOID: - /* Intel 960 COFF has this symbol and meaning. */ - return lookup_fundamental_type (current_objfile, FT_VOID); + case T_VOID: + /* Intel 960 COFF has this symbol and meaning. */ + return lookup_fundamental_type (current_objfile, FT_VOID); #endif - case T_CHAR: - return lookup_fundamental_type (current_objfile, FT_CHAR); - - case T_SHORT: - return lookup_fundamental_type (current_objfile, FT_SHORT); + case T_CHAR: + return lookup_fundamental_type (current_objfile, FT_CHAR); - case T_INT: - return lookup_fundamental_type (current_objfile, FT_INTEGER); + case T_SHORT: + return lookup_fundamental_type (current_objfile, FT_SHORT); - 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); - else - return lookup_fundamental_type (current_objfile, FT_LONG); + case T_INT: + return lookup_fundamental_type (current_objfile, FT_INTEGER); - case T_FLOAT: - return lookup_fundamental_type (current_objfile, FT_FLOAT); + 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); + else + return lookup_fundamental_type (current_objfile, FT_LONG); - case T_DOUBLE: - return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT); + case T_FLOAT: + return lookup_fundamental_type (current_objfile, FT_FLOAT); - case T_LNGDBL: - return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT); + case T_DOUBLE: + return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT); - case T_STRUCT: - if (cs->c_naux != 1) - { - /* anonymous structure type */ - type = coff_alloc_type (cs->c_symnum); - TYPE_CODE (type) = TYPE_CODE_STRUCT; - TYPE_NAME (type) = NULL; - /* This used to set the tag to "<opaque>". But I think setting it - to NULL is right, and the printing code can print it as - "struct {...}". */ - TYPE_TAG_NAME (type) = NULL; - INIT_CPLUS_SPECIFIC(type); - TYPE_LENGTH (type) = 0; - TYPE_FIELDS (type) = 0; - TYPE_NFIELDS (type) = 0; - } - else - { - 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); - } - return type; + case T_LNGDBL: + return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT); - case T_UNION: - if (cs->c_naux != 1) - { - /* anonymous union type */ - type = coff_alloc_type (cs->c_symnum); - TYPE_NAME (type) = NULL; - /* This used to set the tag to "<opaque>". But I think setting it - to NULL is right, and the printing code can print it as - "union {...}". */ - TYPE_TAG_NAME (type) = NULL; - INIT_CPLUS_SPECIFIC(type); - TYPE_LENGTH (type) = 0; - TYPE_FIELDS (type) = 0; - TYPE_NFIELDS (type) = 0; - } - else - { - 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); - } - TYPE_CODE (type) = TYPE_CODE_UNION; - return type; + case T_STRUCT: + if (cs->c_naux != 1) + { + /* anonymous structure type */ + type = coff_alloc_type (cs->c_symnum); + TYPE_CODE (type) = TYPE_CODE_STRUCT; + TYPE_NAME (type) = NULL; + /* This used to set the tag to "<opaque>". But I think setting it + to NULL is right, and the printing code can print it as + "struct {...}". */ + TYPE_TAG_NAME (type) = NULL; + INIT_CPLUS_SPECIFIC (type); + TYPE_LENGTH (type) = 0; + TYPE_FIELDS (type) = 0; + TYPE_NFIELDS (type) = 0; + } + else + { + 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); + } + return type; - case T_ENUM: - if (cs->c_naux != 1) - { - /* anonymous enum type */ - type = coff_alloc_type (cs->c_symnum); - TYPE_CODE (type) = TYPE_CODE_ENUM; - TYPE_NAME (type) = NULL; - /* This used to set the tag to "<opaque>". But I think setting it - to NULL is right, and the printing code can print it as - "enum {...}". */ - TYPE_TAG_NAME (type) = NULL; - TYPE_LENGTH (type) = 0; - TYPE_FIELDS (type) = 0; - TYPE_NFIELDS(type) = 0; - } - else - { - type = coff_read_enum_type (cs->c_symnum, + case T_UNION: + if (cs->c_naux != 1) + { + /* anonymous union type */ + type = coff_alloc_type (cs->c_symnum); + TYPE_NAME (type) = NULL; + /* This used to set the tag to "<opaque>". But I think setting it + to NULL is right, and the printing code can print it as + "union {...}". */ + TYPE_TAG_NAME (type) = NULL; + INIT_CPLUS_SPECIFIC (type); + TYPE_LENGTH (type) = 0; + TYPE_FIELDS (type) = 0; + TYPE_NFIELDS (type) = 0; + } + else + { + 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); - } - return type; + aux->x_sym.x_fcnary.x_fcn.x_endndx.l); + } + TYPE_CODE (type) = TYPE_CODE_UNION; + return type; - case T_MOE: - /* shouldn't show up here */ - break; + case T_ENUM: + if (cs->c_naux != 1) + { + /* anonymous enum type */ + type = coff_alloc_type (cs->c_symnum); + TYPE_CODE (type) = TYPE_CODE_ENUM; + TYPE_NAME (type) = NULL; + /* This used to set the tag to "<opaque>". But I think setting it + to NULL is right, and the printing code can print it as + "enum {...}". */ + TYPE_TAG_NAME (type) = NULL; + TYPE_LENGTH (type) = 0; + TYPE_FIELDS (type) = 0; + TYPE_NFIELDS (type) = 0; + } + else + { + 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); + } + return type; + + case T_MOE: + /* shouldn't show up here */ + break; - case T_UCHAR: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR); + case T_UCHAR: + return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR); - case T_USHORT: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT); + case T_USHORT: + return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT); - case T_UINT: - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER); + case T_UINT: + return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER); - 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); - else - return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG); + 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); + else + return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG); } complain (&unexpected_type_complaint, cs->c_name); return lookup_fundamental_type (current_objfile, FT_VOID); @@ -2013,7 +2023,7 @@ coff_read_struct_type (index, length, lastsym) type = coff_alloc_type (index); TYPE_CODE (type) = TYPE_CODE_STRUCT; - INIT_CPLUS_SPECIFIC(type); + INIT_CPLUS_SPECIFIC (type); TYPE_LENGTH (type) = length; while (!done && symnum < lastsym && symnum < nlist_nsyms_global) @@ -2024,46 +2034,46 @@ coff_read_struct_type (index, length, lastsym) switch (ms->c_sclass) { - case C_MOS: - case C_MOU: - - /* Get space to record the next field's data. */ - new = (struct nextfield *) alloca (sizeof (struct nextfield)); - new->next = list; - list = new; - - /* Save the data. */ - list->field.name = - obsavestring (name, - strlen (name), - ¤t_objfile->symbol_obstack); - FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); - FIELD_BITPOS (list->field) = 8 * ms->c_value; - FIELD_BITSIZE (list->field) = 0; - nfields++; - break; + case C_MOS: + case C_MOU: + + /* Get space to record the next field's data. */ + new = (struct nextfield *) alloca (sizeof (struct nextfield)); + new->next = list; + list = new; + + /* Save the data. */ + list->field.name = + obsavestring (name, + strlen (name), + ¤t_objfile->symbol_obstack); + FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); + FIELD_BITPOS (list->field) = 8 * ms->c_value; + FIELD_BITSIZE (list->field) = 0; + nfields++; + break; - case C_FIELD: - - /* Get space to record the next field's data. */ - new = (struct nextfield *) alloca (sizeof (struct nextfield)); - new->next = list; - list = new; - - /* Save the data. */ - list->field.name = - obsavestring (name, - strlen (name), - ¤t_objfile->symbol_obstack); - FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); - FIELD_BITPOS (list->field) = ms->c_value; - FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size; - nfields++; - break; + case C_FIELD: + + /* Get space to record the next field's data. */ + new = (struct nextfield *) alloca (sizeof (struct nextfield)); + new->next = list; + list = new; + + /* Save the data. */ + list->field.name = + obsavestring (name, + strlen (name), + ¤t_objfile->symbol_obstack); + FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux); + FIELD_BITPOS (list->field) = ms->c_value; + FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size; + nfields++; + break; - case C_EOS: - done = 1; - break; + case C_EOS: + done = 1; + break; } } /* Now create the vector of fields, and record how big it is. */ @@ -2122,28 +2132,28 @@ coff_read_enum_type (index, length, lastsym) switch (ms->c_sclass) { - case C_MOE: - sym = (struct symbol *) obstack_alloc - (¤t_objfile->symbol_obstack, - sizeof (struct symbol)); - memset (sym, 0, sizeof (struct symbol)); - - SYMBOL_NAME (sym) = - obsavestring (name, strlen (name), - ¤t_objfile->symbol_obstack); - SYMBOL_CLASS (sym) = LOC_CONST; - SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; - SYMBOL_VALUE (sym) = ms->c_value; - add_symbol_to_list (sym, symlist); - nsyms++; - break; + case C_MOE: + sym = (struct symbol *) obstack_alloc + (¤t_objfile->symbol_obstack, + sizeof (struct symbol)); + memset (sym, 0, sizeof (struct symbol)); + + SYMBOL_NAME (sym) = + obsavestring (name, strlen (name), + ¤t_objfile->symbol_obstack); + SYMBOL_CLASS (sym) = LOC_CONST; + SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; + SYMBOL_VALUE (sym) = ms->c_value; + add_symbol_to_list (sym, symlist); + nsyms++; + break; - case C_EOS: - /* Sometimes the linker (on 386/ix 2.0.2 at least) screws - up the count of how many symbols to read. So stop - on .eos. */ - done = 1; - break; + case C_EOS: + /* Sometimes the linker (on 386/ix 2.0.2 at least) screws + up the count of how many symbols to read. So stop + on .eos. */ + done = 1; + break; } } @@ -2152,7 +2162,7 @@ coff_read_enum_type (index, length, lastsym) if (length > 0) TYPE_LENGTH (type) = length; else - TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */ + TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */ TYPE_CODE (type) = TYPE_CODE_ENUM; TYPE_NFIELDS (type) = nsyms; TYPE_FIELDS (type) = (struct field *) @@ -2172,7 +2182,7 @@ coff_read_enum_type (index, length, lastsym) if (syms == osyms) j = o_nsyms; - for (; j < syms->nsyms; j++,n++) + for (; j < syms->nsyms; j++, n++) { struct symbol *xsym = syms->symbol[j]; SYMBOL_TYPE (xsym) = type; @@ -2197,13 +2207,13 @@ coff_read_enum_type (index, length, lastsym) static struct sym_fns coff_sym_fns = { bfd_target_coff_flavour, - coff_new_init, /* sym_new_init: init anything gbl to entire symtab */ - coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */ - coff_symfile_read, /* sym_read: read a symbol file into symtab */ - coff_symfile_finish, /* sym_finish: finished with file, cleanup */ + coff_new_init, /* sym_new_init: init anything gbl to entire symtab */ + coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */ + 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 */ - NULL /* next: pointer to next struct sym_fns */ + NULL /* next: pointer to next struct sym_fns */ }; void |