Replace psymbol_allocation_list with std::vector

psymbol_allocation_list is basically a vector implementation.  We can
replace it with an std::vector, now that objfile has been C++-ified.

I sent this to the buildbot, there are a few suspicious failures, but
I don't think they are related to this patch.  For example on powerpc:

new FAIL: gdb.base/catch-syscall.exp: execve: syscall execve has returned
new FAIL: gdb.base/catch-syscall.exp: execve: continue to main
new FAIL: gdb.base/catch-syscall.exp: execve: continue until exit

I get the same failures when testing manually on gcc112, without this
patch.

gdb/ChangeLog:

	* objfiles.h: Don't include symfile.h.
	(struct partial_symbol): Remove forward-declaration.
	(struct objfile) <global_psymbols, static_psymbols>: Change type
	to std::vector<partial_symbol *>.
	* objfiles.c (objfile::objfile): Don't memset those fields.
	(objfile::~objfile): Don't free those fields.
	* psympriv.h (struct psymbol_allocation_list): Remove
	forward-declaration.
	(add_psymbol_to_list): Change psymbol_allocation_list parameter
	to std::vector.
	(start_psymtab_common): Change parameters to std::vector.
	* psymtab.c: Include algorithm.
	(require_partial_symbols): Call shrink_to_fit.
	(find_pc_sect_psymbol): Adjust to vector change.
	(match_partial_symbol): Likewise.
	(lookup_partial_symbol): Likewise.
	(psym_relocate): Likewise.
	(dump_psymtab): Likewise.
	(recursively_search_psymtabs): Likewise.
	(compare_psymbols): Remove.
	(sort_pst_symbols): Adjust to vector change.
	(start_psymtab_common): Likewise.
	(end_psymtab_common): Likewise.
	(psymbol_bcache_full): De-constify return value.
	(add_psymbol_to_bcache): Likewise.
	(extend_psymbol_list): Remove.
	(append_psymbol_to_list): Adjust to vector change.
	(add_psymbol_to_list): Likewise.
	(init_psymbol_list): Likewise.
	(maintenance_info_psymtabs): Likewise.
	(maintenance_check_psymtabs): Likewise.
	* symfile.h (struct psymbol_allocation_list): Remove.
	* symfile.c (reread_symbols): Adjust to vector change.
	* dbxread.c (start_psymtab): Change type of parameters.
	(dbx_symfile_read): Adjust to vector change.
	(read_dbx_symtab): Likewise.
	(start_psymtab): Change type of parameters.
	* dwarf2read.c (dwarf2_build_psymtabs): Adjust to vector change.
	(create_partial_symtab): Likewise.
	(add_partial_symbol): Likewise.
	(write_one_signatured_type): Likewise.
	(recursively_write_psymbols): Likewise.
	* mdebugread.c (parse_partial_symbols): Likewise.
	* xcoffread.c (xcoff_start_psymtab): Change type of parameters.
	(scan_xcoff_symtab): Adjust to vector change.
	(xcoff_initial_scan): Likewise.

1 files changed, 73 insertions, 134 deletions

diff --git a/gdb/psymtab.c b/gdb/psymtab.c
index f55c98c..f848990 100644
--- a/gdb/psymtab.c
+++ b/gdb/psymtab.c
@@ -35,6 +35,7 @@
 #include "language.h"
 #include "cp-support.h"
 #include "gdbcmd.h"
+#include <algorithm>
 
 struct psymbol_bcache
 {
@@ -85,6 +86,12 @@ require_partial_symbols (struct objfile *objfile, int verbose)
 	      gdb_flush (gdb_stdout);
 	    }
 	  (*objfile->sf->sym_read_psymbols) (objfile);
