diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index cb0f989..39d6e8d 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,52 @@
+2017-10-14  Simon Marchi  <simon.marchi@ericsson.com>
+
+	* 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.
+
 2017-10-13  Simon Marchi  <simon.marchi@ericsson.com>

 	* ada-typeprint.c (print_dynamic_range_bound): Use std::string.
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 95b89f9..ce00962 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -291,8 +291,8 @@ static void add_this_object_header_file (int);

 static struct partial_symtab *start_psymtab (struct objfile *, const char *,
 					     CORE_ADDR, int,
-					     struct partial_symbol **,
-					     struct partial_symbol **);
+					     std::vector<partial_symbol *> &,
+					     std::vector<partial_symbol *> &);

 /* Free up old header file tables.  */

@@ -531,7 +531,8 @@ dbx_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
     perror_with_name (objfile_name (objfile));

   /* Size the symbol table.  */
-  if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
+  if (objfile->global_psymbols.capacity () == 0
+      && objfile->static_psymbols.capacity () == 0)
     init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));

   symbol_size = DBX_SYMBOL_SIZE (objfile);
@@ -1358,8 +1359,8 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile)
 		pst = start_psymtab (objfile,
 				     namestring, valu,
 				     first_so_symnum * symbol_size,
-				     objfile->global_psymbols.next,
-				     objfile->static_psymbols.next);
+				     objfile->global_psymbols,
+				     objfile->static_psymbols);
 		pst->dirname = dirname_nso;
 		dirname_nso = NULL;
 	      }
@@ -1997,12 +1998,12 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile)

 static struct partial_symtab *
 start_psymtab (struct objfile *objfile, const char *filename, CORE_ADDR textlow,
-	       int ldsymoff, struct partial_symbol **global_syms,
-	       struct partial_symbol **static_syms)
+	       int ldsymoff, std::vector<partial_symbol *> &global_psymbols,
+	       std::vector<partial_symbol *> &static_psymbols)
 {
   struct partial_symtab *result =
     start_psymtab_common (objfile, filename, textlow,
-			  global_syms, static_syms);
+			  global_psymbols, static_psymbols);

   result->read_symtab_private =
     XOBNEW (&objfile->objfile_obstack, struct symloc);
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 979dae2..af4bb64 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -4456,10 +4456,9 @@ void
 dwarf2_build_psymtabs (struct objfile *objfile)
 {

-  if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
-    {
-      init_psymbol_list (objfile, 1024);
-    }
+  if (objfile->global_psymbols.capacity () == 0
+      && objfile->static_psymbols.capacity () == 0)
+    init_psymbol_list (objfile, 1024);

   TRY
     {
@@ -6143,8 +6142,8 @@ create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
   struct partial_symtab *pst;

   pst = start_psymtab_common (objfile, name, 0,
-			      objfile->global_psymbols.next,
-			      objfile->static_psymbols.next);
+			      objfile->global_psymbols,
+			      objfile->static_psymbols);

   pst->psymtabs_addrmap_supported = 1;

@@ -7166,7 +7165,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
       break;
     case DW_TAG_constant:
       {
-        struct psymbol_allocation_list *list;
+	std::vector<partial_symbol *> *list;

 	if (pdi->is_external)
 	  list = &objfile->global_psymbols;
@@ -23732,14 +23731,12 @@ write_one_signatured_type (void **slot, void *d)

   write_psymbols (info->symtab,
 		  info->psyms_seen,
-		  info->objfile->global_psymbols.list
-		  + psymtab->globals_offset,
+		  &info->objfile->global_psymbols[psymtab->globals_offset],
 		  psymtab->n_global_syms, info->cu_index,
 		  0);
   write_psymbols (info->symtab,
 		  info->psyms_seen,
-		  info->objfile->static_psymbols.list
-		  + psymtab->statics_offset,
+		  &info->objfile->static_psymbols[psymtab->statics_offset],
 		  psymtab->n_static_syms, info->cu_index,
 		  1);

@@ -23789,12 +23786,12 @@ recursively_write_psymbols (struct objfile *objfile,

   write_psymbols (symtab,
 		  psyms_seen,
-		  objfile->global_psymbols.list + psymtab->globals_offset,
+		  &objfile->global_psymbols[psymtab->globals_offset],
 		  psymtab->n_global_syms, cu_index,
 		  0);
   write_psymbols (symtab,
 		  psyms_seen,
-		  objfile->static_psymbols.list + psymtab->statics_offset,
+		  &objfile->static_psymbols[psymtab->statics_offset],
 		  psymtab->n_static_syms, cu_index,
 		  1);
 }
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 13140e7..3f53e1a 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -2657,8 +2657,8 @@ parse_partial_symbols (minimal_symbol_reader &reader,
       pst = start_psymtab_common (objfile,
 				  fdr_name (fh),
 				  textlow,
-				  objfile->global_psymbols.next,
-				  objfile->static_psymbols.next);
+				  objfile->global_psymbols,
+				  objfile->static_psymbols);
       pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
 						sizeof (struct symloc));
       memset (pst->read_symtab_private, 0, sizeof (struct symloc));
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index bf0515a..d8fe88b 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -716,10 +716,6 @@ objfile::~objfile ()
       clear_current_source_symtab_and_line ();
   }

