X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fxcoffread.c;h=a858ffea3e66fb9b9d978eabe1244ffdffebf586;hb=fcaad03cc027ec2cdf7f2cff70d792867d43c57f;hp=a794f61643f7de265c4c623b2a9e663ea0729cd1;hpb=581e13c1888512fde1bd3ff9e46f1a3ec4c337d7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c index a794f61643..a858ffea3e 100644 --- a/gdb/xcoffread.c +++ b/gdb/xcoffread.c @@ -1,7 +1,5 @@ /* Read AIX xcoff symbol tables and convert to internal format, for GDB. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, - 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 1986-2018 Free Software Foundation, Inc. Derived from coffread.c, dbxread.c, and a lot of hacking. Contributed by IBM Corporation. @@ -26,13 +24,10 @@ #include #include #include -#include "gdb_string.h" - -#include #ifdef HAVE_SYS_FILE_H #include #endif -#include "gdb_stat.h" +#include #include "coff/internal.h" #include "libcoff.h" /* FIXME, internal data from BFD */ @@ -46,7 +41,7 @@ /* FIXME: ezannoni/2004-02-13 Verify if the include below is really needed. */ #include "symfile.h" #include "objfiles.h" -#include "buildsym.h" +#include "buildsym-legacy.h" #include "stabsread.h" #include "expression.h" #include "complaints.h" @@ -58,6 +53,10 @@ #include "aout/stab_gnu.h" +/* Key for XCOFF-associated data. */ + +static const struct objfile_data *xcoff_objfile_data_key; + /* We put a pointer to this structure in the read_symtab_private field of the psymtab. */ @@ -93,7 +92,7 @@ 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. */ - long c_value; + CORE_ADDR c_value; unsigned char c_sclass; int c_secnum; unsigned int c_type; @@ -120,11 +119,6 @@ static CORE_ADDR first_object_file_end; #define INITIAL_STABVECTOR_LENGTH 40 -/* Nonzero if within a function (so symbols should be local, - if nothing says specifically). */ - -int within_function; - /* Size of a COFF symbol. I think it is always 18, so I'm not sure there is any reason not to just use a #define, but might as well ask BFD for the size and store it here, I guess. */ @@ -152,32 +146,63 @@ struct coff_symfile_info CORE_ADDR toc_offset; }; +/* Convenience macro to access the per-objfile XCOFF data. */ + +#define XCOFF_DATA(objfile) \ + ((struct coff_symfile_info *) objfile_data ((objfile), \ + xcoff_objfile_data_key)) + +/* XCOFF names for dwarf sections. There is no compressed sections. */ + +static const struct dwarf2_debug_sections dwarf2_xcoff_names = { + { ".dwinfo", NULL }, + { ".dwabrev", NULL }, + { ".dwline", NULL }, + { ".dwloc", NULL }, + { NULL, NULL }, /* debug_loclists */ + /* AIX XCOFF defines one, named DWARF section for macro debug information. + XLC does not generate debug_macinfo for DWARF4 and below. + The section is assigned to debug_macro for DWARF5 and above. */ + { NULL, NULL }, + { ".dwmac", NULL }, + { ".dwstr", NULL }, + { NULL, NULL }, /* debug_line_str */ + { ".dwrnges", NULL }, + { NULL, NULL }, /* debug_rnglists */ + { ".dwpbtyp", NULL }, + { NULL, NULL }, /* debug_addr */ + { ".dwframe", NULL }, + { NULL, NULL }, /* eh_frame */ + { NULL, NULL }, /* gdb_index */ + { NULL, NULL }, /* debug_names */ + { NULL, NULL }, /* debug_aranges */ + 23 +}; + static void bf_notfound_complaint (void) { - complaint (&symfile_complaints, - _("line numbers off, `.bf' symbol not found")); + complaint (_("line numbers off, `.bf' symbol not found")); } static void ef_complaint (int arg1) { - complaint (&symfile_complaints, - _("Mismatched .ef symbol ignored starting at symnum %d"), arg1); + complaint (_("Mismatched .ef symbol ignored starting at symnum %d"), arg1); } static void eb_complaint (int arg1) { - complaint (&symfile_complaints, - _("Mismatched .eb symbol ignored starting at symnum %d"), arg1); + complaint (_("Mismatched .eb symbol ignored starting at symnum %d"), arg1); } -static void xcoff_initial_scan (struct objfile *, int); +static void xcoff_initial_scan (struct objfile *, symfile_add_flags); -static void scan_xcoff_symtab (struct objfile *); +static void scan_xcoff_symtab (minimal_symbol_reader &, + struct objfile *); -static char *xcoff_next_symbol_text (struct objfile *); +static const char *xcoff_next_symbol_text (struct objfile *); static void record_include_begin (struct coff_symbol *); @@ -193,9 +218,6 @@ static void xcoff_new_init (struct objfile *); static void xcoff_symfile_finish (struct objfile *); -static void xcoff_symfile_offsets (struct objfile *, - struct section_addr_info *addrs); - static char *coff_getfilename (union internal_auxent *, struct objfile *); static void read_symbol (struct internal_syment *, int); @@ -207,7 +229,7 @@ static CORE_ADDR read_symbol_nvalue (int); static struct symbol *process_xcoff_symbol (struct coff_symbol *, struct objfile *); -static void read_xcoff_symtab (struct partial_symtab *); +static void read_xcoff_symtab (struct objfile *, struct partial_symtab *); #if 0 static void add_stab_to_list (char *, struct pending_stabs **); @@ -251,41 +273,58 @@ find_targ_sec (bfd *abfd, asection *sect, void *obj) else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD) *args->resultp = SECT_OFF_DATA (objfile); else - *args->resultp = sect->index; + *args->resultp = gdb_bfd_section_index (abfd, sect); *args->bfd_sect = sect; } } -/* Return the section number (SECT_OFF_*) that CS points to. */ -static int -secnum_to_section (int secnum, struct objfile *objfile) -{ - int off = SECT_OFF_TEXT (objfile); +/* Search all BFD sections for the section whose target_index is + equal to N_SCNUM. Set *BFD_SECT to that section. The section's + associated index in the objfile's section_offset table is also + stored in *SECNUM. + + If no match is found, *BFD_SECT is set to NULL, and *SECNUM + is set to the text section's number. */ - asection *sect = NULL; +static void +xcoff_secnum_to_sections (int n_scnum, struct objfile *objfile, + asection **bfd_sect, int *secnum) +{ struct find_targ_sec_arg args; - args.targ_index = secnum; - args.resultp = &off; - args.bfd_sect = § + + args.targ_index = n_scnum; + args.resultp = secnum; + args.bfd_sect = bfd_sect; args.objfile = objfile; + + *bfd_sect = NULL; + *secnum = SECT_OFF_TEXT (objfile); + bfd_map_over_sections (objfile->obfd, find_targ_sec, &args); - return off; } -/* Return the BFD section that CS points to. */ +/* Return the section number (SECT_OFF_*) that N_SCNUM points to. */ + +static int +secnum_to_section (int n_scnum, struct objfile *objfile) +{ + int secnum; + asection *ignored; + + xcoff_secnum_to_sections (n_scnum, objfile, &ignored, &secnum); + return secnum; +} + +/* Return the BFD section that N_SCNUM points to. */ + static asection * -secnum_to_bfd_section (int secnum, struct objfile *objfile) +secnum_to_bfd_section (int n_scnum, struct objfile *objfile) { - int off = SECT_OFF_TEXT (objfile); + int ignored; + asection *bfd_sect; - asection *sect = NULL; - struct find_targ_sec_arg args; - args.targ_index = secnum; - args.resultp = &off; - args.bfd_sect = § - args.objfile = objfile; - bfd_map_over_sections (objfile->obfd, find_targ_sec, &args); - return sect; + xcoff_secnum_to_sections (n_scnum, objfile, &bfd_sect, &ignored); + return bfd_sect; } /* add a given stab string into given stab vector. */ @@ -397,12 +436,12 @@ arrange_linetable (struct linetable *oldLineTb) struct linetable_entry *fentry; /* function entry vector */ int fentry_size; /* # of function entries */ struct linetable *newLineTb; /* new line table */ + int extra_lines = 0; #define NUM_OF_FUNCTIONS 20 fentry_size = NUM_OF_FUNCTIONS; - fentry = (struct linetable_entry *) - xmalloc (fentry_size * sizeof (struct linetable_entry)); + fentry = XNEWVEC (struct linetable_entry, fentry_size); for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii) { @@ -418,6 +457,12 @@ arrange_linetable (struct linetable *oldLineTb) fentry[function_count].line = ii; fentry[function_count].pc = oldLineTb->item[ii].pc; ++function_count; + + /* If the function was compiled with XLC, we may have to add an + extra line entry later. Reserve space for that. */ + if (ii + 1 < oldLineTb->nitems + && oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc) + extra_lines++; } } @@ -434,7 +479,7 @@ arrange_linetable (struct linetable *oldLineTb) newLineTb = (struct linetable *) xmalloc (sizeof (struct linetable) + - (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry)); + (oldLineTb->nitems - function_count + extra_lines) * sizeof (struct linetable_entry)); /* If line table does not start with a function beginning, copy up until a function begin. */ @@ -449,13 +494,26 @@ arrange_linetable (struct linetable *oldLineTb) for (ii = 0; ii < function_count; ++ii) { + /* If the function was compiled with XLC, we may have to add an + extra line to cover the function prologue. */ + jj = fentry[ii].line; + if (jj + 1 < oldLineTb->nitems + && oldLineTb->item[jj].pc != oldLineTb->item[jj + 1].pc) + { + newLineTb->item[newline] = oldLineTb->item[jj]; + newLineTb->item[newline].line = oldLineTb->item[jj + 1].line; + newline++; + } + for (jj = fentry[ii].line + 1; jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0; ++jj, ++newline) newLineTb->item[newline] = oldLineTb->item[jj]; } xfree (fentry); - newLineTb->nitems = oldLineTb->nitems - function_count; + /* The number of items in the line table must include these + extra lines which were added in case of XLC compiled functions. */ + newLineTb->nitems = oldLineTb->nitems - function_count + extra_lines; return newLineTb; } @@ -497,7 +555,7 @@ record_include_begin (struct coff_symbol *cs) /* This can happen with old versions of GCC. GCC 2.3.3-930426 does not exhibit this on a test case which a user said produced the message for him. */ - complaint (&symfile_complaints, _("Nested C_BINCL symbols")); + complaint (_("Nested C_BINCL symbols")); } ++inclDepth; @@ -514,7 +572,7 @@ record_include_end (struct coff_symbol *cs) if (inclDepth == 0) { - complaint (&symfile_complaints, _("Mismatched C_BINCL/C_EINCL pair")); + complaint (_("Mismatched C_BINCL/C_EINCL pair")); } allocate_include_entry (); @@ -531,18 +589,14 @@ allocate_include_entry (void) { if (inclTable == NULL) { - inclTable = (InclTable *) - xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH); - memset (inclTable, - '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH); + inclTable = XCNEWVEC (InclTable, INITIAL_INCLUDE_TABLE_LENGTH); inclLength = INITIAL_INCLUDE_TABLE_LENGTH; inclIndx = 0; } else if (inclIndx >= inclLength) { inclLength += INITIAL_INCLUDE_TABLE_LENGTH; - inclTable = (InclTable *) - xrealloc (inclTable, sizeof (InclTable) * inclLength); + inclTable = XRESIZEVEC (InclTable, inclTable, inclLength); memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH, '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH); } @@ -552,6 +606,9 @@ allocate_include_entry (void) in psymtab to symtab processing. */ static struct partial_symtab *this_symtab_psymtab; +/* Objfile related to this_symtab_psymtab; set at the same time. */ +static struct objfile *this_symtab_objfile; + /* given the start and end addresses of a compilation unit (or a csect, at times) process its lines and create appropriate line vectors. */ @@ -559,9 +616,8 @@ static void process_linenos (CORE_ADDR start, CORE_ADDR end) { int offset, ii; - file_ptr max_offset = - ((struct coff_symfile_info *) this_symtab_psymtab->objfile - ->deprecated_sym_private)->max_lineno_offset; + file_ptr max_offset + = XCOFF_DATA (this_symtab_objfile)->max_lineno_offset; /* subfile structure for the main compilation unit. */ struct subfile main_subfile; @@ -594,7 +650,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) /* There was source with line numbers in include files. */ int linesz = - coff_data (this_symtab_psymtab->objfile->obfd)->local_linesz; + coff_data (this_symtab_objfile->obfd)->local_linesz; main_source_baseline = 0; for (ii = 0; ii < inclIndx; ++ii) @@ -609,7 +665,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) start, 0, &main_source_baseline); } - if (strcmp (inclTable[ii].name, last_source_file) == 0) + if (strcmp (inclTable[ii].name, get_last_source_file ()) == 0) { /* The entry in the include table refers to the main source file. Add the lines to the main subfile. */ @@ -624,8 +680,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) { /* Have a new subfile for the include file. */ - tmpSubfile = inclTable[ii].subfile = - (struct subfile *) xmalloc (sizeof (struct subfile)); + tmpSubfile = inclTable[ii].subfile = XNEW (struct subfile); memset (tmpSubfile, '\0', sizeof (struct subfile)); firstLine = &(inclTable[ii].funStartLine); @@ -658,6 +713,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) /* Line numbers are not necessarily ordered. xlc compilation will put static function to the end. */ + struct subfile *current_subfile = get_current_subfile (); lineTb = arrange_linetable (lv); if (lv == lineTb) { @@ -709,19 +765,20 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) fool it. */ #if 0 - start_subfile (inclTable[ii].name, (char *) 0); + start_subfile (inclTable[ii].name); #else { /* Pick a fake name that will produce the same results as this one when passed to deduce_language_from_filename. Kludge on top of kludge. */ - char *fakename = strrchr (inclTable[ii].name, '.'); + const char *fakename = strrchr (inclTable[ii].name, '.'); if (fakename == NULL) fakename = " ?"; - start_subfile (fakename, (char *) 0); - xfree (current_subfile->name); + start_subfile (fakename); + xfree (get_current_subfile ()->name); } + struct subfile *current_subfile = get_current_subfile (); current_subfile->name = xstrdup (inclTable[ii].name); #endif @@ -741,7 +798,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end) current_subfile->line_vector_length = current_subfile->line_vector->nitems; - start_subfile (pop_subfile (), (char *) 0); + start_subfile (pop_subfile ()); } } @@ -749,16 +806,17 @@ return_after_cleanup: /* We don't want to keep alloc/free'ing the global include file table. */ inclIndx = 0; - - /* Start with a fresh subfile structure for the next file. */ - memset (&main_subfile, '\0', sizeof (struct subfile)); } static void -aix_process_linenos (void) +aix_process_linenos (struct objfile *objfile) { + /* There is no linenos to read if there are only dwarf info. */ + if (this_symtab_psymtab == NULL) + return; + /* Process line numbers and enter them into line vector. */ - process_linenos (last_source_start_addr, cur_src_end_addr); + process_linenos (get_last_source_start_addr (), cur_src_end_addr); } @@ -778,7 +836,7 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset, CORE_ADDR startaddr, /* offsets to line table */ CORE_ADDR endaddr, unsigned *firstLine) { - struct objfile *objfile = this_symtab_psymtab->objfile; + struct objfile *objfile = this_symtab_objfile; struct gdbarch *gdbarch = get_objfile_arch (objfile); unsigned int curoffset; CORE_ADDR addr; @@ -791,16 +849,13 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset, if (endoffset == 0 && startaddr == 0 && endaddr == 0) return; curoffset = beginoffset; - limit_offset = - ((struct coff_symfile_info *) objfile->deprecated_sym_private) - ->max_lineno_offset; + limit_offset = XCOFF_DATA (objfile)->max_lineno_offset; if (endoffset != 0) { if (endoffset >= limit_offset) { - complaint (&symfile_complaints, - _("Bad line table offset in C_EINCL directive")); + complaint (_("Bad line table offset in C_EINCL directive")); return; } limit_offset = endoffset; @@ -846,8 +901,8 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset, text address for the file, and SIZE is the number of bytes of text. */ #define complete_symtab(name, start_addr) { \ - last_source_file = xstrdup (name); \ - last_source_start_addr = start_addr; \ + set_last_source_file (name); \ + set_last_source_start_addr (start_addr); \ } @@ -857,21 +912,35 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset, This function can read past the end of the symbol table (into the string table) but this does no harm. */ -/* Reading symbol table has to be fast! Keep the followings as macros, rather - than functions. */ - -#define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, SECTION, OBJFILE) \ -{ \ - char *namestr; \ - \ - namestr = (NAME); \ - if (namestr[0] == '.') ++namestr; \ - prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \ - (SECTION), (asection *)NULL, \ - (OBJFILE)); \ - misc_func_recorded = 1; \ -} +/* Create a new minimal symbol (using record_with_info). + + Creation of all new minimal symbols should go through this function + rather than calling the various record functions in order + to make sure that all symbol addresses get properly relocated. + + Arguments are: + + NAME - the symbol's name (but if NAME starts with a period, that + leading period is discarded). + ADDRESS - the symbol's address, prior to relocation. This function + relocates the address before recording the minimal symbol. + MS_TYPE - the symbol's type. + N_SCNUM - the symbol's XCOFF section number. + OBJFILE - the objfile associated with the minimal symbol. */ + +static void +record_minimal_symbol (minimal_symbol_reader &reader, + const char *name, CORE_ADDR address, + enum minimal_symbol_type ms_type, + int n_scnum, + struct objfile *objfile) +{ + if (name[0] == '.') + ++name; + reader.record_with_info (name, address, ms_type, + secnum_to_section (n_scnum, objfile)); +} /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be nested. At any given time, a symbol can only be in one static block. @@ -894,20 +963,20 @@ static char *raw_symbol; /* This is the function which stabsread.c calls to get symbol continuations. */ -static char * +static const char * xcoff_next_symbol_text (struct objfile *objfile) { struct internal_syment symbol; - char *retval; + const char *retval; /* FIXME: is this the same as the passed arg? */ - if (this_symtab_psymtab) - objfile = this_symtab_psymtab->objfile; + if (this_symtab_objfile) + objfile = this_symtab_objfile; bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol); if (symbol.n_zeroes) { - complaint (&symfile_complaints, _("Unexpected symbol continuation")); + complaint (_("Unexpected symbol continuation")); /* Return something which points to '\0' and hope the symbol reading code does something reasonable. */ @@ -915,15 +984,13 @@ xcoff_next_symbol_text (struct objfile *objfile) } else if (symbol.n_sclass & 0x80) { - retval = ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->debugsec - + symbol.n_offset; + retval = XCOFF_DATA (objfile)->debugsec + symbol.n_offset; raw_symbol += coff_data (objfile->obfd)->local_symesz; ++symnum; } else { - complaint (&symfile_complaints, _("Unexpected symbol continuation")); + complaint (_("Unexpected symbol continuation")); /* Return something which points to '\0' and hope the symbol reading code does something reasonable. */ @@ -935,16 +1002,14 @@ xcoff_next_symbol_text (struct objfile *objfile) /* Read symbols for a given partial symbol table. */ static void -read_xcoff_symtab (struct partial_symtab *pst) +read_xcoff_symtab (struct objfile *objfile, struct partial_symtab *pst) { - struct objfile *objfile = pst->objfile; bfd *abfd = objfile->obfd; char *raw_auxptr; /* Pointer to first raw aux entry for sym. */ - char *strtbl = - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl; - char *debugsec = - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->debugsec; - char *debugfmt = bfd_xcoff_is_xcoff64 (abfd) ? "XCOFF64" : "XCOFF"; + struct coff_symfile_info *xcoff = XCOFF_DATA (objfile); + char *strtbl = xcoff->strtbl; + char *debugsec = xcoff->debugsec; + const char *debugfmt = bfd_xcoff_is_xcoff64 (abfd) ? "XCOFF64" : "XCOFF"; struct internal_syment symbol[1]; union internal_auxent main_aux; @@ -956,41 +1021,38 @@ read_xcoff_symtab (struct partial_symtab *pst) unsigned int max_symnum; int just_started = 1; int depth = 0; - int fcn_start_addr = 0; + CORE_ADDR fcn_start_addr = 0; struct coff_symbol fcn_stab_saved = { 0 }; /* fcn_cs_saved is global because process_xcoff_symbol needs it. */ - union internal_auxent fcn_aux_saved; - struct context_stack *new; + union internal_auxent fcn_aux_saved = main_aux; + struct context_stack *newobj; - char *filestring = " _start_ "; /* Name of the current file. */ + const char *filestring = pst->filename; /* Name of the current file. */ - char *last_csect_name; /* Last seen csect's name and value. */ - CORE_ADDR last_csect_val; - int last_csect_sec; + const char *last_csect_name; /* Last seen csect's name. */ this_symtab_psymtab = pst; + this_symtab_objfile = objfile; /* Get the appropriate COFF "constants" related to the file we're handling. */ local_symesz = coff_data (abfd)->local_symesz; - last_source_file = NULL; + set_last_source_file (NULL); last_csect_name = 0; - last_csect_val = 0; start_stabs (); - start_symtab (filestring, (char *) NULL, file_start_addr); + start_symtab (objfile, filestring, (char *) NULL, file_start_addr, + language_unknown); record_debugformat (debugfmt); symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum; max_symnum = symnum + ((struct symloc *) pst->read_symtab_private)->numsyms; first_object_file_end = 0; - raw_symbol = - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->symtbl - + symnum * local_symesz; + raw_symbol = xcoff->symtbl + symnum * local_symesz; while (symnum < max_symnum) { @@ -1023,7 +1085,8 @@ read_xcoff_symtab (struct partial_symtab *pst) { char *p; - p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1); + p = (char *) obstack_alloc (&objfile->objfile_obstack, + E_SYMNMLEN + 1); strncpy (p, cs->c_name, E_SYMNMLEN); p[E_SYMNMLEN] = '\0'; cs->c_name = p; @@ -1067,22 +1130,23 @@ read_xcoff_symtab (struct partial_symtab *pst) if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) { - if (last_source_file) + if (get_last_source_file ()) { - pst->symtab = end_symtab (cur_src_end_addr, objfile, - SECT_OFF_TEXT (objfile)); + pst->compunit_symtab = end_symtab (cur_src_end_addr, + SECT_OFF_TEXT (objfile)); end_stabs (); } start_stabs (); - start_symtab ("_globals_", (char *) NULL, (CORE_ADDR) 0); + start_symtab (objfile, "_globals_", (char *) NULL, (CORE_ADDR) 0, + language_unknown); record_debugformat (debugfmt); cur_src_end_addr = first_object_file_end; /* Done with all files, everything from here on is globals. */ } - if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT) - && cs->c_naux == 1) + if (cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT || + cs->c_sclass == C_WEAKEXT) { /* Dealing with a symbol with a csect entry. */ @@ -1092,9 +1156,41 @@ read_xcoff_symtab (struct partial_symtab *pst) #define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp)) #define CSECT_SCLAS(PP) (CSECT(PP).x_smclas) - /* Convert the auxent to something we can access. */ - bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass, - 0, cs->c_naux, &main_aux); + /* Convert the auxent to something we can access. + XCOFF can have more than one auxiliary entries. + + Actual functions will have two auxiliary entries, one to have the + function size and other to have the smtype/smclass (LD/PR). + + c_type value of main symbol table will be set only in case of + C_EXT/C_HIDEEXT/C_WEAKEXT storage class symbols. + Bit 10 of type is set if symbol is a function, ie the value is set + to 32(0x20). So we need to read the first function auxiliay entry + which contains the size. */ + if (cs->c_naux > 1 && ISFCN (cs->c_type)) + { + /* a function entry point. */ + + fcn_start_addr = cs->c_value; + + /* save the function header info, which will be used + when `.bf' is seen. */ + fcn_cs_saved = *cs; + + /* Convert the auxent to something we can access. */ + bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass, + 0, cs->c_naux, &fcn_aux_saved); + continue; + } + /* Read the csect auxiliary header, which is always the last by + onvention. */ + bfd_coff_swap_aux_in (abfd, + raw_auxptr + + ((coff_data (abfd)->local_symesz) + * (cs->c_naux - 1)), + cs->c_type, cs->c_sclass, + cs->c_naux - 1, cs->c_naux, + &main_aux); switch (CSECT_SMTYP (&main_aux)) { @@ -1127,13 +1223,13 @@ read_xcoff_symtab (struct partial_symtab *pst) { complete_symtab (filestring, file_start_addr); cur_src_end_addr = file_end_addr; - end_symtab (file_end_addr, objfile, - SECT_OFF_TEXT (objfile)); + end_symtab (file_end_addr, SECT_OFF_TEXT (objfile)); end_stabs (); start_stabs (); /* Give all csects for this source file the same name. */ - start_symtab (filestring, NULL, (CORE_ADDR) 0); + start_symtab (objfile, filestring, NULL, + (CORE_ADDR) 0, language_unknown); record_debugformat (debugfmt); } @@ -1151,14 +1247,8 @@ read_xcoff_symtab (struct partial_symtab *pst) SECT_OFF_TEXT (objfile)); file_end_addr = file_start_addr + CSECT_LEN (&main_aux); - if (cs->c_name && (cs->c_name[0] == '.' - || cs->c_name[0] == '@')) - { - last_csect_name = cs->c_name; - last_csect_val = cs->c_value; - last_csect_sec = secnum_to_section (cs->c_secnum, - objfile); - } + if (cs->c_name && (cs->c_name[0] == '.' || cs->c_name[0] == '@')) + last_csect_name = cs->c_name; } continue; @@ -1185,16 +1275,11 @@ read_xcoff_symtab (struct partial_symtab *pst) switch (CSECT_SCLAS (&main_aux)) { + /* We never really come to this part as this case has been + handled in ISFCN check above. + This and other cases of XTY_LD are kept just for + reference. */ case XMC_PR: - /* a function entry point. */ - function_entry_point: - - fcn_start_addr = cs->c_value; - - /* save the function header info, which will be used - when `.bf' is seen. */ - fcn_cs_saved = *cs; - fcn_aux_saved = main_aux; continue; case XMC_GL: @@ -1227,16 +1312,6 @@ read_xcoff_symtab (struct partial_symtab *pst) } } - /* If explicitly specified as a function, treat is as one. This check - evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur - after the above CSECT check. */ - if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF) - { - bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass, - 0, cs->c_naux, &main_aux); - goto function_entry_point; - } - switch (cs->c_sclass) { case C_FILE: @@ -1255,7 +1330,7 @@ read_xcoff_symtab (struct partial_symtab *pst) complete_symtab (filestring, file_start_addr); cur_src_end_addr = file_end_addr; - end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile)); + end_symtab (file_end_addr, SECT_OFF_TEXT (objfile)); end_stabs (); /* XCOFF, according to the AIX 3.2 documentation, puts the @@ -1274,7 +1349,8 @@ read_xcoff_symtab (struct partial_symtab *pst) filestring = cs->c_name; start_stabs (); - start_symtab (filestring, (char *) NULL, (CORE_ADDR) 0); + start_symtab (objfile, filestring, (char *) NULL, (CORE_ADDR) 0, + language_unknown); record_debugformat (debugfmt); last_csect_name = 0; @@ -1299,13 +1375,13 @@ read_xcoff_symtab (struct partial_symtab *pst) within_function = 1; - new = push_context (0, fcn_start_addr + off); + newobj = push_context (0, fcn_start_addr + off); - new->name = define_symbol + newobj->name = define_symbol (fcn_cs_saved.c_value + off, fcn_stab_saved.c_name, 0, 0, objfile); - if (new->name != NULL) - SYMBOL_SECTION (new->name) = SECT_OFF_TEXT (objfile); + if (newobj->name != NULL) + SYMBOL_SECTION (newobj->name) = SECT_OFF_TEXT (objfile); } else if (strcmp (cs->c_name, ".ef") == 0) { @@ -1317,28 +1393,27 @@ read_xcoff_symtab (struct partial_symtab *pst) /* { 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. */ ef_complaint (cs->c_symnum); within_function = 0; break; } - new = pop_context (); + struct context_stack cstk = pop_context (); /* Stack must be empty now. */ - if (context_stack_depth > 0 || new == NULL) + if (!outermost_context_p ()) { ef_complaint (cs->c_symnum); within_function = 0; break; } - finish_block (new->name, &local_symbols, new->old_blocks, - new->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, - SECT_OFF_TEXT (objfile))), - objfile); + SECT_OFF_TEXT (objfile)))); within_function = 0; } break; @@ -1369,8 +1444,7 @@ read_xcoff_symtab (struct partial_symtab *pst) case C_UNTAG: case C_ENTAG: { - complaint (&symfile_complaints, - _("Unrecognized storage class %d."), + complaint (_("Unrecognized storage class %d."), cs->c_sclass); } break; @@ -1404,35 +1478,35 @@ read_xcoff_symtab (struct partial_symtab *pst) if (strcmp (cs->c_name, ".bb") == 0) { depth++; - new = push_context (depth, + newobj = push_context (depth, (cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)))); } 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. */ eb_complaint (cs->c_symnum); break; } - new = pop_context (); - if (depth-- != new->depth) + struct context_stack cstk = pop_context (); + if (depth-- != cstk.depth) { eb_complaint (cs->c_symnum); break; } - if (local_symbols && context_stack_depth > 0) + if (*get_local_symbols () && !outermost_context_p ()) { /* Make a block for the local symbols within. */ - finish_block (new->name, &local_symbols, new->old_blocks, - new->start_addr, + finish_block (cstk.name, + cstk.old_blocks, NULL, + cstk.start_addr, (cs->c_value + ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile))), - objfile); + SECT_OFF_TEXT (objfile)))); } - local_symbols = new->locals; + *get_local_symbols () = cstk.locals; } break; @@ -1442,32 +1516,31 @@ read_xcoff_symtab (struct partial_symtab *pst) } } - if (last_source_file) + if (get_last_source_file ()) { - struct symtab *s; + struct compunit_symtab *cust; complete_symtab (filestring, file_start_addr); cur_src_end_addr = file_end_addr; - s = end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile)); + cust = end_symtab (file_end_addr, SECT_OFF_TEXT (objfile)); /* When reading symbols for the last C_FILE of the objfile, try - to make sure that we set pst->symtab to the symtab for the + to make sure that we set pst->compunit_symtab to the symtab for the file, not to the _globals_ symtab. I'm not sure whether this actually works right or when/if it comes up. */ - if (pst->symtab == NULL) - pst->symtab = s; + if (pst->compunit_symtab == NULL) + pst->compunit_symtab = cust; end_stabs (); } } #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \ - (SYMBOL2) = (struct symbol *) \ - obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \ + (SYMBOL2) = XOBNEW (&objfile->objfile_obstack, struct symbol); \ *(SYMBOL2) = *(SYMBOL1); #define SYMNAME_ALLOC(NAME, ALLOCED) \ - ((ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), \ - &objfile->objfile_obstack)) + ((ALLOCED) ? (NAME) : obstack_copy0 (&objfile->objfile_obstack, \ + (NAME), strlen (NAME))) /* process one xcoff symbol. */ @@ -1500,7 +1573,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile) if (name[0] == '.') ++name; - memset (sym, '\0', sizeof (struct symbol)); + initialize_objfile_symbol (sym); /* default assumptions */ SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off; @@ -1513,16 +1586,17 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile) will be patched with the type from its stab entry later on in patch_block_stabs (), unless the file was compiled without -g. */ - SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced)); + SYMBOL_SET_LINKAGE_NAME (sym, ((const char *) + SYMNAME_ALLOC (name, symname_alloced))); SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol; - SYMBOL_CLASS (sym) = LOC_BLOCK; + SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK; SYMBOL_DUP (sym, sym2); - if (cs->c_sclass == C_EXT) - add_symbol_to_list (sym2, &global_symbols); + if (cs->c_sclass == C_EXT || C_WEAKEXT) + add_symbol_to_list (sym2, get_global_symbols ()); else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT) - add_symbol_to_list (sym2, &file_symbols); + add_symbol_to_list (sym2, get_file_symbols ()); } else { @@ -1555,7 +1629,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile) break; default: - complaint (&symfile_complaints, _("Unexpected storage class: %d"), + complaint (_("Unexpected storage class: %d"), cs->c_sclass); /* FALLTHROUGH */ @@ -1585,7 +1659,11 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile) where we need to, which is not necessarily super-clean, but seems workable enough. */ - if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL) + if (*name == ':') + return NULL; + + pp = strchr (name, ':'); + if (pp == NULL) return NULL; ++pp; @@ -1616,9 +1694,8 @@ coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile) static char buffer[BUFSIZ]; if (aux_entry->x_file.x_n.x_zeroes == 0) - strcpy (buffer, ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->strtbl - + aux_entry->x_file.x_n.x_offset); + strcpy (buffer, (XCOFF_DATA (objfile)->strtbl + + aux_entry->x_file.x_n.x_offset)); else { strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN); @@ -1631,20 +1708,18 @@ coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile) static void read_symbol (struct internal_syment *symbol, int symno) { - int nsyms - = ((struct coff_symfile_info *) - this_symtab_psymtab->objfile->deprecated_sym_private)->symtbl_num_syms; - char *stbl = ((struct coff_symfile_info *) - this_symtab_psymtab->objfile->deprecated_sym_private)->symtbl; + struct coff_symfile_info *xcoff = XCOFF_DATA (this_symtab_objfile); + int nsyms = xcoff->symtbl_num_syms; + char *stbl = xcoff->symtbl; if (symno < 0 || symno >= nsyms) { - complaint (&symfile_complaints, _("Invalid symbol offset")); + complaint (_("Invalid symbol offset")); symbol->n_value = 0; symbol->n_scnum = -1; return; } - bfd_coff_swap_sym_in (this_symtab_psymtab->objfile->obfd, + bfd_coff_swap_sym_in (this_symtab_objfile->obfd, stbl + (symno * local_symesz), symbol); } @@ -1667,11 +1742,10 @@ read_symbol_nvalue (int symno) static int read_symbol_lineno (int symno) { - struct objfile *objfile = this_symtab_psymtab->objfile; + struct objfile *objfile = this_symtab_objfile; int xcoff64 = bfd_xcoff_is_xcoff64 (objfile->obfd); - struct coff_symfile_info *info = - (struct coff_symfile_info *)objfile->deprecated_sym_private; + struct coff_symfile_info *info = XCOFF_DATA (objfile); int nsyms = info->symtbl_num_syms; char *stbl = info->symtbl; char *strtbl = info->strtbl; @@ -1758,12 +1832,9 @@ find_linenos (struct bfd *abfd, struct bfd_section *asect, void *vpinfo) info->max_lineno_offset = maxoff; } -static void xcoff_psymtab_to_symtab_1 (struct partial_symtab *); - static void -xcoff_psymtab_to_symtab_1 (struct partial_symtab *pst) +xcoff_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst) { - struct cleanup *old_chain; int i; if (!pst) @@ -1792,65 +1863,53 @@ xcoff_psymtab_to_symtab_1 (struct partial_symtab *pst) wrap_here (""); /* Flush output */ gdb_flush (gdb_stdout); } - xcoff_psymtab_to_symtab_1 (pst->dependencies[i]); + xcoff_psymtab_to_symtab_1 (objfile, pst->dependencies[i]); } if (((struct symloc *) pst->read_symtab_private)->numsyms != 0) { /* Init stuff necessary for reading in symbols. */ stabsread_init (); - buildsym_init (); - old_chain = make_cleanup (really_free_pendings, 0); - read_xcoff_symtab (pst); - - do_cleanups (old_chain); + scoped_free_pendings free_pending; + read_xcoff_symtab (objfile, pst); } pst->readin = 1; } -static void xcoff_psymtab_to_symtab (struct partial_symtab *); - /* Read in all of the symbols for a given psymtab for real. - Be verbose about it if the user wants that. */ + Be verbose about it if the user wants that. SELF is not NULL. */ static void -xcoff_psymtab_to_symtab (struct partial_symtab *pst) +xcoff_read_symtab (struct partial_symtab *self, struct objfile *objfile) { - bfd *sym_bfd; - - if (!pst) - return; - - if (pst->readin) + if (self->readin) { fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n", - pst->filename); + self->filename); return; } - if (((struct symloc *) pst->read_symtab_private)->numsyms != 0 - || pst->number_of_dependencies) + if (((struct symloc *) self->read_symtab_private)->numsyms != 0 + || self->number_of_dependencies) { /* Print the message now, before reading the string table, to avoid disconcerting pauses. */ if (info_verbose) { - printf_filtered ("Reading in symbols for %s...", pst->filename); + printf_filtered ("Reading in symbols for %s...", self->filename); gdb_flush (gdb_stdout); } - sym_bfd = pst->objfile->obfd; - next_symbol_text_func = xcoff_next_symbol_text; - xcoff_psymtab_to_symtab_1 (pst); + xcoff_psymtab_to_symtab_1 (objfile, self); /* Match with global symbols. This only needs to be done once, after all of the symtabs and dependencies have been read in. */ - scan_file_globals (pst->objfile); + scan_file_globals (objfile); /* Finish up the debug error message. */ if (info_verbose) @@ -1862,7 +1921,6 @@ static void xcoff_new_init (struct objfile *objfile) { stabsread_new_init (); - buildsym_new_init (); } /* Do initialization in preparation for reading symbols from OBJFILE. @@ -1874,16 +1932,16 @@ xcoff_new_init (struct objfile *objfile) static void xcoff_symfile_init (struct objfile *objfile) { + struct coff_symfile_info *xcoff; + /* Allocate struct to keep track of the symfile. */ - objfile->deprecated_sym_private - = xmalloc (sizeof (struct coff_symfile_info)); + xcoff = XNEW (struct coff_symfile_info); + set_objfile_data (objfile, xcoff_objfile_data_key, xcoff); /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we find this causes a significant slowdown in gdb then we could set it in the debug symbol readers only when necessary. */ objfile->flags |= OBJF_REORDERED; - - init_entry_point_info (objfile); } /* Perform any local cleanups required when we are done with a particular @@ -1894,11 +1952,6 @@ xcoff_symfile_init (struct objfile *objfile) static void xcoff_symfile_finish (struct objfile *objfile) { - if (objfile->deprecated_sym_private != NULL) - { - xfree (objfile->deprecated_sym_private); - } - /* Start with a fresh include table for the next objfile. */ if (inclTable) { @@ -1916,9 +1969,9 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile) int val; unsigned char lengthbuf[4]; char *strtbl; + struct coff_symfile_info *xcoff = XCOFF_DATA (objfile); - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl - = NULL; + xcoff->strtbl = NULL; if (bfd_seek (abfd, offset, SEEK_SET) < 0) error (_("cannot seek to string table in %s: %s"), @@ -1937,8 +1990,7 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile) as long as we have its symbol table around. */ strtbl = (char *) obstack_alloc (&objfile->objfile_obstack, length); - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl - = strtbl; + xcoff->strtbl = strtbl; /* Copy length buffer, the first byte is usually zero and is used for stabs with a name length of zero. */ @@ -1963,10 +2015,6 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile) for the psymtab. */ static unsigned int first_fun_line_offset; -static struct partial_symtab *xcoff_start_psymtab - (struct objfile *, char *, int, - struct partial_symbol **, struct partial_symbol **); - /* Allocate and partially fill a partial symtab. It will be completely filled at the end of the symbol list. @@ -1975,21 +2023,22 @@ static struct partial_symtab *xcoff_start_psymtab (normal). */ static struct partial_symtab * -xcoff_start_psymtab (struct objfile *objfile, char *filename, int first_symnum, - struct partial_symbol **global_syms, - struct partial_symbol **static_syms) +xcoff_start_psymtab (struct objfile *objfile, + const char *filename, int first_symnum, + std::vector &global_psymbols, + std::vector &static_psymbols) { struct partial_symtab *result = - start_psymtab_common (objfile, objfile->section_offsets, + start_psymtab_common (objfile, filename, /* We fill in textlow later. */ 0, - global_syms, static_syms); + global_psymbols, static_psymbols); - result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, - sizeof (struct symloc)); + result->read_symtab_private = + XOBNEW (&objfile->objfile_obstack, struct symloc); ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum; - result->read_symtab = xcoff_psymtab_to_symtab; + result->read_symtab = xcoff_read_symtab; /* Deduce the source language from the filename for this psymtab. */ psymtab_language = deduce_language_from_filename (filename); @@ -1997,10 +2046,6 @@ xcoff_start_psymtab (struct objfile *objfile, char *filename, int first_symnum, return result; } -static struct partial_symtab *xcoff_end_psymtab - (struct partial_symtab *, char **, int, int, - struct partial_symtab **, int, int); - /* Close off the current usage of PST. Returns PST, or NULL if the partial symtab was empty and thrown away. @@ -2010,13 +2055,13 @@ static struct partial_symtab *xcoff_end_psymtab are the information for includes and dependencies. */ static struct partial_symtab * -xcoff_end_psymtab (struct partial_symtab *pst, char **include_list, - int num_includes, int capping_symbol_number, +xcoff_end_psymtab (struct objfile *objfile, struct partial_symtab *pst, + const char **include_list, int num_includes, + int capping_symbol_number, struct partial_symtab **dependency_list, int number_dependencies, int textlow_not_set) { int i; - struct objfile *objfile = pst->objfile; if (capping_symbol_number != -1) ((struct symloc *) pst->read_symtab_private)->numsyms = @@ -2025,17 +2070,15 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list, ((struct symloc *) pst->read_symtab_private)->lineno_off = first_fun_line_offset; first_fun_line_offset = 0; - pst->n_global_syms = objfile->global_psymbols.next - - (objfile->global_psymbols.list + pst->globals_offset); - pst->n_static_syms = objfile->static_psymbols.next - - (objfile->static_psymbols.list + pst->statics_offset); + + end_psymtab_common (objfile, pst); pst->number_of_dependencies = number_dependencies; if (number_dependencies) { - pst->dependencies = (struct partial_symtab **) - obstack_alloc (&objfile->objfile_obstack, - number_dependencies * sizeof (struct partial_symtab *)); + pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack, + struct partial_symtab *, + number_dependencies); memcpy (pst->dependencies, dependency_list, number_dependencies * sizeof (struct partial_symtab *)); } @@ -2047,19 +2090,14 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list, struct partial_symtab *subpst = allocate_psymtab (include_list[i], objfile); - subpst->section_offsets = pst->section_offsets; - subpst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, - sizeof (struct symloc)); + subpst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc); ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0; ((struct symloc *) subpst->read_symtab_private)->numsyms = 0; - subpst->textlow = 0; - subpst->texthigh = 0; /* We could save slight bits of space by only making one of these, shared by the entire set of include files. FIXME-someday. */ - subpst->dependencies = (struct partial_symtab **) - obstack_alloc (&objfile->objfile_obstack, - sizeof (struct partial_symtab *)); + subpst->dependencies = + XOBNEW (&objfile->objfile_obstack, struct partial_symtab *); subpst->dependencies[0] = pst; subpst->number_of_dependencies = 1; @@ -2069,12 +2107,10 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list, subpst->n_static_syms = 0; subpst->readin = 0; - subpst->symtab = 0; + subpst->compunit_symtab = NULL; subpst->read_symtab = pst->read_symtab; } - sort_pst_symbols (pst); - if (num_includes == 0 && number_dependencies == 0 && pst->n_global_syms == 0 @@ -2085,25 +2121,21 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list, /* Empty psymtabs happen as a result of header files which don't have any symbols in them. There can be a lot of them. */ - discard_psymtab (pst); + discard_psymtab (objfile, pst); /* Indicate that psymtab was thrown away. */ - pst = (struct partial_symtab *) NULL; + pst = NULL; } return pst; } -static void swap_sym (struct internal_syment *, - union internal_auxent *, char **, char **, - unsigned int *, struct objfile *); - /* Swap raw symbol at *RAW and put the name in *NAME, the symbol in *SYMBOL, the first auxent in *AUX. Advance *RAW and *SYMNUMP over the symbol and its auxents. */ static void swap_sym (struct internal_syment *symbol, union internal_auxent *aux, - char **name, char **raw, unsigned int *symnump, + const char **name, char **raw, unsigned int *symnump, struct objfile *objfile) { bfd_coff_swap_sym_in (objfile->obfd, *raw, symbol); @@ -2117,7 +2149,8 @@ swap_sym (struct internal_syment *symbol, union internal_auxent *aux, into the minimal symbols. */ char *p; - p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1); + p = (char *) obstack_alloc (&objfile->objfile_obstack, + E_SYMNMLEN + 1); strncpy (p, symbol->n_name, E_SYMNMLEN); p[E_SYMNMLEN] = '\0'; *name = p; @@ -2129,13 +2162,11 @@ swap_sym (struct internal_syment *symbol, union internal_auxent *aux, } else if (symbol->n_sclass & 0x80) { - *name = ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->debugsec + symbol->n_offset; + *name = XCOFF_DATA (objfile)->debugsec + symbol->n_offset; } else { - *name = ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->strtbl + symbol->n_offset; + *name = XCOFF_DATA (objfile)->strtbl + symbol->n_offset; } ++*symnump; *raw += coff_data (objfile->obfd)->local_symesz; @@ -2152,21 +2183,20 @@ swap_sym (struct internal_syment *symbol, union internal_auxent *aux, static void function_outside_compilation_unit_complaint (const char *arg1) { - complaint (&symfile_complaints, - _("function `%s' appears to be defined " + complaint (_("function `%s' appears to be defined " "outside of all compilation units"), arg1); } static void -scan_xcoff_symtab (struct objfile *objfile) +scan_xcoff_symtab (minimal_symbol_reader &reader, + struct objfile *objfile) { struct gdbarch *gdbarch = get_objfile_arch (objfile); CORE_ADDR toc_offset = 0; /* toc offset value in data section. */ - char *filestring = NULL; + const char *filestring = NULL; - char *namestring; - int past_first_source_file = 0; + const char *namestring; bfd *abfd; asection *bfd_sect; unsigned int nsyms; @@ -2175,7 +2205,7 @@ scan_xcoff_symtab (struct objfile *objfile) struct partial_symtab *pst; /* List of current psymtab's include files. */ - char **psymtab_include_list; + const char **psymtab_include_list; int includes_allocated; int includes_used; @@ -2188,7 +2218,7 @@ scan_xcoff_symtab (struct objfile *objfile) union internal_auxent main_aux[5]; unsigned int ssymnum; - char *last_csect_name = NULL; /* Last seen csect's name and value. */ + const char *last_csect_name = NULL; /* Last seen csect's name and value. */ CORE_ADDR last_csect_val = 0; int last_csect_sec = 0; int misc_func_recorded = 0; /* true if any misc. function. */ @@ -2198,8 +2228,8 @@ scan_xcoff_symtab (struct objfile *objfile) includes_allocated = 30; includes_used = 0; - psymtab_include_list = (char **) alloca (includes_allocated * - sizeof (char *)); + psymtab_include_list = (const char **) alloca (includes_allocated * + sizeof (const char *)); dependencies_allocated = 30; dependencies_used = 0; @@ -2207,15 +2237,13 @@ scan_xcoff_symtab (struct objfile *objfile) (struct partial_symtab **) alloca (dependencies_allocated * sizeof (struct partial_symtab *)); - last_source_file = NULL; + set_last_source_file (NULL); abfd = objfile->obfd; next_symbol_text_func = xcoff_next_symbol_text; - sraw_symbol = ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->symtbl; - nsyms = ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->symtbl_num_syms; + sraw_symbol = XCOFF_DATA (objfile)->symtbl; + nsyms = XCOFF_DATA (objfile)->symtbl_num_syms; ssymnum = 0; while (ssymnum < nsyms) { @@ -2230,6 +2258,7 @@ scan_xcoff_symtab (struct objfile *objfile) { case C_EXT: case C_HIDEXT: + case C_WEAKEXT: { /* The CSECT auxent--always the last auxent. */ union internal_auxent csect_aux; @@ -2271,10 +2300,10 @@ scan_xcoff_symtab (struct objfile *objfile) if (!misc_func_recorded) { - RECORD_MINIMAL_SYMBOL - (last_csect_name, last_csect_val, - mst_text, last_csect_sec, - objfile); + record_minimal_symbol + (reader, last_csect_name, last_csect_val, + mst_text, last_csect_sec, objfile); + misc_func_recorded = 1; } if (pst != NULL) @@ -2283,8 +2312,8 @@ scan_xcoff_symtab (struct objfile *objfile) each program csect, because their text sections need not be adjacent. */ xcoff_end_psymtab - (pst, psymtab_include_list, includes_used, - symnum_before, dependency_list, + (objfile, pst, psymtab_include_list, + includes_used, symnum_before, dependency_list, dependencies_used, textlow_not_set); includes_used = 0; dependencies_used = 0; @@ -2294,8 +2323,8 @@ scan_xcoff_symtab (struct objfile *objfile) (objfile, filestring, symnum_before, - objfile->global_psymbols.next, - objfile->static_psymbols.next); + objfile->global_psymbols, + objfile->static_psymbols); } } /* Activate the misc_func_recorded mechanism for @@ -2306,18 +2335,18 @@ scan_xcoff_symtab (struct objfile *objfile) { last_csect_name = namestring; last_csect_val = symbol.n_value; - last_csect_sec = - secnum_to_section (symbol.n_scnum, objfile); + last_csect_sec = symbol.n_scnum; } if (pst != NULL) { CORE_ADDR highval = symbol.n_value + csect_aux.x_csect.x_scnlen.l; - if (highval > pst->texthigh) - pst->texthigh = highval; - if (pst->textlow == 0 || symbol.n_value < pst->textlow) - pst->textlow = symbol.n_value; + if (highval > pst->raw_text_high ()) + pst->set_text_high (highval); + if (!pst->text_low_valid + || symbol.n_value < pst->raw_text_low ()) + pst->set_text_low (symbol.n_value); } misc_func_recorded = 0; break; @@ -2327,11 +2356,10 @@ scan_xcoff_symtab (struct objfile *objfile) /* Data variables are recorded in the minimal symbol table, except for section symbols. */ if (*namestring != '.') - prim_record_minimal_symbol_and_info - (namestring, symbol.n_value, + record_minimal_symbol + (reader, namestring, symbol.n_value, sclass == C_HIDEXT ? mst_file_data : mst_data, - secnum_to_section (symbol.n_scnum, objfile), - NULL, objfile); + symbol.n_scnum, objfile); break; case XMC_TC0: @@ -2365,11 +2393,12 @@ scan_xcoff_symtab (struct objfile *objfile) if (first_fun_line_offset == 0 && symbol.n_numaux > 1) first_fun_line_offset = main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr; - RECORD_MINIMAL_SYMBOL - (namestring, symbol.n_value, + + record_minimal_symbol + (reader, namestring, symbol.n_value, sclass == C_HIDEXT ? mst_file_text : mst_text, - secnum_to_section (symbol.n_scnum, objfile), - objfile); + symbol.n_scnum, objfile); + misc_func_recorded = 1; break; case XMC_GL: @@ -2380,11 +2409,10 @@ scan_xcoff_symtab (struct objfile *objfile) mst_solib_trampoline symbol. When we lookup mst symbols, we will choose mst_text over mst_solib_trampoline. */ - RECORD_MINIMAL_SYMBOL - (namestring, symbol.n_value, - mst_solib_trampoline, - secnum_to_section (symbol.n_scnum, objfile), - objfile); + record_minimal_symbol + (reader, namestring, symbol.n_value, + mst_solib_trampoline, symbol.n_scnum, objfile); + misc_func_recorded = 1; break; case XMC_DS: @@ -2403,11 +2431,10 @@ scan_xcoff_symtab (struct objfile *objfile) typically be XMC_RW; I suspect XMC_RO and XMC_BS might be possible too. */ if (*namestring != '.') - prim_record_minimal_symbol_and_info - (namestring, symbol.n_value, + record_minimal_symbol + (reader, namestring, symbol.n_value, sclass == C_HIDEXT ? mst_file_data : mst_data, - secnum_to_section (symbol.n_scnum, objfile), - NULL, objfile); + symbol.n_scnum, objfile); break; } break; @@ -2420,11 +2447,10 @@ scan_xcoff_symtab (struct objfile *objfile) /* Common variables are recorded in the minimal symbol table, except for section symbols. */ if (*namestring != '.') - prim_record_minimal_symbol_and_info - (namestring, symbol.n_value, + record_minimal_symbol + (reader, namestring, symbol.n_value, sclass == C_HIDEXT ? mst_file_bss : mst_bss, - secnum_to_section (symbol.n_scnum, objfile), - NULL, objfile); + symbol.n_scnum, objfile); break; } break; @@ -2450,16 +2476,17 @@ scan_xcoff_symtab (struct objfile *objfile) it as a function. This will take care of functions like strcmp() compiled by xlc. */ - RECORD_MINIMAL_SYMBOL - (last_csect_name, last_csect_val, - mst_text, last_csect_sec, objfile); + record_minimal_symbol (reader, last_csect_name, last_csect_val, + mst_text, last_csect_sec, objfile); + misc_func_recorded = 1; } if (pst) { - xcoff_end_psymtab (pst, psymtab_include_list, includes_used, - symnum_before, dependency_list, - dependencies_used, textlow_not_set); + xcoff_end_psymtab (objfile, pst, psymtab_include_list, + includes_used, symnum_before, + dependency_list, dependencies_used, + textlow_not_set); includes_used = 0; dependencies_used = 0; } @@ -2480,23 +2507,22 @@ scan_xcoff_symtab (struct objfile *objfile) pst = xcoff_start_psymtab (objfile, filestring, symnum_before, - objfile->global_psymbols.next, - objfile->static_psymbols.next); + objfile->global_psymbols, + objfile->static_psymbols); last_csect_name = NULL; } break; default: { - complaint (&symfile_complaints, - _("Storage class %d not recognized during scan"), + complaint (_("Storage class %d not recognized during scan"), sclass); } /* FALLTHROUGH */ + case C_FCN: /* C_FCN is .bf and .ef symbols. I think it is sufficient to handle only the C_FUN and C_EXT. */ - case C_FCN: case C_BSTAT: case C_ESTAT: @@ -2593,13 +2619,13 @@ scan_xcoff_symtab (struct objfile *objfile) psymtab_include_list[includes_used++] = namestring; if (includes_used >= includes_allocated) { - char **orig = psymtab_include_list; + const char **orig = psymtab_include_list; - psymtab_include_list = (char **) + psymtab_include_list = (const char **) alloca ((includes_allocated *= 2) * - sizeof (char *)); + sizeof (const char *)); memcpy (psymtab_include_list, orig, - includes_used * sizeof (char *)); + includes_used * sizeof (const char *)); } continue; } @@ -2614,12 +2640,12 @@ scan_xcoff_symtab (struct objfile *objfile) case C_DECL: case C_STSYM: { - char *p; + const char *p; swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol, &ssymnum, objfile); - p = (char *) strchr (namestring, ':'); + p = strchr (namestring, ':'); if (!p) continue; /* Not a debugging symbol. */ @@ -2633,29 +2659,26 @@ scan_xcoff_symtab (struct objfile *objfile) switch (p[1]) { case 'S': - symbol.n_value += ANOFFSET (objfile->section_offsets, - SECT_OFF_DATA (objfile)); - if (gdbarch_static_transform_name_p (gdbarch)) namestring = gdbarch_static_transform_name (gdbarch, namestring); add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_STATIC, + SECT_OFF_DATA (objfile), &objfile->static_psymbols, - 0, symbol.n_value, + symbol.n_value, psymtab_language, objfile); continue; case 'G': - symbol.n_value += ANOFFSET (objfile->section_offsets, - SECT_OFF_DATA (objfile)); /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_STATIC, + SECT_OFF_DATA (objfile), &objfile->global_psymbols, - 0, symbol.n_value, + symbol.n_value, psymtab_language, objfile); continue; @@ -2671,18 +2694,16 @@ scan_xcoff_symtab (struct objfile *objfile) && namestring[0] != ' ')) { add_psymbol_to_list (namestring, p - namestring, 1, - STRUCT_DOMAIN, LOC_TYPEDEF, + STRUCT_DOMAIN, LOC_TYPEDEF, -1, &objfile->static_psymbols, - symbol.n_value, 0, - psymtab_language, objfile); + 0, psymtab_language, objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ add_psymbol_to_list (namestring, p - namestring, 1, - VAR_DOMAIN, LOC_TYPEDEF, + VAR_DOMAIN, LOC_TYPEDEF, -1, &objfile->static_psymbols, - symbol.n_value, 0, - psymtab_language, objfile); + 0, psymtab_language, objfile); p += 1; } } @@ -2692,10 +2713,9 @@ scan_xcoff_symtab (struct objfile *objfile) if (p != namestring) /* a name is there, not just :T... */ { add_psymbol_to_list (namestring, p - namestring, 1, - VAR_DOMAIN, LOC_TYPEDEF, + VAR_DOMAIN, LOC_TYPEDEF, -1, &objfile->static_psymbols, - symbol.n_value, 0, - psymtab_language, objfile); + 0, psymtab_language, objfile); } check_enum: /* If this is an enumerated type, we need to @@ -2741,7 +2761,7 @@ scan_xcoff_symtab (struct objfile *objfile) Accept either. */ while (*p && *p != ';' && *p != ',') { - char *q; + const char *q; /* Check for and handle cretinous dbx symbol name continuation! */ @@ -2755,8 +2775,8 @@ scan_xcoff_symtab (struct objfile *objfile) /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ add_psymbol_to_list (p, q - p, 1, - VAR_DOMAIN, LOC_CONST, - &objfile->static_psymbols, 0, + VAR_DOMAIN, LOC_CONST, -1, + &objfile->static_psymbols, 0, psymtab_language, objfile); /* Point past the name. */ p = q; @@ -2773,8 +2793,8 @@ scan_xcoff_symtab (struct objfile *objfile) case 'c': /* Constant, e.g. from "const" in Pascal. */ add_psymbol_to_list (namestring, p - namestring, 1, - VAR_DOMAIN, LOC_CONST, - &objfile->static_psymbols, symbol.n_value, + VAR_DOMAIN, LOC_CONST, -1, + &objfile->static_psymbols, 0, psymtab_language, objfile); continue; @@ -2782,19 +2802,18 @@ scan_xcoff_symtab (struct objfile *objfile) if (! pst) { int name_len = p - namestring; - char *name = xmalloc (name_len + 1); + char *name = (char *) xmalloc (name_len + 1); memcpy (name, namestring, name_len); name[name_len] = '\0'; function_outside_compilation_unit_complaint (name); xfree (name); } - symbol.n_value += ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile)); add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_BLOCK, + SECT_OFF_TEXT (objfile), &objfile->static_psymbols, - 0, symbol.n_value, + symbol.n_value, psymtab_language, objfile); continue; @@ -2805,7 +2824,7 @@ scan_xcoff_symtab (struct objfile *objfile) if (! pst) { int name_len = p - namestring; - char *name = xmalloc (name_len + 1); + char *name = (char *) xmalloc (name_len + 1); memcpy (name, namestring, name_len); name[name_len] = '\0'; @@ -2817,15 +2836,14 @@ scan_xcoff_symtab (struct objfile *objfile) loader-generated definitions. Keeping the global symbols leads to "in psymbols but not in symbols" errors. */ - if (strncmp (namestring, "@FIX", 4) == 0) + if (startswith (namestring, "@FIX")) continue; - symbol.n_value += ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile)); add_psymbol_to_list (namestring, p - namestring, 1, VAR_DOMAIN, LOC_BLOCK, + SECT_OFF_TEXT (objfile), &objfile->global_psymbols, - 0, symbol.n_value, + symbol.n_value, psymtab_language, objfile); continue; @@ -2868,8 +2886,7 @@ scan_xcoff_symtab (struct objfile *objfile) the end of every string looking for a backslash. */ - complaint (&symfile_complaints, - _("unknown symbol descriptor `%c'"), p[1]); + complaint (_("unknown symbol descriptor `%c'"), p[1]); /* Ignore it; perhaps it is an extension that we don't know about. */ @@ -2881,7 +2898,7 @@ scan_xcoff_symtab (struct objfile *objfile) if (pst) { - xcoff_end_psymtab (pst, psymtab_include_list, includes_used, + xcoff_end_psymtab (objfile, pst, psymtab_include_list, includes_used, ssymnum, dependency_list, dependencies_used, textlow_not_set); } @@ -2891,8 +2908,7 @@ scan_xcoff_symtab (struct objfile *objfile) Another place to obtain this information would be file auxiliary header. */ - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->toc_offset - = toc_offset; + XCOFF_DATA (objfile)->toc_offset = toc_offset; } /* Return the toc offset value for a given objfile. */ @@ -2901,8 +2917,7 @@ CORE_ADDR xcoff_get_toc_offset (struct objfile *objfile) { if (objfile) - return ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->toc_offset; + return XCOFF_DATA (objfile)->toc_offset; return 0; } @@ -2916,21 +2931,20 @@ xcoff_get_toc_offset (struct objfile *objfile) loaded). */ static void -xcoff_initial_scan (struct objfile *objfile, int symfile_flags) +xcoff_initial_scan (struct objfile *objfile, symfile_add_flags symfile_flags) { bfd *abfd; int val; - struct cleanup *back_to; int num_symbols; /* # of symbols */ file_ptr symtab_offset; /* symbol table and */ file_ptr stringtab_offset; /* string table file offsets */ struct coff_symfile_info *info; - char *name; + const char *name; unsigned int size; - info = (struct coff_symfile_info *) objfile->deprecated_sym_private; + info = XCOFF_DATA (objfile); symfile_bfd = abfd = objfile->obfd; - name = objfile->name; + name = objfile_name (objfile); num_symbols = bfd_get_symcount (abfd); /* # of symbols */ symtab_offset = obj_sym_filepos (abfd); /* symbol table file offset */ @@ -2946,33 +2960,33 @@ xcoff_initial_scan (struct objfile *objfile, int symfile_flags) /* Read the string table. */ init_stringtab (abfd, stringtab_offset, objfile); - /* Read the .debug section, if present. */ - { - struct bfd_section *secp; - bfd_size_type length; - char *debugsec = NULL; + /* Read the .debug section, if present and if we're not ignoring + it. */ + if (!(objfile->flags & OBJF_READNEVER)) + { + struct bfd_section *secp; + bfd_size_type length; + bfd_byte *debugsec = NULL; - secp = bfd_get_section_by_name (abfd, ".debug"); - if (secp) - { - length = bfd_section_size (abfd, secp); - if (length) - { - debugsec = - (char *) obstack_alloc (&objfile->objfile_obstack, length); + secp = bfd_get_section_by_name (abfd, ".debug"); + if (secp) + { + length = bfd_section_size (abfd, secp); + if (length) + { + debugsec + = (bfd_byte *) obstack_alloc (&objfile->objfile_obstack, + length); - if (!bfd_get_section_contents (abfd, secp, debugsec, - (file_ptr) 0, length)) - { - error (_("Error reading .debug section of `%s': %s"), - name, bfd_errmsg (bfd_get_error ())); - } - } - } - ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->debugsec - = debugsec; - } + if (!bfd_get_full_section_contents (abfd, secp, &debugsec)) + { + error (_("Error reading .debug section of `%s': %s"), + name, bfd_errmsg (bfd_get_error ())); + } + } + } + info->debugsec = (char *) debugsec; + } } /* Read the symbols. We keep them in core because we will want to @@ -2982,87 +2996,79 @@ xcoff_initial_scan (struct objfile *objfile, int symfile_flags) error (_("Error reading symbols from %s: %s"), name, bfd_errmsg (bfd_get_error ())); size = coff_data (abfd)->local_symesz * num_symbols; - ((struct coff_symfile_info *) objfile->deprecated_sym_private)->symtbl = - obstack_alloc (&objfile->objfile_obstack, size); - ((struct coff_symfile_info *) - objfile->deprecated_sym_private)->symtbl_num_syms - = num_symbols; - - val = bfd_bread (((struct coff_symfile_info *) - objfile->deprecated_sym_private)->symtbl, - size, abfd); + info->symtbl = (char *) obstack_alloc (&objfile->objfile_obstack, size); + info->symtbl_num_syms = num_symbols; + + val = bfd_bread (info->symtbl, size, abfd); if (val != size) perror_with_name (_("reading symbol table")); /* If we are reinitializing, or if we have never loaded syms yet, init. */ - if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0) + if (objfile->global_psymbols.capacity () == 0 + && objfile->static_psymbols.capacity () == 0) /* I'm not sure how how good num_symbols is; the rule of thumb in init_psymbol_list was developed for a.out. On the one hand, num_symbols includes auxents. On the other hand, it doesn't include N_SLINE. */ init_psymbol_list (objfile, num_symbols); - free_pending_blocks (); - back_to = make_cleanup (really_free_pendings, 0); - - init_minimal_symbol_collection (); - make_cleanup_discard_minimal_symbols (); + scoped_free_pendings free_pending; + minimal_symbol_reader reader (objfile); /* Now that the symbol table data of the executable file are all in core, process them and define symbols accordingly. */ - scan_xcoff_symtab (objfile); + scan_xcoff_symtab (reader, objfile); /* Install any minimal symbols that have been collected as the current minimal symbols for this objfile. */ - install_minimal_symbols (objfile); + reader.install (); - do_cleanups (back_to); + /* DWARF2 sections. */ + + if (dwarf2_has_info (objfile, &dwarf2_xcoff_names)) + dwarf2_build_psymtabs (objfile); + + dwarf2_build_frame_info (objfile); } static void xcoff_symfile_offsets (struct objfile *objfile, - struct section_addr_info *addrs) + const section_addr_info &addrs) { - asection *sect = NULL; - int i; + const char *first_section_name; - objfile->num_sections = bfd_count_sections (objfile->obfd); - objfile->section_offsets = (struct section_offsets *) - obstack_alloc (&objfile->objfile_obstack, - SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); + default_symfile_offsets (objfile, addrs); - /* Initialize the section indexes for future use. */ - sect = bfd_get_section_by_name (objfile->obfd, ".text"); - if (sect) - objfile->sect_index_text = sect->index; + /* Oneof the weird side-effects of default_symfile_offsets is that + it sometimes sets some section indices to zero for sections that, + in fact do not exist. See the body of default_symfile_offsets + for more info on when that happens. Undo that, as this then allows + us to test whether the associated section exists or not, and then + access it quickly (without searching it again). */ - sect = bfd_get_section_by_name (objfile->obfd, ".data"); - if (sect) - objfile->sect_index_data = sect->index; + if (objfile->num_sections == 0) + return; /* Is that even possible? Better safe than sorry. */ - sect = bfd_get_section_by_name (objfile->obfd, ".bss"); - if (sect) - objfile->sect_index_bss = sect->index; + first_section_name + = bfd_section_name (objfile->obfd, objfile->sections[0].the_bfd_section); - sect = bfd_get_section_by_name (objfile->obfd, ".rodata"); - if (sect) - objfile->sect_index_rodata = sect->index; + if (objfile->sect_index_text == 0 + && strcmp (first_section_name, ".text") != 0) + objfile->sect_index_text = -1; - for (i = 0; i < objfile->num_sections; ++i) - { - /* syms_from_objfile kindly subtracts from addr the - bfd_section_vma of the .text section. This strikes me as - wrong--whether the offset to be applied to symbol reading is - relative to the start address of the section depends on the - symbol format. In any event, this whole "addr" concept is - pretty broken (it doesn't handle any section but .text - sensibly), so just ignore the addr parameter and use 0. - rs6000-nat.c will set the correct section offsets via - objfile_relocate. */ - (objfile->section_offsets)->offsets[i] = 0; - } + if (objfile->sect_index_data == 0 + && strcmp (first_section_name, ".data") != 0) + objfile->sect_index_data = -1; + + if (objfile->sect_index_bss == 0 + && strcmp (first_section_name, ".bss") != 0) + objfile->sect_index_bss = -1; + + if (objfile->sect_index_rodata == 0 + && strcmp (first_section_name, ".rodata") != 0) + objfile->sect_index_rodata = -1; } /* Register our ability to parse symbols for xcoff BFD files. */ @@ -3079,24 +3085,93 @@ static const struct sym_fns xcoff_sym_fns = xcoffread.c reads all the symbols and does in fact randomly access them (in C_BSTAT and line number processing). */ - bfd_target_xcoff_flavour, - xcoff_new_init, /* init anything gbl to entire symtab */ xcoff_symfile_init, /* read initial info, setup for sym_read() */ xcoff_initial_scan, /* read a symbol file into symtab */ + NULL, /* sym_read_psymbols */ xcoff_symfile_finish, /* finished with file, cleanup */ xcoff_symfile_offsets, /* xlate offsets ext->int form */ default_symfile_segments, /* Get segment information from a file. */ aix_process_linenos, default_symfile_relocate, /* Relocate a debug section. */ + NULL, /* sym_probe_fns */ &psym_functions }; -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_xcoffread; +/* Same as xcoff_get_n_import_files, but for core files. */ + +static int +xcoff_get_core_n_import_files (bfd *abfd) +{ + asection *sect = bfd_get_section_by_name (abfd, ".ldinfo"); + gdb_byte buf[4]; + file_ptr offset = 0; + int n_entries = 0; + + if (sect == NULL) + return -1; /* Not a core file. */ + + for (offset = 0; offset < bfd_get_section_size (sect);) + { + int next; + + n_entries++; + + if (!bfd_get_section_contents (abfd, sect, buf, offset, 4)) + return -1; + next = bfd_get_32 (abfd, buf); + if (next == 0) + break; /* This is the last entry. */ + offset += next; + } + + /* Return the number of entries, excluding the first one, which is + the path to the executable that produced this core file. */ + return n_entries - 1; +} + +/* Return the number of import files (shared libraries) that the given + BFD depends on. Return -1 if this number could not be computed. */ + +int +xcoff_get_n_import_files (bfd *abfd) +{ + asection *sect = bfd_get_section_by_name (abfd, ".loader"); + gdb_byte buf[4]; + int l_nimpid; + + /* If the ".loader" section does not exist, the objfile is probably + not an executable. Might be a core file... */ + if (sect == NULL) + return xcoff_get_core_n_import_files (abfd); + + /* The number of entries in the Import Files Table is stored in + field l_nimpid. This field is always at offset 16, and is + always 4 bytes long. Read those 4 bytes. */ + + if (!bfd_get_section_contents (abfd, sect, buf, 16, 4)) + return -1; + l_nimpid = bfd_get_32 (abfd, buf); + + /* By convention, the first entry is the default LIBPATH value + to be used by the system loader, so it does not count towards + the number of import files. */ + return l_nimpid - 1; +} + +/* Free the per-objfile xcoff data. */ + +static void +xcoff_free_info (struct objfile *objfile, void *arg) +{ + xfree (arg); +} void _initialize_xcoffread (void) { - add_symtab_fns (&xcoff_sym_fns); + add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns); + + xcoff_objfile_data_key = register_objfile_data_with_cleanup (NULL, + xcoff_free_info); }