+
+	  /* Partial symbols list are not expected to changed after this
+	     point.  */
+	  objfile->global_psymbols.shrink_to_fit ();
+	  objfile->static_psymbols.shrink_to_fit ();
+
 	  if (verbose)
 	    {
 	      if (!objfile_has_symbols (objfile))
@@ -402,7 +409,7 @@ find_pc_sect_psymbol (struct objfile *objfile,
 		      struct partial_symtab *psymtab, CORE_ADDR pc,
 		      struct obj_section *section)
 {
-  struct partial_symbol *best = NULL, *p, **pp;
+  struct partial_symbol *best = NULL;
   CORE_ADDR best_pc;
 
   gdb_assert (psymtab != NULL);
@@ -413,12 +420,10 @@ find_pc_sect_psymbol (struct objfile *objfile,
   /* Search the global symbols as well as the static symbols, so that
      find_pc_partial_function doesn't use a minimal symbol and thus
      cache a bad endaddr.  */
-  for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
-       (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
-	< psymtab->n_global_syms);
-       pp++)
+  for (int i = 0; i < psymtab->n_global_syms; i++)
     {
-      p = *pp;
+      partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
+
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
 	  && PSYMBOL_CLASS (p) == LOC_BLOCK
 	  && pc >= SYMBOL_VALUE_ADDRESS (p)
@@ -438,12 +443,10 @@ find_pc_sect_psymbol (struct objfile *objfile,
 	}
     }
 
-  for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
-       (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
-	< psymtab->n_static_syms);
-       pp++)
+  for (int i = 0; i < psymtab->n_static_syms; i++)
     {
-      p = *pp;
+      partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
+
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
 	  && PSYMBOL_CLASS (p) == LOC_BLOCK
 	  && pc >= SYMBOL_VALUE_ADDRESS (p)
@@ -565,8 +568,8 @@ match_partial_symbol (struct objfile *objfile,
   if (length == 0)
       return NULL;
   start = (global ?
-	   objfile->global_psymbols.list + pst->globals_offset :
-	   objfile->static_psymbols.list + pst->statics_offset);
+	   &objfile->global_psymbols[pst->globals_offset] :
+	   &objfile->static_psymbols[pst->statics_offset]);
 
   if (global && ordered_compare)  /* Can use a binary search.  */
     {
@@ -667,8 +670,8 @@ lookup_partial_symbol (struct objfile *objfile,
 
   gdb::unique_xmalloc_ptr<char> search_name = psymtab_search_name (name);
   start = (global ?
-	   objfile->global_psymbols.list + pst->globals_offset :
-	   objfile->static_psymbols.list + pst->statics_offset);
+	   &objfile->global_psymbols[pst->globals_offset] :
+	   &objfile->static_psymbols[pst->statics_offset]);
 
   if (global)			/* This means we can use a binary search.  */
     {
@@ -785,23 +788,17 @@ psym_relocate (struct objfile *objfile,
       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
     }
 
-  for (psym = objfile->global_psymbols.list;
-       psym < objfile->global_psymbols.next;
-       psym++)
+  for (partial_symbol *psym : objfile->global_psymbols)
     {
-      fixup_psymbol_section (*psym, objfile);
-      if (SYMBOL_SECTION (*psym) >= 0)
-	SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
-						  SYMBOL_SECTION (*psym));
+      fixup_psymbol_section (psym, objfile);
+      if (SYMBOL_SECTION (psym) >= 0)
+	SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
     }
-  for (psym = objfile->static_psymbols.list;
-       psym < objfile->static_psymbols.next;
-       psym++)
+  for (partial_symbol *psym : objfile->static_psymbols)
     {
-      fixup_psymbol_section (*psym, objfile);
-      if (SYMBOL_SECTION (*psym) >= 0)
-	SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
-						  SYMBOL_SECTION (*psym));
+      fixup_psymbol_section (psym, objfile);
+      if (SYMBOL_SECTION (psym) >= 0)
+	SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
     }
 }
 
@@ -1013,15 +1010,13 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
   if (psymtab->n_global_syms > 0)
     {
       print_partial_symbols (gdbarch,
-			     objfile->global_psymbols.list
-			     + psymtab->globals_offset,
+			     &objfile->global_psymbols[psymtab->globals_offset],
 			     psymtab->n_global_syms, "Global", outfile);
     }
   if (psymtab->n_static_syms > 0)
     {
       print_partial_symbols (gdbarch,
-			     objfile->static_psymbols.list
-			     + psymtab->statics_offset,
+			     &objfile->static_psymbols[psymtab->statics_offset],
 			     psymtab->n_static_syms, "Static", outfile);
     }
   fprintf_filtered (outfile, "\n");
@@ -1285,8 +1280,6 @@ recursively_search_psymtabs
   (struct partial_symtab *ps, struct objfile *objfile, enum search_domain kind,
    gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
 {
-  struct partial_symbol **psym;
-  struct partial_symbol **bound, **gbound, **sbound;
   int keep_going = 1;
   enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
   int i;
@@ -1313,22 +1306,22 @@ recursively_search_psymtabs
 	}
     }
 
-  gbound = (objfile->global_psymbols.list
-	    + ps->globals_offset + ps->n_global_syms);
-  sbound = (objfile->static_psymbols.list
-	    + ps->statics_offset + ps->n_static_syms);
-  bound = gbound;
+  partial_symbol **gbound
+    = &objfile->global_psymbols[ps->globals_offset + ps->n_global_syms];
+  partial_symbol **sbound
+    = &objfile->static_psymbols[ps->statics_offset + ps->n_static_syms];
+  partial_symbol **bound = gbound;
 
   /* Go through all of the symbols stored in a partial
      symtab in one loop.  */
-  psym = objfile->global_psymbols.list + ps->globals_offset;
+  partial_symbol **psym = &objfile->global_psymbols[ps->globals_offset];
   while (keep_going)
     {
       if (psym >= bound)
 	{
 	  if (bound == gbound && ps->n_static_syms != 0)
 	    {
-	      psym = objfile->static_psymbols.list + ps->statics_offset;
+	      psym = &objfile->static_psymbols[ps->statics_offset];
 	      bound = sbound;
 	    }
 	  else
@@ -1453,27 +1446,22 @@ const struct quick_symbol_functions psym_functions =
 
 
 
-/* This compares two partial symbols by names, using strcmp_iw_ordered
-   for the comparison.  */
-
-static int
-compare_psymbols (const void *s1p, const void *s2p)
-{
-  struct partial_symbol *const *s1 = (struct partial_symbol * const*) s1p;
-  struct partial_symbol *const *s2 = (struct partial_symbol * const*) s2p;
-
-  return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
-			    SYMBOL_SEARCH_NAME (*s2));
-}
-
 static void
 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
 {
   /* Sort the global list; don't sort the static list.  */
+  auto begin = objfile->global_psymbols.begin ();
+  std::advance (begin, pst->globals_offset);
+
+  /* The psymbols for this partial_symtab are currently at the end of the
+     vector.  */
+  auto end = objfile->global_psymbols.end ();
 
-  qsort (objfile->global_psymbols.list + pst->globals_offset,
-	 pst->n_global_syms, sizeof (struct partial_symbol *),
-	 compare_psymbols);
+  std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
+    {
+      return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1),
+				SYMBOL_SEARCH_NAME (s2)) < 0;
+    });
 }
 
 /* Allocate and partially fill a partial symtab.  It will be
@@ -1484,16 +1472,17 @@ sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
 struct partial_symtab *
 start_psymtab_common (struct objfile *objfile,
 		      const char *filename,
-		      CORE_ADDR textlow, struct partial_symbol **global_syms,
-		      struct partial_symbol **static_syms)
+		      CORE_ADDR textlow,
+		      std::vector<partial_symbol *> &global_psymbols,
+		      std::vector<partial_symbol *> &static_psymbols)
 {
   struct partial_symtab *psymtab;
 
   psymtab = allocate_psymtab (filename, objfile);
   psymtab->textlow = textlow;
   psymtab->texthigh = psymtab->textlow;		/* default */