-  if (global_psymbols.list)
-    xfree (global_psymbols.list);
-  if (static_psymbols.list)
-    xfree (static_psymbols.list);
   /* Free the obstacks for non-reusable objfiles.  */
   psymbol_bcache_free (psymbol_cache);
   obstack_free (&objfile_obstack, 0);
diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index 7e2beee..453166a 100644
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -23,7 +23,7 @@
 #include "hashtab.h"
 #include "gdb_obstack.h"	/* For obstack internals.  */
 #include "objfile-flags.h"
-#include "symfile.h"		/* For struct psymbol_allocation_list.  */
+#include "symfile.h"
 #include "progspace.h"
 #include "registry.h"
 #include "gdb_bfd.h"
@@ -31,6 +31,7 @@
 struct bcache;
 struct htab;
 struct objfile_data;
+struct partial_symbol;

 /* This structure maintains information on a per-objfile basis about the
    "entry point" of the objfile, and the scope within which the entry point
@@ -356,8 +357,8 @@ struct objfile
   /* Vectors of all partial symbols read in from file.  The actual data
      is stored in the objfile_obstack.  */

-  struct psymbol_allocation_list global_psymbols {};
-  struct psymbol_allocation_list static_psymbols {};
+  std::vector<partial_symbol *> global_psymbols;
+  std::vector<partial_symbol *> static_psymbols;

   /* Structure which keeps track of functions that manipulate objfile's
      of the same type as this objfile.  I.e. the function to read partial
diff --git a/gdb/psympriv.h b/gdb/psympriv.h
index c4d2bb9..b001573 100644
--- a/gdb/psympriv.h
+++ b/gdb/psympriv.h
@@ -23,8 +23,6 @@
 #include "psymtab.h"
 #include "objfiles.h"

-struct psymbol_allocation_list;
-
 /* A partial_symbol records the name, domain, and address class of
    symbols whose types we have not parsed yet.  For functions, it also
    contains their memory address, so we can find them from a PC value.
@@ -202,12 +200,12 @@ struct partial_symtab
   void *read_symtab_private;
 };

-/* Add any kind of symbol to a psymbol_allocation_list.  */
+/* Add any kind of symbol to a partial_symbol vector.  */

 extern void add_psymbol_to_list (const char *, int,
 				 int, domain_enum,
 				 enum address_class,
-				 struct psymbol_allocation_list *,
+				 std::vector<partial_symbol *> *,
 				 CORE_ADDR,
 				 enum language, struct objfile *);