-  psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
-  psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
+  psymtab->globals_offset = global_psymbols.size ();
+  psymtab->statics_offset = static_psymbols.size ();
   return psymtab;
 }
 
@@ -1502,12 +1491,8 @@ start_psymtab_common (struct objfile *objfile,
 void
 end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
 {
-  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);
+  pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
+  pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
 
   sort_pst_symbols (objfile, pst);
 }
@@ -1589,12 +1574,12 @@ psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
    1 in case of new entry or 0 if returning an old entry.  */
 
-static const struct partial_symbol *
+static struct partial_symbol *
 psymbol_bcache_full (struct partial_symbol *sym,
                      struct psymbol_bcache *bcache,
                      int *added)
 {
-  return ((const struct partial_symbol *)
+  return ((struct partial_symbol *)
 	  bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
 		       added));
 }
@@ -1605,7 +1590,7 @@ psymbol_bcache_full (struct partial_symbol *sym,
    structure.  In other words, having two symbols with the same name but
    different domain (or address) is possible and correct.  */
 
-static const struct partial_symbol *
+static struct partial_symbol *
 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
 		       domain_enum domain,
 		       enum address_class theclass,
@@ -1632,44 +1617,14 @@ add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
   return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
 }
 
-/* Increase the space allocated for LISTP, which is probably
-   global_psymbols or static_psymbols.  This space will eventually
-   be freed in free_objfile().  */
-
-static void
-extend_psymbol_list (struct psymbol_allocation_list *listp,
-		     struct objfile *objfile)
-{
-  int new_size;
-
-  if (listp->size == 0)
-    {
-      new_size = 255;
-      listp->list = XNEWVEC (struct partial_symbol *, new_size);
-    }
-  else
-    {
-      new_size = listp->size * 2;
-      listp->list = (struct partial_symbol **)
-	xrealloc ((char *) listp->list,
-		  new_size * sizeof (struct partial_symbol *));
-    }
-  /* Next assumes we only went one over.  Should be good if
-     program works correctly.  */
-  listp->next = listp->list + listp->size;
-  listp->size = new_size;
-}
-
 /* Helper function, adds partial symbol to the given partial symbol list.  */
 
 static void