@@ -215,8 +213,8 @@ extern void init_psymbol_list (struct objfile *, int);

 extern struct partial_symtab *start_psymtab_common (struct objfile *,
 						    const char *, CORE_ADDR,
-						    struct partial_symbol **,
-						    struct partial_symbol **);
+						    std::vector<partial_symbol *> &,
+						    std::vector<partial_symbol *> &);

 extern void end_psymtab_common (struct objfile *, struct partial_symtab *);

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--)
       {
diff --git a/gdb/symfile.c b/gdb/symfile.c
index 07d867c..a7d8553 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -2511,14 +2511,8 @@ reread_symbols (void)

 	  /* FIXME: Do we have to free a whole linked list, or is this
 	     enough?  */
-	  if (objfile->global_psymbols.list)
-	    xfree (objfile->global_psymbols.list);
-	  memset (&objfile->global_psymbols, 0,
-		  sizeof (objfile->global_psymbols));
-	  if (objfile->static_psymbols.list)
-	    xfree (objfile->static_psymbols.list);
-	  memset (&objfile->static_psymbols, 0,
-		  sizeof (objfile->static_psymbols));
+	  objfile->global_psymbols.clear ();
+	  objfile->static_psymbols.clear ();

 	  /* Free the obstacks for non-reusable objfiles.  */
 	  psymbol_bcache_free (objfile->psymbol_cache);
diff --git a/gdb/symfile.h b/gdb/symfile.h
index 1f4460c..14f48f3 100644
--- a/gdb/symfile.h
+++ b/gdb/symfile.h
@@ -45,37 +45,6 @@ struct axs_value;
 typedef int (symbol_compare_ftype) (const char *string1,
 				    const char *string2);

-/* Partial symbols are stored in the psymbol_cache and pointers to
-   them are kept in a dynamically grown array that is obtained from
-   malloc and grown as necessary via realloc.  Each objfile typically
-   has two of these, one for global symbols and one for static
-   symbols.  Although this adds a level of indirection for storing or
-   accessing the partial symbols, it allows us to throw away duplicate
-   psymbols and set all pointers to the single saved instance.  */
-
-struct psymbol_allocation_list
-{
-
-  /* Pointer to beginning of dynamically allocated array of pointers
-     to partial symbols.  The array is dynamically expanded as
-     necessary to accommodate more pointers.  */
-
-  struct partial_symbol **list;
-
-  /* Pointer to next available slot in which to store a pointer to a
-     partial symbol.  */
-
-  struct partial_symbol **next;
-
-  /* Number of allocated pointer slots in current dynamic array (not
-     the number of bytes of storage).  The "next" pointer will always
-     point somewhere between list[0] and list[size], and when at
-     list[size] the array will be expanded on the next attempt to
-     store a pointer.  */
-
-  int size;
-};
-
 struct other_sections
 {
   CORE_ADDR addr;
diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index 0707cd7..ea11b3f 100644
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -2030,15 +2030,15 @@ static unsigned int first_fun_line_offset;
 static struct partial_symtab *
 xcoff_start_psymtab (struct objfile *objfile,
 		     const char *filename, int first_symnum,
-		     struct partial_symbol **global_syms,
-		     struct partial_symbol **static_syms)
+		     std::vector<partial_symbol *> &global_psymbols,
+		     std::vector<partial_symbol *> &static_psymbols)
 {
   struct partial_symtab *result =
     start_psymtab_common (objfile,
 			  filename,
 			  /* We fill in textlow later.  */
 			  0,
-			  global_syms, static_syms);
+			  global_psymbols, static_psymbols);

   result->read_symtab_private =
     XOBNEW (&objfile->objfile_obstack, struct symloc);
@@ -2332,8 +2332,8 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
 			      (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
@@ -2515,8 +2515,8 @@ scan_xcoff_symtab (minimal_symbol_reader &reader,
 	    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;
@@ -3018,7 +3018,8 @@ xcoff_initial_scan (struct objfile *objfile, symfile_add_flags symfile_flags)
     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