-append_psymbol_to_list (struct psymbol_allocation_list *list,
-			const struct partial_symbol *psym,
+append_psymbol_to_list (std::vector<partial_symbol *> *list,
+			struct partial_symbol *psym,
 			struct objfile *objfile)
 {
-  if (list->next >= list->list + list->size)
-    extend_psymbol_list (list, objfile);
-  *list->next++ = (struct partial_symbol *) psym;
+  list->push_back (psym);
   OBJSTAT (objfile, n_psyms++);
 }
 
@@ -1683,11 +1638,11 @@ void
 add_psymbol_to_list (const char *name, int namelength, int copy_name,
 		     domain_enum domain,
 		     enum address_class theclass,
-		     struct psymbol_allocation_list *list,
+		     std::vector<partial_symbol *> *list,
 		     CORE_ADDR coreaddr,
 		     enum language language, struct objfile *objfile)
 {
-  const struct partial_symbol *psym;
+  struct partial_symbol *psym;
 
   int added;
 
@@ -1710,31 +1665,14 @@ void
 init_psymbol_list (struct objfile *objfile, int total_symbols)
 {
   /* Free any previously allocated psymbol lists.  */
-
-  if (objfile->global_psymbols.list)
-    xfree (objfile->global_psymbols.list);
-  if (objfile->static_psymbols.list)
-    xfree (objfile->static_psymbols.list);
+  objfile->global_psymbols.clear ();
+  objfile->static_psymbols.clear ();
 
   /* Current best guess is that approximately a twentieth
      of the total symbols (in a debugging file) are global or static
      oriented symbols, then multiply that by slop factor of two.  */
-
-  objfile->global_psymbols.size = total_symbols / 10;
-  objfile->static_psymbols.size = total_symbols / 10;
-
-  if (objfile->global_psymbols.size > 0)
-    {
-      objfile->global_psymbols.next =
-	objfile->global_psymbols.list =
-	  XNEWVEC (struct partial_symbol *, objfile->global_psymbols.size);
-    }
-  if (objfile->static_psymbols.size > 0)
-    {
-      objfile->static_psymbols.next =
-	objfile->static_psymbols.list =
-	  XNEWVEC (struct partial_symbol *, objfile->static_psymbols.size);
-    }
+  objfile->global_psymbols.reserve (total_symbols / 10);
+  objfile->static_psymbols.reserve (total_symbols / 10);
 }
 
 struct partial_symtab *
@@ -2105,9 +2043,10 @@ maintenance_info_psymtabs (const char *regexp, int from_tty)
 	      printf_filtered ("    globals ");
 	      if (psymtab->n_global_syms)
 		{
+		  auto p = &objfile->global_psymbols[psymtab->globals_offset];
+
 		  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
-				   host_address_to_string (objfile->global_psymbols.list
-				    + psymtab->globals_offset),
+				   host_address_to_string (p),
 				   psymtab->n_global_syms);
 		}
 	      else
@@ -2115,9 +2054,10 @@ maintenance_info_psymtabs (const char *regexp, int from_tty)
 	      printf_filtered ("    statics ");
 	      if (psymtab->n_static_syms)
 		{
+		  auto p = &objfile->static_psymbols[psymtab->statics_offset];
+
 		  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
-				   host_address_to_string (objfile->static_psymbols.list
-				    + psymtab->statics_offset),
+				   host_address_to_string (p),
 				   psymtab->n_static_syms);
 		}
 	      else
@@ -2157,7 +2097,6 @@ static void
 maintenance_check_psymtabs (const char *ignore, int from_tty)
 {
   struct symbol *sym;
-  struct partial_symbol **psym;
   struct compunit_symtab *cust = NULL;
   struct partial_symtab *ps;
   const struct blockvector *bv;
@@ -2192,7 +2131,7 @@ maintenance_check_psymtabs (const char *ignore, int from_tty)
       continue;
     bv = COMPUNIT_BLOCKVECTOR (cust);
     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-    psym = objfile->static_psymbols.list + ps->statics_offset;
+    partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
     length = ps->n_static_syms;
     while (length--)
       {
@@ -2209,7 +2148,7 @@ maintenance_check_psymtabs (const char *ignore, int from_tty)
 	psym++;
       }
     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-    psym = objfile->global_psymbols.list + ps->globals_offset;
+    psym = &objfile->global_psymbols[ps->globals_offset];
     length = ps->n_global_syms;
     while (length--)
       {