remove gengtype support for param_is use_param, if_marked and splay tree allocators

gcc/

	* plugin.c, plugin.def, ggc.h, ggc-common.c, gengtype.h, gengtype.c,
	gengtype-state.c, gengtype-parse.c, gentype-lex.l, gcc-plugin.h,
	doc/plugins.texi, doc/gty.texi: Remove support for if_marked and
	param_is.

include/

	* hashtab.h, splay-tree.h: Remove GTY markers.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@218558 138bc75d-0d04-0410-961f-82ee72b054a4

16 files changed, 100 insertions, 936 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 28fe989c605..49ab6b38b2e 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2014-12-09  Trevor Saunders  <tsaunders@mozilla.com>
+
+	* plugin.c, plugin.def, ggc.h, ggc-common.c, gengtype.h, gengtype.c,
+	gengtype-state.c, gengtype-parse.c, gentype-lex.l, gcc-plugin.h,
+	doc/plugins.texi, doc/gty.texi: Remove support for if_marked and
+	param_is.
+
 2014-12-10  Oleg Endo  <olegendo@gcc.gnu.org>
 
 	PR target/53513
diff --git a/gcc/doc/gty.texi b/gcc/doc/gty.texi
index e4d2b604687..aa6f84f9697 100644
--- a/gcc/doc/gty.texi
+++ b/gcc/doc/gty.texi
@@ -245,54 +245,6 @@ The @code{desc} and @code{tag} options can also be used for inheritance
 to denote which subclass an instance is.  See @ref{Inheritance and GTY}
 for more information.
 
-@findex param_is
-@findex use_param
-@item param_is (@var{type})
-@itemx use_param
-
-Sometimes it's convenient to define some data structure to work on
-generic pointers (that is, @code{PTR}) and then use it with a specific
-type.  @code{param_is} specifies the real type pointed to, and
-@code{use_param} says where in the generic data structure that type
-should be put.
-
-For instance, to have a @code{htab_t} that points to trees, one would
-write the definition of @code{htab_t} like this:
-@smallexample
-typedef struct GTY(()) @{
-  @dots{}
-  void ** GTY ((use_param, @dots{})) entries;
-  @dots{}
-@} htab_t;
-@end smallexample
-and then declare variables like this:
-@smallexample
-  static htab_t GTY ((param_is (union tree_node))) ict;
-@end smallexample
-
-@findex param@var{n}_is
-@findex use_param@var{n}
-@item param@var{n}_is (@var{type})
-@itemx use_param@var{n}
-
-In more complicated cases, the data structure might need to work on
-several different types, which might not necessarily all be pointers.
-For this, @code{param1_is} through @code{param9_is} may be used to
-specify the real type of a field identified by @code{use_param1} through
-@code{use_param9}.
-
-@findex use_params
-@item use_params
-
-When a structure contains another structure that is parameterized,
-there's no need to do anything special, the inner structure inherits the
-parameters of the outer one.  When a structure contains a pointer to a
-parameterized structure, the type machinery won't automatically detect
-this (it could, it just doesn't yet), so it's necessary to tell it that
-the pointed-to structure should use the same parameters as the outer
-structure.  This is done by marking the pointer with the
-@code{use_params} option.
-
 @findex cache
 @item cache
 
@@ -309,23 +261,6 @@ garbage collection runs, there's no need to mark anything pointed to
 by this variable, it can just be set to @code{NULL} instead.  This is used
 to keep a list of free structures around for re-use.
 
-@findex if_marked
-@item if_marked ("@var{expression}")
-
-Suppose you want some kinds of object to be unique, and so you put them
-in a hash table.  If garbage collection marks the hash table, these
-objects will never be freed, even if the last other reference to them
-goes away.  GGC has special handling to deal with this: if you use the
-@code{if_marked} option on a global hash table, GGC will call the
-routine whose name is the parameter to the option on each hash table
-entry.  If the routine returns nonzero, the hash table entry will
-be marked as usual.  If the routine returns zero, the hash table entry
-will be deleted.
-
-The routine @code{ggc_marked_p} can be used to determine if an element
-has been marked already; in fact, the usual case is to use
-@code{if_marked ("ggc_marked_p")}.
-
 @findex mark_hook
 @item mark_hook ("@var{hook-routine-name}")
 
diff --git a/gcc/doc/plugins.texi b/gcc/doc/plugins.texi
index 4a839b8abad..96df5066d59 100644
--- a/gcc/doc/plugins.texi
+++ b/gcc/doc/plugins.texi
@@ -185,7 +185,6 @@ enum plugin_event
   PLUGIN_GGC_MARKING,           /* Extend the GGC marking. */
   PLUGIN_GGC_END,               /* Called at end of GGC. */
   PLUGIN_REGISTER_GGC_ROOTS,    /* Register an extra GGC root table. */
-  PLUGIN_REGISTER_GGC_CACHES,   /* Register an extra GGC cache table. */
   PLUGIN_ATTRIBUTES,            /* Called during attribute registration */
   PLUGIN_START_UNIT,            /* Called before processing a translation unit.  */
   PLUGIN_PRAGMAS,               /* Called during pragma registration. */
@@ -233,10 +232,9 @@ the arguments:
 @item @code{void *user_data}: Pointer to plugin-specific data.
 @end itemize
 
-For the @i{PLUGIN_PASS_MANAGER_SETUP}, @i{PLUGIN_INFO},
-@i{PLUGIN_REGISTER_GGC_ROOTS} and @i{PLUGIN_REGISTER_GGC_CACHES}
-pseudo-events the @code{callback} should be null, and the
-@code{user_data} is specific.
+For the @i{PLUGIN_PASS_MANAGER_SETUP}, @i{PLUGIN_INFO}, and
+@i{PLUGIN_REGISTER_GGC_ROOTS} pseudo-events the @code{callback} should be null,
+and the @code{user_data} is specific.
 
 When the @i{PLUGIN_PRAGMAS} event is triggered (with a null pointer as
 data from GCC), plugins may register their own pragmas.  Notice that
@@ -321,21 +319,22 @@ done by registering a callback (called with a null @code{gcc_data})
 for the @code{PLUGIN_GGC_MARKING} event. Such callbacks can call the
 @code{ggc_set_mark} routine, preferably through the @code{ggc_mark} macro
 (and conversely, these routines should usually not be used in plugins
-outside of the @code{PLUGIN_GGC_MARKING} event).
+outside of the @code{PLUGIN_GGC_MARKING} event).  Plugins that wish to hold
+weak references to gc data may also use this event to drop weak references when
+the object is about to be collected.  The @code{ggc_marked_p} function can be
+used to tell if an object is marked, or is about to  be collected.  The
+@code{gt_clear_cache} overloads which some types define may also be of use in
+managing weak references.
 
 Some plugins may need to add extra GGC root tables, e.g. to handle their own
 @code{GTY}-ed data. This can be done with the @code{PLUGIN_REGISTER_GGC_ROOTS}
 pseudo-event with a null callback and the extra root table (of type @code{struct
-ggc_root_tab*}) as @code{user_data}.  Plugins that want to use the
-@code{if_marked} hash table option can add the extra GGC cache tables generated
-by @code{gengtype} using the @code{PLUGIN_REGISTER_GGC_CACHES} pseudo-event with
-a null callback and the extra cache table (of type @code{struct ggc_cache_tab*})
-as @code{user_data}.  Running the @code{gengtype -p @var{source-dir}
-@var{file-list} @var{plugin*.c} ...} utility generates these extra root tables.
+ggc_root_tab*}) as @code{user_data}.  Running the
+ @code{gengtype -p @var{source-dir} @var{file-list} @var{plugin*.c} ...}
+utility generates these extra root tables.
 
 You should understand the details of memory management inside GCC
-before using @code{PLUGIN_GGC_MARKING}, @code{PLUGIN_REGISTER_GGC_ROOTS}
-or @code{PLUGIN_REGISTER_GGC_CACHES}.
+before using @code{PLUGIN_GGC_MARKING} or @code{PLUGIN_REGISTER_GGC_ROOTS}.
 
 
 @node Plugins description
diff --git a/gcc/gcc-plugin.h b/gcc/gcc-plugin.h
index f1c13a50d04..6ebb8f0154a 100644
--- a/gcc/gcc-plugin.h
+++ b/gcc/gcc-plugin.h
@@ -150,8 +150,8 @@ extern int get_event_last (void);
 int get_named_event_id (const char *name, enum insert_option insert);
 
 /* This is also called without a callback routine for the
-   PLUGIN_PASS_MANAGER_SETUP, PLUGIN_INFO, PLUGIN_REGISTER_GGC_ROOTS and
-   PLUGIN_REGISTER_GGC_CACHES pseudo-events, with a specific user_data.
+   PLUGIN_PASS_MANAGER_SETUP, PLUGIN_INFO and PLUGIN_REGISTER_GGC_ROOTS
+   pseudo-events, with a specific user_data.
   */
 
 extern void register_callback (const char *plugin_name,
diff --git a/gcc/gengtype-lex.l b/gcc/gengtype-lex.l
index 0866603d5c4..d5a6cc838ff 100644
--- a/gcc/gengtype-lex.l
+++ b/gcc/gengtype-lex.l
@@ -126,10 +126,6 @@ CXX_KEYWORD inline|public:|private:|protected:|template|operator|friend|static
 "nested_ptr"/{EOID}		{ return NESTED_PTR; }
 "user"/{EOID}			{ return USER_GTY; }
 [0-9]+				{ return NUM; }
-"param"[0-9]*"_is"/{EOID}		{
-  *yylval = XDUPVAR (const char, yytext, yyleng, yyleng+1);
-  return PARAM_IS;
-}
 
 {IWORD}({WS}{IWORD})*/{EOID}		|
 "ENUM_BITFIELD"{WS}?"("{WS}?{ID}{WS}?")"	{
diff --git a/gcc/gengtype-parse.c b/gcc/gengtype-parse.c
index 87b69175214..f99b853cd66 100644
--- a/gcc/gengtype-parse.c
+++ b/gcc/gengtype-parse.c
@@ -538,7 +538,6 @@ nestedptr_optvalue (options_p prev)
 /* One GTY(()) option:
    ID str_optvalue_opt
    | PTR_ALIAS type_optvalue
-   | PARAM_IS type_optvalue
    | NESTED_PTR nestedptr_optvalue
 */
 static options_p
@@ -553,9 +552,6 @@ option (options_p prev)
       advance ();
       return type_optvalue (prev, "ptr_alias");
 
-    case PARAM_IS:
-      return type_optvalue (prev, advance ());
-
     case NESTED_PTR:
       advance ();
       return nestedptr_optvalue (prev);
diff --git a/gcc/gengtype-state.c b/gcc/gengtype-state.c
index 7634f746e0d..9eaf07804dd 100644
--- a/gcc/gengtype-state.c
+++ b/gcc/gengtype-state.c
@@ -54,8 +54,6 @@ type_lineloc (const_type_p ty)
     case TYPE_USER_STRUCT:
     case TYPE_UNDEFINED:
       return CONST_CAST (struct fileloc*, &ty->u.s.line);
-    case TYPE_PARAM_STRUCT:
-      return CONST_CAST (struct fileloc*, &ty->u.param_struct.line);
     case TYPE_SCALAR:
     case TYPE_STRING:
     case TYPE_POINTER:
@@ -180,7 +178,6 @@ private:
   void write_state_user_struct_type (type_p current);
   void write_state_union_type (type_p current);
   void write_state_lang_struct_type (type_p current);
-  void write_state_param_struct_type (type_p current);
   void write_state_pointer_type (type_p current);
   void write_state_array_type (type_p current);
   void write_state_gc_used (enum gc_used_enum gus);
@@ -190,7 +187,6 @@ private:
   int write_state_pair_list (pair_p list);
   void write_state_typedefs (void);
   void write_state_structures (void);
-  void write_state_param_structs (void);
   void write_state_variables (void);
   void write_state_srcdir (void);
   void write_state_files_list (void);
@@ -635,7 +631,6 @@ state_token_is_name (struct state_token_st *p, const char *name)
  * We want to serialize :
  *          - typedefs list
  *          - structures list
- *          - param_structs list
  *          - variables list
  *
  * So, we have one routine for each kind of data.  The main writing
@@ -1023,29 +1018,6 @@ state_writer::write_state_lang_struct_type (type_p current)
   end_s_expr ();
 }
 
-/* Write a parametrized structure GTY type.  */
-void
-state_writer::write_state_param_struct_type (type_p current)
-{
-  int i;
-
-  write_any_indent (0);
-  fprintf (state_file, "param_struct ");
-  write_state_common_type_content (current);
-  write_state_type (current->u.param_struct.stru);
-  for (i = 0; i < NUM_PARAM; i++)
-    {
-      if (current->u.param_struct.param[i] != NULL)
-	write_state_type (current->u.param_struct.param[i]);
-      else
-	{
-	  write_any_indent (0);
-	  fprintf (state_file, "nil ");
-	}
-    }
-  write_state_fileloc (&current->u.param_struct.line);
-}
-
 /* Write a pointer type.  */
 void
 state_writer::write_state_pointer_type (type_p current)
@@ -1166,9 +1138,6 @@ state_writer::write_state_type (type_p current)
 	case TYPE_LANG_STRUCT:
 	  write_state_lang_struct_type (current);
 	  break;
-	case TYPE_PARAM_STRUCT:
-	  write_state_param_struct_type (current);
-	  break;
 	case TYPE_SCALAR:
 	  write_state_scalar_type (current);
 	  break;
@@ -1225,10 +1194,9 @@ state_writer::write_state_pair_list (pair_p list)
 
 }
 
-/* When writing imported linked lists, like typedefs, structures,
-   param_structs, ... we count their length first and write it.  These
-   eases the reading, and enables an extra verification on the number
-   of actually read items.  */
+/* When writing imported linked lists, like typedefs, structures, ... we count
+   their length first and write it.  This eases the reading, and enables an
+   extra verification on the number of actually read items.  */
 
 /* Write our typedefs.  */
 void
@@ -1270,25 +1238,6 @@ state_writer::write_state_structures (void)
     printf ("%s wrote %d structures in state\n", progname, nbstruct);
 }
 
-/* Write our param_struct-s.  */
-void
-state_writer::write_state_param_structs (void)
-{
-  int nbparamstruct = 0;
-  type_p current;
-
-  for (current = param_structs; current != NULL; current = current->next)
-    nbparamstruct++;
-
-  begin_s_expr ("param_structs");
-  fprintf (state_file, "%d", nbparamstruct);
-
-  for (current = param_structs; current != NULL; current = current->next)
-    write_state_type (current);
-
-  end_s_expr ();
-}
-
 /* Write our variables.  */
 void
 state_writer::write_state_variables (void)
@@ -1425,7 +1374,6 @@ write_state (const char *state_path)
   sw.write_state_files_list ();
   sw.write_state_structures ();
   sw.write_state_typedefs ();
-  sw.write_state_param_structs ();
   sw.write_state_variables ();
   write_state_trailer ();
   statelen = ftell (state_file);
@@ -1810,34 +1758,6 @@ read_state_lang_struct_type (type_p type)
 }
 
 
-/* Read a param_struct type for GTY parametrized structures.  */
-static void
-read_state_param_struct_type (type_p type)
-{
-  int i;
-  struct state_token_st *t0;
-
-  type->kind = TYPE_PARAM_STRUCT;
-  read_state_common_type_content (type);
-  DBGPRINTF ("read param_struct type @%p #%d",
-	     (void *) type, type->state_number);
-  read_state_type (&(type->u.param_struct.stru));
-
-  for (i = 0; i < NUM_PARAM; i++)
-    {
-      t0 = peek_state_token (0);
-      if (state_token_is_name (t0, "nil"))
-	{
-	  type->u.param_struct.param[i] = NULL;
-	  next_state_tokens (1);
-	}
-      else
-	read_state_type (&(type->u.param_struct.param[i]));
-    }
-  read_state_fileloc (&(type->u.param_struct.line));
-}
-
-
 /* Read the gc used information.  */
 static void
 read_state_gc_used (enum gc_used_enum *pgus)
@@ -1939,12 +1859,6 @@ read_state_type (type_p *current)
 	      next_state_tokens (1);
 	      read_state_lang_struct_type (*current);
 	    }
-	  else if (state_token_is_name (t0, "param_struct"))
-	    {
-	      *current = XCNEW (struct type);
-	      next_state_tokens (1);
-	      read_state_param_struct_type (*current);
-	    }
 	  else if (state_token_is_name (t0, "pointer"))
 	    {
 	      *current = XCNEW (struct type);
@@ -2440,58 +2354,6 @@ read_state_structures (type_p *structures)
 }
 
 
-/* Read the param_struct-s.  */
-static void
-read_state_param_structs (type_p *param_structs)
-{
-  int nbparamstructs = 0;
-  int countparamstructs = 0;
-  type_p head = NULL;
-  type_p previous = NULL;
-  type_p tmp;
-  struct state_token_st *t0 = peek_state_token (0);
-  struct state_token_st *t1 = peek_state_token (1);
-  struct state_token_st *t2 = peek_state_token (2);
-
-  if (state_token_kind (t0) == STOK_LEFTPAR
-      && state_token_is_name (t1, "!param_structs")
-      && state_token_kind (t2) == STOK_INTEGER)
-    {
-      nbparamstructs = t2->stok_un.stok_num;
-      next_state_tokens (3);
-      t0 = t1 = t2 = NULL;
-      t0 = peek_state_token (0);
-      while (state_token_kind (t0) != STOK_RIGHTPAR)
-	{
-	  tmp = NULL;
-	  read_state_type (&tmp);
-	  if (head == NULL)
-	    {
-	      head = tmp;
-	      previous = head;
-	    }
-	  else
-	    {
-	      previous->next = tmp;
-	      previous = tmp;
-	    }
-	  t0 = peek_state_token (0);
-	  countparamstructs++;
-	}
-      next_state_tokens (1);
-    }
-  else
-    fatal_reading_state (t0, "Bad param_structs syntax");
-  t0 = peek_state_token (0);
-  if (countparamstructs != nbparamstructs)
-    fatal_reading_state_printf
-      (t0,
-       "invalid number of param_structs expected %d got %d",
-       nbparamstructs, countparamstructs);
-  *param_structs = head;
-}
-
-
 /* Read the variables.  */
 static void
 read_state_variables (pair_p *variables)
@@ -2738,7 +2600,6 @@ read_state (const char *path)
       (NULL_STATE_TOKEN, "input error while reading state [%s]",
        xstrerror (errno));
   read_state_typedefs (&typedefs);
-  read_state_param_structs (&param_structs);
   read_state_variables (&variables);
   read_state_trailer ();
 
diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index 39d29183521..04b77471bd2 100644
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -186,7 +186,7 @@ dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
 {
   int nb_types = 0, nb_scalar = 0, nb_string = 0;
   int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0;
-  int nb_lang_struct = 0, nb_param_struct = 0;
+  int nb_lang_struct = 0;
   int nb_user_struct = 0, nb_undefined = 0;
   type_p p = NULL;
   for (p = t; p; p = p->next)
@@ -220,9 +220,6 @@ dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
 	case TYPE_LANG_STRUCT:
 	  nb_lang_struct++;
 	  break;
-	case TYPE_PARAM_STRUCT:
-	  nb_param_struct++;
-	  break;
 	case TYPE_NONE:
 	  gcc_unreachable ();
 	}
@@ -235,9 +232,8 @@ dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
     fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union);
   if (nb_pointer > 0 || nb_array > 0)
     fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array);
-  if (nb_lang_struct > 0 || nb_param_struct > 0)
-    fprintf (stderr, "@@%%@@ %d lang_structs, %d param_structs\n",
-	     nb_lang_struct, nb_param_struct);
+  if (nb_lang_struct > 0)
+    fprintf (stderr, "@@%%@@ %d lang_structs\n", nb_lang_struct);
   if (nb_user_struct > 0)
     fprintf (stderr, "@@%%@@ %d user_structs\n", nb_user_struct);
   if (nb_undefined > 0)
@@ -519,10 +515,8 @@ struct type scalar_char = {
 
 pair_p typedefs = NULL;
 type_p structures = NULL;
-type_p param_structs = NULL;
 pair_p variables = NULL;
 
-static type_p find_param_structure (type_p t, type_p param[NUM_PARAM]);
 static type_p adjust_field_tree_exp (type_p t, options_p opt);
 static type_p adjust_field_rtx_def (type_p t, options_p opt);
 
@@ -872,34 +866,6 @@ find_structure (const char *name, enum typekind kind)
   return s;
 }
 
-/* Return the previously-defined parameterized structure for structure
-   T and parameters PARAM, or a new parameterized empty structure or
-   union if none was defined previously.  */
-
-static type_p
-find_param_structure (type_p t, type_p param[NUM_PARAM])
-{
-  type_p res;
-
-  for (res = param_structs; res; res = res->next)
-    if (res->u.param_struct.stru == t
-	&& memcmp (res->u.param_struct.param, param,
-		   sizeof (type_p) * NUM_PARAM) == 0)
-      break;
-  if (res == NULL)
-    {
-      type_count++;
-      res = XCNEW (struct type);
-      res->kind = TYPE_PARAM_STRUCT;
-      res->next = param_structs;
-      res->state_number = -type_count;
-      param_structs = res;
-      res->u.param_struct.stru = t;
-      memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
-    }
-  return res;
-}
-
 /* Return a scalar type with name NAME.  */
 
 type_p
@@ -1462,12 +1428,6 @@ adjust_field_type (type_p t, options_p opt)
 {
   int length_p = 0;
   const int pointer_p = t->kind == TYPE_POINTER;
-  type_p params[NUM_PARAM];
-  int params_p = 0;
-  int i;
-
-  for (i = 0; i < NUM_PARAM; i++)
-    params[i] = NULL;
 
   for (; opt; opt = opt->next)
     if (strcmp (opt->name, "length") == 0)
@@ -1482,31 +1442,6 @@ adjust_field_type (type_p t, options_p opt)
 	  }
 	length_p = 1;
       }
-    else if ((strcmp (opt->name, "param_is") == 0
-	      || (strncmp (opt->name, "param", 5) == 0
-		  && ISDIGIT (opt->name[5])
-		  && strcmp (opt->name + 6, "_is") == 0))
-	     && opt->kind == OPTION_TYPE)
-      {
-	int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
-
-	if (!union_or_struct_p (t)
-	    && (t->kind != TYPE_POINTER || !union_or_struct_p (t->u.p)))
-	  {
-	    error_at_line (&lexer_line,
-			   "option `%s' may only be applied to structures or structure pointers",
-			   opt->name);
-	    return t;
-	  }
-
-	params_p = 1;
-	if (params[num] != NULL)
-	  error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
-	if (!ISDIGIT (opt->name[5]))
-	  params[num] = create_pointer (opt->info.type);
-	else
-	  params[num] = opt->info.type;
-      }
     else if (strcmp (opt->name, "special") == 0
 	     && opt->kind == OPTION_STRING)
       {
@@ -1519,16 +1454,6 @@ adjust_field_type (type_p t, options_p opt)
 	  error_at_line (&lexer_line, "unknown special `%s'", special_name);
       }
 
-  if (params_p)
-    {
-      type_p realt;
-
-      if (pointer_p)
-	t = t->u.p;
-      realt = find_param_structure (t, params);
-      t = pointer_p ? create_pointer (realt) : realt;
-    }
-
   if (!length_p
       && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char)
     return &string_type;
@@ -1541,27 +1466,23 @@ adjust_field_type (type_p t, options_p opt)
 }
 
 
-static void set_gc_used_type (type_p, enum gc_used_enum, type_p *,
-			      bool = false);
+static void set_gc_used_type (type_p, enum gc_used_enum, bool = false);
 static void set_gc_used (pair_p);
 
 /* Handle OPT for set_gc_used_type.  */
 
 static void
 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
-		    int *pass_param, int *length, int *skip,
-		    type_p *nested_ptr)
+		    int *length, int *skip, type_p *nested_ptr)
 {
   options_p o;
   for (o = opt; o; o = o->next)
     if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO
 	&& o->kind == OPTION_TYPE)
       set_gc_used_type (o->info.type,
-			GC_POINTED_TO, NULL);
+			GC_POINTED_TO);
     else if (strcmp (o->name, "maybe_undef") == 0)
       *maybe_undef = 1;
-    else if (strcmp (o->name, "use_params") == 0)
-      *pass_param = 1;
     else if (strcmp (o->name, "length") == 0)
       *length = 1;
     else if (strcmp (o->name, "skip") == 0)
@@ -1595,7 +1516,7 @@ process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
    'EnumValue' is a type.  */
 
 static void
-set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM],
+set_gc_used_type (type_p t, enum gc_used_enum level,
 		  bool allow_undefined_types)
 {
   if (t->gc_used >= level)
@@ -1614,44 +1535,36 @@ set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM],
 	type_p dummy2;
 	bool allow_undefined_field_types = (t->kind == TYPE_USER_STRUCT);
 
-	process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
+	process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy,
 			    &dummy2);
 
 	if (t->u.s.base_class)
-	  set_gc_used_type (t->u.s.base_class, level, param,
-			    allow_undefined_types);
+	  set_gc_used_type (t->u.s.base_class, level, allow_undefined_types);
 	/* Anything pointing to a base class might actually be pointing
 	   to a subclass.  */
 	for (type_p subclass = t->u.s.first_subclass; subclass;
 	     subclass = subclass->u.s.next_sibling_class)
-	  set_gc_used_type (subclass, level, param,
-			    allow_undefined_types);
+	  set_gc_used_type (subclass, level, allow_undefined_types);
 
 	FOR_ALL_INHERITED_FIELDS(t, f)
 	  {
 	    int maybe_undef = 0;
-	    int pass_param = 0;
 	    int length = 0;
 	    int skip = 0;
 	    type_p nested_ptr = NULL;
-	    process_gc_options (f->opt, level, &maybe_undef, &pass_param,
-				&length, &skip, &nested_ptr);
+	    process_gc_options (f->opt, level, &maybe_undef, &length, &skip,
+				&nested_ptr);
 
 	    if (nested_ptr && f->type->kind == TYPE_POINTER)
-	      set_gc_used_type (nested_ptr, GC_POINTED_TO,
-				pass_param ? param : NULL);
+	      set_gc_used_type (nested_ptr, GC_POINTED_TO);
 	    else if (length && f->type->kind == TYPE_POINTER)
-	      set_gc_used_type (f->type->u.p, GC_USED, NULL);
+	      set_gc_used_type (f->type->u.p, GC_USED);
 	    else if (maybe_undef && f->type->kind == TYPE_POINTER)
-	      set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
-	    else if (pass_param && f->type->kind == TYPE_POINTER && param)
-	      set_gc_used_type (find_param_structure (f->type->u.p, param),
-				GC_POINTED_TO, NULL);
+	      set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO);
 	    else if (skip)
 	      ;			/* target type is not used through this field */
 	    else
-	      set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL,
-				allow_undefined_field_types);
+	      set_gc_used_type (f->type, GC_USED, allow_undefined_field_types);
 	  }
 	break;
       }
@@ -1666,32 +1579,16 @@ set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM],
       break;
 
     case TYPE_POINTER:
-      set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
+      set_gc_used_type (t->u.p, GC_POINTED_TO);
       break;
 
     case TYPE_ARRAY:
-      set_gc_used_type (t->u.a.p, GC_USED, param);
+      set_gc_used_type (t->u.a.p, GC_USED);
       break;
 
     case TYPE_LANG_STRUCT:
       for (t = t->u.s.lang_struct; t; t = t->next)
-	set_gc_used_type (t, level, param);
-      break;
-
-    case TYPE_PARAM_STRUCT:
-      {
-	int i;
-	for (i = 0; i < NUM_PARAM; i++)
-	  if (t->u.param_struct.param[i] != 0)
-	    set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
-      }
-      if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
-	level = GC_POINTED_TO;
-      else
-	level = GC_USED;
-      t->u.param_struct.stru->gc_used = GC_UNUSED;
-      set_gc_used_type (t->u.param_struct.stru, level,
-			t->u.param_struct.param);
+	set_gc_used_type (t, level);
       break;
 
     default:
@@ -1708,7 +1605,7 @@ set_gc_used (pair_p variables)
   pair_p p;
   for (p = variables; p; p = p->next)
     {
-      set_gc_used_type (p->type, GC_USED, NULL);
+      set_gc_used_type (p->type, GC_USED);
       nbvars++;
     };
   if (verbosity_level >= 2)
@@ -2540,27 +2437,25 @@ static void output_escaped_param (struct walk_type_data *d,
 				  const char *, const char *);
 static void output_mangled_typename (outf_p, const_type_p);
 static void walk_type (type_p t, struct walk_type_data *d);
-static void write_func_for_structure (type_p orig_s, type_p s, type_p *param,
+static void write_func_for_structure (type_p orig_s, type_p s,
 				      const struct write_types_data *wtd);
 static void write_types_process_field
   (type_p f, const struct walk_type_data *d);
 static void write_types (outf_p output_header,
 			 type_p structures,
-			 type_p param_structs,
 			 const struct write_types_data *wtd);
 static void write_types_local_process_field
   (type_p f, const struct walk_type_data *d);
-static void write_local_func_for_structure
-  (const_type_p orig_s, type_p s, type_p *param);
+static void write_local_func_for_structure (const_type_p orig_s, type_p s);
 static void write_local (outf_p output_header,
-			 type_p structures, type_p param_structs);
+			 type_p structures);
 static int contains_scalar_p (type_p t);
 static void put_mangled_filename (outf_p, const input_file *);
 static void finish_root_table (struct flist *flp, const char *pfx,
 			       const char *tname, const char *lastname,
 			       const char *name);
 static void write_root (outf_p, pair_p, type_p, const char *, int,
-			struct fileloc *, const char *, bool);
+			struct fileloc *, bool);
 static void write_array (outf_p f, pair_p v,
 			 const struct write_types_data *wtd);
 static void write_roots (pair_p, bool);
@@ -2579,7 +2474,6 @@ struct walk_type_data
   int counter;
   const struct fileloc *line;
   lang_bitmap bitmap;
-  type_p *param;
   int used_length;
   type_p orig_s;
   const char *reorder_fn;
@@ -2660,15 +2554,6 @@ output_mangled_typename (outf_p of, const_type_p t)
 	    free (CONST_CAST (char *, id_for_tag));
 	}
 	break;
-      case TYPE_PARAM_STRUCT:
-	{
-	  int i;
-	  for (i = 0; i < NUM_PARAM; i++)
-	    if (t->u.param_struct.param[i] != NULL)
-	      output_mangled_typename (of, t->u.param_struct.param[i]);
-	  output_mangled_typename (of, t->u.param_struct.stru);
-	}
-	break;
       case TYPE_ARRAY:
 	gcc_unreachable ();
       }
@@ -2793,8 +2678,7 @@ walk_subclasses (type_p base, struct walk_type_data *d,
    containing the current object, D->OPT is a list of options to
    apply, D->INDENT is the current indentation level, D->LINE is used
    to print error messages, D->BITMAP indicates which languages to
-   print the structure for, and D->PARAM is the current parameter
-   (from an enclosing param_is option).  */
+   print the structure for.  */
 
 static void
 walk_type (type_p t, struct walk_type_data *d)
@@ -2803,8 +2687,6 @@ walk_type (type_p t, struct walk_type_data *d)
   const char *desc = NULL;
   const char *type_tag = NULL;
   int maybe_undef_p = 0;
-  int use_param_num = -1;
-  int use_params_p = 0;
   int atomic_p = 0;
   options_p oo;
   const struct nested_ptr_data *nested_ptr_d = NULL;
@@ -2815,11 +2697,6 @@ walk_type (type_p t, struct walk_type_data *d)
       length = oo->info.string;
     else if (strcmp (oo->name, "maybe_undef") == 0)
       maybe_undef_p = 1;
-    else if (strncmp (oo->name, "use_param", 9) == 0
-	     && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
-      use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
-    else if (strcmp (oo->name, "use_params") == 0)
-      use_params_p = 1;
     else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING)
       desc = oo->info.string;
     else if (strcmp (oo->name, "mark_hook") == 0)
@@ -2839,11 +2716,6 @@ walk_type (type_p t, struct walk_type_data *d)
       atomic_p = 1;
     else if (strcmp (oo->name, "default") == 0)
       ;
-    else if (strcmp (oo->name, "param_is") == 0)
-      ;
-    else if (strncmp (oo->name, "param", 5) == 0
-	     && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0)
-      ;
     else if (strcmp (oo->name, "chain_next") == 0)
       ;
     else if (strcmp (oo->name, "chain_prev") == 0)
@@ -2862,39 +2734,6 @@ walk_type (type_p t, struct walk_type_data *d)
   if (d->used_length)
     length = NULL;
 
-  if (use_params_p)
-    {
-      int pointer_p = t->kind == TYPE_POINTER;
-
-      if (pointer_p)
-	t = t->u.p;
-      if (!union_or_struct_p (t))
-	error_at_line (d->line, "`use_params' option on unimplemented type");
-      else
-	t = find_param_structure (t, d->param);
-      if (pointer_p)
-	t = create_pointer (t);
-    }
-
-  if (use_param_num != -1)
-    {
-      if (d->param != NULL && d->param[use_param_num] != NULL)
-	{
-	  type_p nt = d->param[use_param_num];
-
-	  if (t->kind == TYPE_ARRAY)
-	    nt = create_array (nt, t->u.a.len);
-	  else if (length != NULL && t->kind == TYPE_POINTER)
-	    nt = create_pointer (nt);
-	  d->needs_cast_p = (t->kind != TYPE_POINTER
-			     && (nt->kind == TYPE_POINTER
-				 || nt->kind == TYPE_STRING));
-	  t = nt;
-	}
-      else
-	error_at_line (d->line, "no parameter defined for `%s'", d->val);
-    }
-
   if (maybe_undef_p
       && (t->kind != TYPE_POINTER || !union_or_struct_p (t->u.p)))
     {
@@ -2947,8 +2786,7 @@ walk_type (type_p t, struct walk_type_data *d)
 
 	if (!length)
 	  {
-	    if (!union_or_struct_p (t->u.p)
-		&& t->u.p->kind != TYPE_PARAM_STRUCT)
+	    if (!union_or_struct_p (t->u.p))
 	      {
 		error_at_line (d->line,
 			       "field `%s' is pointer to unimplemented type",
@@ -3221,7 +3059,6 @@ walk_type (type_p t, struct walk_type_data *d)
 	    const char *tagid = NULL;
 	    int skip_p = 0;
 	    int default_p = 0;
-	    int use_param_p = 0;
 	    const char *fieldlength = NULL;
 	    char *newval;
 
@@ -3240,9 +3077,6 @@ walk_type (type_p t, struct walk_type_data *d)
 	      else if (strcmp (oo->name, "reorder") == 0
 		  && oo->kind == OPTION_STRING)
 		d->reorder_fn = oo->info.string;
-	      else if (strncmp (oo->name, "use_param", 9) == 0
-		       && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
-		use_param_p = 1;
 	      else if (strcmp (oo->name, "length") == 0
 		       && oo->kind == OPTION_STRING)
 		fieldlength = oo->info.string;
@@ -3290,10 +3124,7 @@ walk_type (type_p t, struct walk_type_data *d)
 	    d->used_length = false;
 	    d->in_record_p = !union_p;
 
-	    if (union_p && use_param_p && d->param == NULL)
-	      oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
-	    else
-	      walk_type (f->type, d);
+	    walk_type (f->type, d);
 
 	    d->in_record_p = false;
 
@@ -3369,16 +3200,6 @@ walk_type (type_p t, struct walk_type_data *d)
       }
       break;
 
-    case TYPE_PARAM_STRUCT:
-      {
-	type_p *oldparam = d->param;
-
-	d->param = t->u.param_struct.param;
-	walk_type (t->u.param_struct.stru, d);
-	d->param = oldparam;
-      }
-      break;
-
     case TYPE_USER_STRUCT:
       d->process_field (t, d);
       break;
@@ -3447,7 +3268,6 @@ write_types_process_field (type_p f, const struct walk_type_data *d)
     case TYPE_STRUCT:
     case TYPE_UNION:
     case TYPE_LANG_STRUCT:
-    case TYPE_PARAM_STRUCT:
     case TYPE_USER_STRUCT:
       if (f->kind == TYPE_USER_STRUCT && !d->in_ptr_field)
 	{
@@ -3483,20 +3303,13 @@ write_types_process_field (type_p f, const struct walk_type_data *d)
    reference struct S */
 
 static outf_p
-get_output_file_for_structure (const_type_p s, type_p *param)
+get_output_file_for_structure (const_type_p s)
 {
   const input_file *fn;
-  int i;
 
   gcc_assert (union_or_struct_p (s));
   fn = s->u.s.line.file;
 
-  /* This is a hack, and not the good kind either.  */
-  for (i = NUM_PARAM - 1; i >= 0; i--)
-    if (param && param[i] && param[i]->kind == TYPE_POINTER
-	&& union_or_struct_p (param[i]->u.p))
-      fn = param[i]->u.p->u.s.line.file;
-
   /* The call to get_output_file_with_visibility may update fn by
      caching its result inside, so we need the CONST_CAST.  */
   return get_output_file_with_visibility (CONST_CAST (input_file*, fn));
@@ -3566,11 +3379,6 @@ write_marker_function_name (outf_p of, type_p s, const char *prefix)
       if (id_for_tag != s->u.s.tag)
 	free (CONST_CAST (char *, id_for_tag));
     }
-  else if (s->kind == TYPE_PARAM_STRUCT)
-    {
-      oprintf (of, "gt_%s_", prefix);
-      output_mangled_typename (of, s);
-    }
   else
     gcc_unreachable ();
 }
@@ -3582,16 +3390,6 @@ write_marker_function_name (outf_p of, type_p s, const char *prefix)
 static void
 write_user_func_for_structure_ptr (outf_p of, type_p s, const write_types_data *wtd)
 {
-  /* Parameterized structures are not supported in user markers. There
-     is no way for the marker function to know which specific type
-     to use to generate the call to the void * entry point.  For
-     instance, a marker for struct htab may need to call different
-     routines to mark the fields, depending on the paramN_is attributes.
-
-     A user-defined marker that accepts 'struct htab' as its argument
-     would not know which variant to call. Generating several entry
-     points accepting 'struct htab' would cause multiply-defined
-     errors during compilation.  */
   gcc_assert (union_or_struct_p (s));
 
   type_p alias_of = NULL;
@@ -3684,15 +3482,14 @@ write_user_marking_functions (type_p s,
 }
 
 
-/* For S, a structure that's part of ORIG_S, and using parameters
-   PARAM, write out a routine that:
+/* For S, a structure that's part of ORIG_S write out a routine that:
    - Takes a parameter, a void * but actually of type *S
    - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
    field of S or its substructures and (in some cases) things
    that are pointed to by S.  */
 
 static void
-write_func_for_structure (type_p orig_s, type_p s, type_p *param,
+write_func_for_structure (type_p orig_s, type_p s,
 			  const struct write_types_data *wtd)
 {
   const char *chain_next = NULL;
@@ -3721,7 +3518,7 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param,
     }
 
   memset (&d, 0, sizeof (d));
-  d.of = get_output_file_for_structure (s, param);
+  d.of = get_output_file_for_structure (s);
 
   bool for_user = false;
   for (opt = s->u.s.opt; opt; opt = opt->next)
@@ -3752,7 +3549,6 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param,
   d.opt = s->u.s.opt;
   d.line = &s->u.s.line;
   d.bitmap = s->u.s.bitmap;
-  d.param = param;
   d.prev_val[0] = "*x";
   d.prev_val[1] = "not valid postage";	/* Guarantee an error.  */
   d.prev_val[3] = "x";
@@ -3894,7 +3690,7 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param,
 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS.  */
 
 static void
-write_types (outf_p output_header, type_p structures, type_p param_structs,
+write_types (outf_p output_header, type_p structures,
 	     const struct write_types_data *wtd)
 {
   int nbfun = 0;		/* Count the emitted functions.  */
@@ -3965,24 +3761,6 @@ write_types (outf_p output_header, type_p structures, type_p param_structs,
 	  }
       }
 
-  for (s = param_structs; s; s = s->next)
-    if (s->gc_used == GC_POINTED_TO)
-      {
-	type_p stru = s->u.param_struct.stru;
-
-	/* Declare the marker procedure.  */
-	oprintf (output_header, "extern void gt_%s_", wtd->prefix);
-	output_mangled_typename (output_header, s);
-	oprintf (output_header, " (void *);\n");
-
-	if (stru->u.s.line.file == NULL)
-	  {
-	    fprintf (stderr, "warning: structure `%s' used but not defined\n",
-		     stru->u.s.tag);
-	    continue;
-	  }
-      }
-
   /* At last we emit the functions code.  */
   oprintf (output_header, "\n/* functions code */\n");
   for (s = structures; s; s = s->next)
@@ -4006,7 +3784,7 @@ write_types (outf_p output_header, type_p structures, type_p param_structs,
 		nbfun++;
 		DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
 			   nbfun, (void*) ss, ss->u.s.tag);
-		write_func_for_structure (s, ss, NULL, wtd);
+		write_func_for_structure (s, ss, wtd);
 	      }
 	  }
 	else
@@ -4014,7 +3792,7 @@ write_types (outf_p output_header, type_p structures, type_p param_structs,
 	    nbfun++;
 	    DBGPRINTF ("writing func #%d struct s @ %p '%s'",
 		       nbfun, (void*) s, s->u.s.tag);
-	    write_func_for_structure (s, s, NULL, wtd);
+	    write_func_for_structure (s, s, wtd);
 	  }
       }
     else
@@ -4025,38 +3803,6 @@ write_types (outf_p output_header, type_p structures, type_p param_structs,
 		   (int) s->gc_used);
       }
 
-  for (s = param_structs; s; s = s->next)
-    if (s->gc_used == GC_POINTED_TO)
-      {
-	type_p *param = s->u.param_struct.param;
-	type_p stru = s->u.param_struct.stru;
-	if (stru->u.s.line.file == NULL)
-	  continue;
-	if (stru->kind == TYPE_LANG_STRUCT)
-	  {
-	    type_p ss;
-	    for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
-	      {
-		nbfun++;
-		DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
-			   nbfun, (void*) ss,  ss->u.s.tag);
-		write_func_for_structure (s, ss, param, wtd);
-	      }
-	  }
-	else
-	  {
-	    nbfun++;
-	    DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
-		       nbfun, (void*) s,
-		       (void*) stru,  stru->u.s.tag);
-	    write_func_for_structure (s, stru, param, wtd);
-	  }
-      }
-    else
-      { 
-	/* Param structure s is not pointed to, so should be ignored.  */
-	DBGPRINTF ("ignored s @ %p", (void*)s);
-      }
   if (verbosity_level >= 2)
     printf ("%s emitted %d routines for %s\n",
 	    progname, nbfun, wtd->comment);
@@ -4094,7 +3840,6 @@ write_types_local_user_process_field (type_p f, const struct walk_type_data *d)
     case TYPE_STRUCT:
     case TYPE_UNION:
     case TYPE_LANG_STRUCT:
-    case TYPE_PARAM_STRUCT:
     case TYPE_STRING:
       oprintf (d->of, "%*s  op (&(%s), cookie);\n", d->indent, "", d->val);
       break;
@@ -4175,7 +3920,6 @@ write_types_local_process_field (type_p f, const struct walk_type_data *d)
     case TYPE_STRUCT:
     case TYPE_UNION:
     case TYPE_LANG_STRUCT:
-    case TYPE_PARAM_STRUCT:
     case TYPE_STRING:
       oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
 	       d->prev_val[3]);
@@ -4210,7 +3954,7 @@ write_types_local_process_field (type_p f, const struct walk_type_data *d)
 */
 
 static void
-write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
+write_local_func_for_structure (const_type_p orig_s, type_p s)
 {
   struct walk_type_data d;
 
@@ -4220,12 +3964,11 @@ write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
     return;
 
   memset (&d, 0, sizeof (d));
-  d.of = get_output_file_for_structure (s, param);
+  d.of = get_output_file_for_structure (s);
   d.process_field = write_types_local_process_field;
   d.opt = s->u.s.opt;
   d.line = &s->u.s.line;
   d.bitmap = s->u.s.bitmap;
-  d.param = param;
   d.prev_val[0] = d.prev_val[2] = "*x";
   d.prev_val[1] = "not valid postage";	/* Guarantee an error.  */
   d.prev_val[3] = "x";
@@ -4276,7 +4019,7 @@ write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS.  */
 
 static void
-write_local (outf_p output_header, type_p structures, type_p param_structs)
+write_local (outf_p output_header, type_p structures)
 {
   type_p s;
 
@@ -4323,39 +4066,10 @@ write_local (outf_p output_header, type_p structures, type_p param_structs)
 	  {
 	    type_p ss;
 	    for (ss = s->u.s.lang_struct; ss; ss = ss->next)
-	      write_local_func_for_structure (s, ss, NULL);
+	      write_local_func_for_structure (s, ss);
 	  }
 	else
-	  write_local_func_for_structure (s, s, NULL);
-      }
-
-  for (s = param_structs; s; s = s->next)
-    if (s->gc_used == GC_POINTED_TO)
-      {
-	type_p *param = s->u.param_struct.param;
-	type_p stru = s->u.param_struct.stru;
-
-	/* Declare the marker procedure.  */
-	oprintf (output_header, "extern void gt_pch_p_");
-	output_mangled_typename (output_header, s);
-	oprintf (output_header,
-		 "\n    (void *, void *, gt_pointer_operator, void *);\n");
-
-	if (stru->u.s.line.file == NULL)
-	  {
-	    fprintf (stderr, "warning: structure `%s' used but not defined\n",
-		     stru->u.s.tag);
-	    continue;
-	  }
-
-	if (stru->kind == TYPE_LANG_STRUCT)
-	  {
-	    type_p ss;
-	    for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
-	      write_local_func_for_structure (s, ss, param);
-	  }
-	else
-	  write_local_func_for_structure (s, stru, param);
+	  write_local_func_for_structure (s, s);
       }
 }
 
@@ -4576,7 +4290,7 @@ start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line)
 
 static void
 write_field_root (outf_p f, pair_p v, type_p type, const char *name,
-		  int has_length, struct fileloc *line, const char *if_marked,
+		  int has_length, struct fileloc *line,
 		  bool emit_pch, type_p field_type, const char *field_name)
 {
   struct pair newv;
@@ -4596,7 +4310,7 @@ write_field_root (outf_p f, pair_p v, type_p type, const char *name,
   else if (field_type->kind == TYPE_ARRAY)
     v = NULL;
   write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)),
-	      has_length, line, if_marked, emit_pch);
+	      has_length, line, emit_pch);
 }
 
 /* Write out to F the table entry and any marker routines needed to
@@ -4611,12 +4325,11 @@ write_field_root (outf_p f, pair_p v, type_p type, const char *name,
      - the C variable that contains NAME, if NAME is not part of an array.
 
    LINE is the line of the C source that declares the root variable.
-   HAS_LENGTH is nonzero iff V was a variable-length array.  IF_MARKED
-   is nonzero iff we are building the root table for hash table caches.  */
+   HAS_LENGTH is nonzero iff V was a variable-length array.  */
 
 static void
 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
-	    struct fileloc *line, const char *if_marked, bool emit_pch)
+	    struct fileloc *line, bool emit_pch)
 {
   switch (type->kind)
     {
@@ -4635,8 +4348,6 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
 	      else if (strcmp (o->name, "desc") == 0
 		       && o->kind == OPTION_STRING)
 		desc = o->info.string;
-	      else if (strcmp (o->name, "param_is") == 0)
-		;
 	      else
 		error_at_line (line,
 			       "field `%s' of global `%s' has unknown option `%s'",
@@ -4667,8 +4378,8 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
 		    validf = ufld;
 		  }
 		if (validf != NULL)
-		  write_field_root (f, v, type, name, 0, line, if_marked,
-				    emit_pch, validf->type,
+		  write_field_root (f, v, type, name, 0, line, emit_pch,
+				    validf->type,
 				    ACONCAT ((fld->name, ".",
 					      validf->name, NULL)));
 	      }
@@ -4677,8 +4388,8 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
 			     "global `%s.%s' has `desc' option but is not union",
 			     name, fld->name);
 	    else
-	      write_field_root (f, v, type, name, 0, line, if_marked,
-				emit_pch, fld->type, fld->name);
+	      write_field_root (f, v, type, name, 0, line, emit_pch, fld->type,
+				fld->name);
 	  }
       }
       break;
@@ -4687,8 +4398,7 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
       {
 	char *newname;
 	newname = xasprintf ("%s[0]", name);
-	write_root (f, v, type->u.a.p, newname, has_length, line, if_marked,
-		    emit_pch);
+	write_root (f, v, type->u.a.p, newname, has_length, line, emit_pch);
 	free (newname);
       }
       break;
@@ -4720,18 +4430,6 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
 	    if (id_for_tag != tp->u.s.tag)
 	      free (CONST_CAST (char *, id_for_tag));
 	  }
-	else if (!has_length && tp->kind == TYPE_PARAM_STRUCT)
-	  {
-	    oprintf (f, "    &gt_ggc_m_");
-	    output_mangled_typename (f, tp);
-	    if (emit_pch)
-	      {
-		oprintf (f, ",\n    &gt_pch_n_");
-		output_mangled_typename (f, tp);
-	      }
-	    else
-	      oprintf (f, ",\n    NULL");
-	  }
 	else if (has_length
 		 && (tp->kind == TYPE_POINTER || union_or_struct_p (tp)))
 	  {
@@ -4747,8 +4445,6 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
 			   "global `%s' is pointer to unimplemented type",
 			   name);
 	  }
-	if (if_marked)
-	  oprintf (f, ",\n    &%s", if_marked);
 	oprintf (f, "\n  },\n");
       }
       break;
@@ -4771,7 +4467,6 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
     case TYPE_UNDEFINED:
     case TYPE_UNION:
     case TYPE_LANG_STRUCT:
-    case TYPE_PARAM_STRUCT:
       error_at_line (line, "global `%s' is unimplemented type", name);
     }
 }
@@ -4791,7 +4486,6 @@ write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
   d.line = &v->line;
   d.opt = v->opt;
   d.bitmap = get_lang_bitmap (v->line.file);
-  d.param = NULL;
 
   d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
 
@@ -4849,13 +4543,6 @@ write_roots (pair_p variables, bool emit_pch)
 	  length = o->info.string;
 	else if (strcmp (o->name, "deletable") == 0)
 	  deletable_p = 1;
-	else if (strcmp (o->name, "param_is") == 0)
-	  ;
-	else if (strncmp (o->name, "param", 5) == 0
-		 && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0)
-	  ;
-	else if (strcmp (o->name, "if_marked") == 0)
-	  ;
 	else if (strcmp (o->name, "cache") == 0)
 	  ;
 	else
@@ -4902,8 +4589,7 @@ write_roots (pair_p variables, bool emit_pch)
       for (o = v->opt; o; o = o->next)
 	if (strcmp (o->name, "length") == 0)
 	  length_p = 1;
-	else if (strcmp (o->name, "deletable") == 0
-		 || strcmp (o->name, "if_marked") == 0)
+	else if (strcmp (o->name, "deletable") == 0)
 	  skip_p = 1;
 
       if (skip_p)
@@ -4921,7 +4607,7 @@ write_roots (pair_p variables, bool emit_pch)
 	  oprintf (f, "[] = {\n");
 	}
 
-      write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
+      write_root (f, v, v->type, v->name, length_p, &v->line, emit_pch);
     }
 
   finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
@@ -4938,8 +4624,6 @@ write_roots (pair_p variables, bool emit_pch)
       for (o = v->opt; o; o = o->next)
 	if (strcmp (o->name, "deletable") == 0)
 	  skip_p = 0;
-	else if (strcmp (o->name, "if_marked") == 0)
-	  skip_p = 1;
 
       if (skip_p)
 	continue;
@@ -4968,52 +4652,6 @@ write_roots (pair_p variables, bool emit_pch)
       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
 							      v->line.file));
       struct flist *fli;
-      const char *if_marked = NULL;
-      int length_p = 0;
-      options_p o;
-
-      for (o = v->opt; o; o = o->next)
-	if (strcmp (o->name, "length") == 0)
-	  length_p = 1;
-	else if (strcmp (o->name, "if_marked") == 0
-		       && o->kind == OPTION_STRING)
-	  if_marked = o->info.string;
-       if (if_marked == NULL)
-	continue;
-      if (v->type->kind != TYPE_POINTER
-	  || v->type->u.p->kind != TYPE_PARAM_STRUCT
-	  || v->type->u.p->u.param_struct.stru != find_structure ("htab",
-	                                                          TYPE_STRUCT))
-	{
-	  error_at_line (&v->line,
-			 "if_marked option used but not hash table");
-	  continue;
-	}
-
-      for (fli = flp; fli; fli = fli->next)
-	if (fli->f == f)
-	  break;
-      if (!fli->started_p)
-	{
-	  fli->started_p = 1;
-
-	  oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
-	  put_mangled_filename (f, v->line.file);
-	  oprintf (f, "[] = {\n");
-	}
-
-      write_root (f, v, v->type->u.p->u.param_struct.param[0],
-		  v->name, length_p, &v->line, if_marked, emit_pch);
-    }
-
-  finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
-		     "gt_ggc_cache_rtab");
-
-  for (v = variables; v; v = v->next)
-    {
-      outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
-							      v->line.file));
-      struct flist *fli;
       bool cache = false;
       options_p o;
 
@@ -5048,48 +4686,11 @@ write_roots (pair_p variables, bool emit_pch)
       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
 							      v->line.file));
       struct flist *fli;
-      int length_p = 0;
-      int if_marked_p = 0;
-      options_p o;
-
-      for (o = v->opt; o; o = o->next)
-	if (strcmp (o->name, "length") == 0)
-	  length_p = 1;
-	else if (strcmp (o->name, "if_marked") == 0)
-	  if_marked_p = 1;
-
-      if (!if_marked_p)
-	continue;
-
-      for (fli = flp; fli; fli = fli->next)
-	if (fli->f == f)
-	  break;
-      if (!fli->started_p)
-	{
-	  fli->started_p = 1;
-
-	  oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
-	  put_mangled_filename (f, v->line.file);
-	  oprintf (f, "[] = {\n");
-	}
-
-      write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
-    }
-
-  finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
-		     "gt_pch_cache_rtab");
-
-  for (v = variables; v; v = v->next)
-    {
-      outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
-							      v->line.file));
-      struct flist *fli;
       int skip_p = 0;
       options_p o;
 
       for (o = v->opt; o; o = o->next)
-	if (strcmp (o->name, "deletable") == 0
-	    || strcmp (o->name, "if_marked") == 0)
+	if (strcmp (o->name, "deletable") == 0)
 	  {
 	    skip_p = 1;
 	    break;
@@ -5146,18 +4747,6 @@ output_typename (outf_p of, const_type_p t)
     case TYPE_LANG_STRUCT:
       oprintf (of, "%s", t->u.s.tag);
       break;
-    case TYPE_PARAM_STRUCT:
-      {
-	int i;
-	for (i = 0; i < NUM_PARAM; i++)
-	  if (t->u.param_struct.param[i] != NULL)
-	    {
-	      output_typename (of, t->u.param_struct.param[i]);
-	      oprintf (of, "_");
-	    }
-	output_typename (of, t->u.param_struct.stru);
-	break;
-      }
     case TYPE_NONE:
     case TYPE_UNDEFINED:
     case TYPE_ARRAY:
@@ -5165,40 +4754,6 @@ output_typename (outf_p of, const_type_p t)
     }
 }
 
-/* Writes a typed GC allocator for type S that is suitable as a callback for
-   the splay tree implementation in libiberty.  */
-
-static void
-write_splay_tree_allocator_def (const_type_p s)
-{
-  outf_p of = get_output_file_with_visibility (NULL);
-  oprintf (of, "void * ggc_alloc_splay_tree_");
-  output_typename (of, s);
-  oprintf (of, " (int sz, void * nl)\n");
-  oprintf (of, "{\n");
-  oprintf (of, "  return ggc_splay_alloc (sz, nl);\n");
-  oprintf (of, "}\n\n");
-}
-
-/* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
-   for the splay tree implementation in libiberty.  */
-
-static void
-write_splay_tree_allocators (const_type_p param_structs)
-{
-  const_type_p s;
-
-  oprintf (header_file, "\n/* Splay tree callback allocators.  */\n");
-  for (s = param_structs; s; s = s->next)
-    if (s->gc_used == GC_POINTED_TO)
-      {
-	oprintf (header_file, "extern void * ggc_alloc_splay_tree_");
-	output_typename (header_file, s);
-	oprintf (header_file, " (int, void *);\n");
-	write_splay_tree_allocator_def (s);
-      }
-}
-
 #define INDENT 2
 
 /* Dumps the value of typekind KIND.  */
@@ -5236,9 +4791,6 @@ dump_typekind (int indent, enum typekind kind)
     case TYPE_LANG_STRUCT:
       printf ("TYPE_LANG_STRUCT");
       break;
-    case TYPE_PARAM_STRUCT:
-      printf ("TYPE_PARAM_STRUCT");
-      break;
     default:
       gcc_unreachable ();
     }
@@ -5349,25 +4901,6 @@ dump_type_u_a (int indent, type_p t)
   dump_type_list (indent + INDENT, t->u.a.p);
 }
 
-/* Recursively dumps the parameterized struct T.  */
-
-static void
-dump_type_u_param_struct (int indent, type_p t)
-{
-  int i;
-  gcc_assert (t->kind == TYPE_PARAM_STRUCT);
-  printf ("%*cu.param_struct.stru:\n", indent, ' ');
-  dump_type_list (indent, t->u.param_struct.stru);
-  dump_fileloc (indent, t->u.param_struct.line);
-  for (i = 0; i < NUM_PARAM; i++)
-    {
-      if (t->u.param_struct.param[i] == NULL)
-	continue;
-      printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i);
-      dump_type (indent + INDENT, t->u.param_struct.param[i]);
-    }
-}
-
 /* Recursively dumps the type list T.  */
 
 static void
@@ -5428,9 +4961,6 @@ dump_type (int indent, type_p t)
     case TYPE_ARRAY:
       dump_type_u_a (indent + INDENT, t);
       break;
-    case TYPE_PARAM_STRUCT:
-      dump_type_u_param_struct (indent + INDENT, t);
-      break;
     default:
       gcc_unreachable ();
     }
@@ -5480,7 +5010,6 @@ dump_everything (void)
 {
   dump_pair_list ("typedefs", typedefs);
   dump_structures ("structures", structures);
-  dump_structures ("param_structs", param_structs);
   dump_pair_list ("variables", variables);
 
   /* Allocated with the first call to dump_type.  */
@@ -5716,7 +5245,6 @@ main (int argc, char **argv)
 	       inputlist, read_state_filename);
       read_state (read_state_filename);
       DBGPRINT_COUNT_TYPE ("structures after read_state", structures);
-      DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs);
     }
   else if (inputlist)
     {
@@ -5755,8 +5283,6 @@ main (int argc, char **argv)
 		progname, (int) num_gt_files, type_count);
 
       DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
-      DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs);
-
     }
   else
     fatal ("either an input list or a read state file should be given");
@@ -5801,8 +5327,6 @@ main (int argc, char **argv)
 
   gen_rtx_next ();
 
-  /* The call to set_gc_used may indirectly call find_param_structure
-     hence enlarge the param_structs list of types.  */
   set_gc_used (variables);
 
   for (type_p t = structures; t; t = t->next)
@@ -5816,7 +5340,7 @@ main (int argc, char **argv)
 	  }
 
       if (for_user)
-	set_gc_used_type (t, GC_POINTED_TO, NULL);
+	set_gc_used_type (t, GC_POINTED_TO);
     }
  /* The state at this point is read from the state input file or by
     parsing source files and optionally augmented by parsing plugin
@@ -5824,7 +5348,6 @@ main (int argc, char **argv)
   if (write_state_filename)
     {
       DBGPRINT_COUNT_TYPE ("structures before write_state", structures);
-      DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs);
 
       if (hit_error)
 	fatal ("didn't write state file %s after errors", 
@@ -5850,20 +5373,15 @@ main (int argc, char **argv)
   output_header = plugin_output ? plugin_output : header_file;
   DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
 		       structures);
-  DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
-		       param_structs);
 
-  write_types (output_header, structures, param_structs, &ggc_wtd);
+  write_types (output_header, structures, &ggc_wtd);
   if (plugin_files == NULL)
     {
       DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
 			   structures);
-      DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
-			   param_structs);
-      write_types (header_file, structures, param_structs, &pch_wtd);
-      write_local (header_file, structures, param_structs);
+      write_types (header_file, structures, &pch_wtd);
+      write_local (header_file, structures);
     }
-  write_splay_tree_allocators (param_structs);
   write_roots (variables, plugin_files == NULL);
   write_rtx_next ();
   close_output_files ();
diff --git a/gcc/gengtype.h b/gcc/gengtype.h
index bc3daf0671a..e4596039a01 100644
--- a/gcc/gengtype.h
+++ b/gcc/gengtype.h
@@ -124,7 +124,6 @@ extern struct fileloc lexer_line;
    gengtype.c & in gengtype-state.c files.  */
 extern pair_p typedefs;
 extern type_p structures;
-extern type_p param_structs;
 extern pair_p variables;
 
 /* An enum for distinguishing GGC vs PCH.  */
@@ -153,11 +152,6 @@ enum typekind {
   TYPE_LANG_STRUCT,     /* GCC front-end language specific structs.
                            Various languages may have homonymous but
                            different structs.  */
-  TYPE_PARAM_STRUCT,    /* Type for parametrized structs, e.g. hash_t
-                           hash-tables, ...  See (param_is, use_param,
-                           param1_is, param2_is,... use_param1,
-                           use_param_2,... use_params) GTY
-                           options.  */
   TYPE_USER_STRUCT	/* User defined type.  Walkers and markers for
 			   this type are assumed to be provided by the
 			   user.  */
@@ -246,20 +240,16 @@ enum gc_used_enum {
   GC_POINTED_TO
 };
 
-/* We can have at most ten type parameters in parameterized structures.  */
-#define NUM_PARAM 10
-
 /* Our type structure describes all types handled by gengtype.  */
 struct type {
   /* Discriminating kind, cannot be TYPE_NONE.  */
   enum typekind kind;
 
   /* For top-level structs or unions, the 'next' field links the
-     global list 'structures' or 'param_structs'; for lang_structs,
-     their homonymous structs are linked using this 'next' field.  The
-     homonymous list starts at the s.lang_struct field of the
-     lang_struct.  See the new_structure function for details.  This is
-     tricky!  */
+     global list 'structures'; for lang_structs, their homonymous structs are
+     linked using this 'next' field.  The homonymous list starts at the
+     s.lang_struct field of the lang_struct.  See the new_structure function
+     for details.  This is tricky!  */
   type_p next;
 
   /* State number used when writing & reading the persistent state.  A
@@ -325,14 +315,6 @@ struct type {
       const char *len;          /* The string if any giving its length.  */
     } a;
 
-    /* When TYPE_PARAM_STRUCT for (param_is, use_param, param1_is,
-       param2_is, ... use_param1, use_param_2, ... use_params) GTY
-       options.  */
-    struct {
-      type_p stru;              /* The generic GTY-ed type.  */
-      type_p param[NUM_PARAM];  /* The actual parameter types.  */
-      struct fileloc line;      /* The source location.  */
-    } param_struct;
   } u;
 };
 
@@ -376,8 +358,6 @@ type_fileloc (type_p t)
     return NULL;
   if (union_or_struct_p (t))
     return &t->u.s.line;
-  if  (t->kind == TYPE_PARAM_STRUCT)
-    return &t->u.param_struct.line;
   return NULL;
 }
 
@@ -488,7 +468,6 @@ enum gty_token
   PTR_ALIAS,
   NESTED_PTR,
   USER_GTY,
-  PARAM_IS,
   NUM,
   SCALAR,
   ID,
@@ -499,7 +478,7 @@ enum gty_token
 
   /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
      a meaningful value to be printed.  */
-  FIRST_TOKEN_WITH_VALUE = PARAM_IS
+  FIRST_TOKEN_WITH_VALUE = USER_GTY
 };
 
 
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index 06f70c2f353..b935fc6a1ab 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -45,7 +45,6 @@ static ggc_statistics *ggc_stats;
 
 struct traversal_state;
 
-static int ggc_htab_delete (void **, void *);
 static int compare_ptr_data (const void *, const void *);
 static void relocate_ptrs (void *, void *);
 static void write_pch_globals (const struct ggc_root_tab * const *tab,
@@ -53,22 +52,6 @@ static void write_pch_globals (const struct ggc_root_tab * const *tab,
 
 /* Maintain global roots that are preserved during GC.  */
 
-/* Process a slot of an htab by deleting it if it has not been marked.  */
-
-static int
-ggc_htab_delete (void **slot, void *info)
-{
-  const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
-
-  if (! (*r->marked_p) (*slot))
-    htab_clear_slot (*r->base, slot);
-  else
-    (*r->cb) (*slot);
-
-  return 1;
-}
-
-
 /* This extra vector of dynamically registered root_tab-s is used by
    ggc_mark_roots and gives the ability to dynamically add new GGC root
    tables, for instance from some plugins; this vector is on the heap
@@ -86,41 +69,6 @@ ggc_register_root_tab (const struct ggc_root_tab* rt)
     extra_root_vec.safe_push (rt);
 }
 
-/* This extra vector of dynamically registered cache_tab-s is used by
-   ggc_mark_roots and gives the ability to dynamically add new GGC cache
-   tables, for instance from some plugins; this vector is on the heap
-   since it is used by GGC internally.  */
-typedef const struct ggc_cache_tab *const_ggc_cache_tab_t;
-static vec<const_ggc_cache_tab_t> extra_cache_vec;
-
-/* Dynamically register a new GGC cache table CT. This is useful for
-   plugins. */
-
-void
-ggc_register_cache_tab (const struct ggc_cache_tab* ct)
-{
-  if (ct)
-    extra_cache_vec.safe_push (ct);
-}
-
-/* Scan a hash table that has objects which are to be deleted if they are not
-   already marked.  */
-
-static void
-ggc_scan_cache_tab (const_ggc_cache_tab_t ctp)
-{
-  const struct ggc_cache_tab *cti;
-
-  for (cti = ctp; cti->base != NULL; cti++)
-    if (*cti->base)
-      {
-        ggc_set_mark (*cti->base);
-        htab_traverse_noresize (*cti->base, ggc_htab_delete,
-                                CONST_CAST (void *, (const void *)cti));
-        ggc_set_mark ((*cti->base)->entries);
-      }
-}
-
 /* Mark all the roots in the table RT.  */
 
 static void
@@ -140,8 +88,6 @@ ggc_mark_roots (void)
 {
   const struct ggc_root_tab *const *rt;
   const_ggc_root_tab_t rtp, rti;
-  const struct ggc_cache_tab *const *ct;
-  const_ggc_cache_tab_t ctp;
   size_t i;
 
   for (rt = gt_ggc_deletable_rtab; *rt; rt++)
@@ -157,16 +103,8 @@ ggc_mark_roots (void)
   if (ggc_protect_identifiers)
     ggc_mark_stringpool ();
 
-  /* Now scan all hash tables that have objects which are to be deleted if
-     they are not already marked.  */
-  for (ct = gt_ggc_cache_rtab; *ct; ct++)
-    ggc_scan_cache_tab (*ct);
-
   gt_clear_caches ();
 
-  FOR_EACH_VEC_ELT (extra_cache_vec, i, ctp)
-    ggc_scan_cache_tab (ctp);
-
   if (! ggc_protect_identifiers)
     ggc_purge_stringpool ();
 
@@ -503,11 +441,6 @@ gt_pch_save (FILE *f)
       for (i = 0; i < rti->nelt; i++)
 	(*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 
-  for (rt = gt_pch_cache_rtab; *rt; rt++)
-    for (rti = *rt; rti->base != NULL; rti++)
-      for (i = 0; i < rti->nelt; i++)
-	(*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
-
   /* Prepare the objects for writing, determine addresses and such.  */
   state.f = f;
   state.d = init_ggc_pch ();
@@ -543,7 +476,6 @@ gt_pch_save (FILE *f)
 
   /* Write out all the global pointers, after translation.  */
   write_pch_globals (gt_ggc_rtab, &state);
-  write_pch_globals (gt_pch_cache_rtab, &state);
 
   /* Pad the PCH file so that the mmapped area starts on an allocation
      granularity (usually page) boundary.  */
@@ -693,13 +625,6 @@ gt_pch_restore (FILE *f)
 		   sizeof (void *), 1, f) != 1)
 	  fatal_error ("can%'t read PCH file: %m");
 
-  for (rt = gt_pch_cache_rtab; *rt; rt++)
-    for (rti = *rt; rti->base != NULL; rti++)
-      for (i = 0; i < rti->nelt; i++)
-	if (fread ((char *)rti->base + rti->stride * i,
-		   sizeof (void *), 1, f) != 1)
-	  fatal_error ("can%'t read PCH file: %m");
-
   if (fread (&mmi, sizeof (mmi), 1, f) != 1)
     fatal_error ("can%'t read PCH file: %m");
 
diff --git a/gcc/ggc.h b/gcc/ggc.h
index fb8ce733a8b..2389f94498c 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -73,23 +73,8 @@ struct ggc_root_tab {
 /* Pointers to arrays of ggc_root_tab, terminated by NULL.  */
 extern const struct ggc_root_tab * const gt_ggc_rtab[];
 extern const struct ggc_root_tab * const gt_ggc_deletable_rtab[];
-extern const struct ggc_root_tab * const gt_pch_cache_rtab[];
 extern const struct ggc_root_tab * const gt_pch_scalar_rtab[];
 
-/* Structure for hash table cache marking.  */
-struct htab;
-struct ggc_cache_tab {
-  struct htab * *base;
-  size_t nelt;
-  size_t stride;
-  gt_pointer_walker cb;
-  gt_pointer_walker pchw;
-  int (*marked_p) (const void *);
-};
-#define LAST_GGC_CACHE_TAB { NULL, 0, 0, NULL, NULL, NULL }
-/* Pointers to arrays of ggc_cache_tab, terminated by NULL.  */
-extern const struct ggc_cache_tab * const gt_ggc_cache_rtab[];
-
 /* If EXPR is not NULL and previously unmarked, mark it and evaluate
    to true.  Otherwise evaluate to false.  */
 #define ggc_test_and_set_mark(EXPR) \
@@ -251,27 +236,6 @@ ggc_alloc_atomic (size_t s CXX_MEM_STAT_INFO)
     return ggc_internal_alloc (s PASS_MEM_STAT);
 }
 
-extern void *ggc_cleared_alloc_htab_ignore_args (size_t, size_t)
-  ATTRIBUTE_MALLOC;
-
-extern void *ggc_cleared_alloc_ptr_array_two_args (size_t, size_t)
-  ATTRIBUTE_MALLOC;
-
-#define htab_create_ggc(SIZE, HASH, EQ, DEL) \
-  htab_create_typed_alloc (SIZE, HASH, EQ, DEL,	\
-			   ggc_cleared_alloc_htab_ignore_args,		\
-			   ggc_cleared_alloc_ptr_array_two_args,	\
-			   ggc_free)
-
-#define splay_tree_new_ggc(COMPARE, ALLOC_TREE, ALLOC_NODE)		     \
-  splay_tree_new_typed_alloc (COMPARE, NULL, NULL, &ALLOC_TREE, &ALLOC_NODE, \
-			      &ggc_splay_dont_free, NULL)
-
-extern void *ggc_splay_alloc (int, void *)
-  ATTRIBUTE_MALLOC;
-
-extern void ggc_splay_dont_free (void *, void *);
-
 /* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
    If LENGTH is -1, then CONTENTS is assumed to be a
    null-terminated string and the memory sized accordingly.  */
@@ -292,10 +256,6 @@ extern void ggc_grow (void);
    plugins.  Does nothing if the passed pointer is NULL. */
 extern void ggc_register_root_tab (const struct ggc_root_tab *);
 
-/* Register an additional cache table.  This can be useful for some
-   plugins.  Does nothing if the passed pointer is NULL. */
-extern void ggc_register_cache_tab (const struct ggc_cache_tab *);
-
 /* Read objects previously saved with gt_pch_save from F.  */
 extern void gt_pch_restore (FILE *f);
 
diff --git a/gcc/plugin.c b/gcc/plugin.c
index 8debc09cada..5482f7915be 100644
--- a/gcc/plugin.c
+++ b/gcc/plugin.c
@@ -420,10 +420,6 @@ register_callback (const char *plugin_name,
 	gcc_assert (!callback);
         ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
 	break;
-      case PLUGIN_REGISTER_GGC_CACHES:
-	gcc_assert (!callback);
-        ggc_register_cache_tab ((const struct ggc_cache_tab*) user_data);
-	break;
       case PLUGIN_EVENT_FIRST_DYNAMIC:
       default:
 	if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
@@ -546,7 +542,6 @@ invoke_plugin_callbacks_full (int event, void *gcc_data)
 
       case PLUGIN_PASS_MANAGER_SETUP:
       case PLUGIN_REGISTER_GGC_ROOTS:
-      case PLUGIN_REGISTER_GGC_CACHES:
         gcc_assert (false);
     }
 
diff --git a/gcc/plugin.def b/gcc/plugin.def
index df5d383ca93..cbda3ad3f1a 100644
--- a/gcc/plugin.def
+++ b/gcc/plugin.def
@@ -51,9 +51,6 @@ DEFEVENT (PLUGIN_GGC_END)
 /* Register an extra GGC root table. */
 DEFEVENT (PLUGIN_REGISTER_GGC_ROOTS)
 
-/* Register an extra GGC cache table. */
-DEFEVENT (PLUGIN_REGISTER_GGC_CACHES)
-
 /* Called during attribute registration.  */
 DEFEVENT (PLUGIN_ATTRIBUTES)
 
diff --git a/include/ChangeLog b/include/ChangeLog
index 632420c7699..f264b27501f 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,7 @@
+2014-12-09  Trevor Saunders  <tsaunders@mozilla.com>
+
+	* hashtab.h, splay-tree.h: Remove GTY markers.
+
 2014-12-08  Mark Wielaard  <mjw@redhat.com>
 
 	PR debug/60782
diff --git a/include/hashtab.h b/include/hashtab.h
index 4bb65d6c7a2..188b8494db2 100644
--- a/include/hashtab.h
+++ b/include/hashtab.h
@@ -39,10 +39,6 @@ extern "C" {
 
 #include "ansidecl.h"
 
-#ifndef GTY
-#define GTY(X)
-#endif
-
 /* The type for a hash code.  */
 typedef unsigned int hashval_t;
 
@@ -97,7 +93,7 @@ typedef void (*htab_free_with_arg) (void *, void *);
    functions mentioned below.  The size of this structure is subject to
    change.  */
 
-struct GTY(()) htab {
+struct htab {
   /* Pointer to hash function.  */
   htab_hash hash_f;
 
@@ -108,7 +104,7 @@ struct GTY(()) htab {
   htab_del del_f;
 
   /* Table itself.  */
-  void ** GTY ((use_param, length ("%h.size"))) entries;
+  void **entries;
 
   /* Current size (in entries) of the hash table.  */
   size_t size;
@@ -132,7 +128,7 @@ struct GTY(()) htab {
   htab_free free_f;
 
   /* Alternate allocate/free functions, which take an extra argument.  */
-  void * GTY((skip)) alloc_arg;
+  void *alloc_arg;
   htab_alloc_with_arg alloc_with_arg_f;
   htab_free_with_arg free_with_arg_f;
 
diff --git a/include/splay-tree.h b/include/splay-tree.h
index a26135a099d..ec48a1fa5b8 100644
--- a/include/splay-tree.h
+++ b/include/splay-tree.h
@@ -44,10 +44,6 @@ extern "C" {
 #include <inttypes.h>
 #endif
 
-#ifndef GTY
-#define GTY(X)
-#endif
-
 /* Use typedefs for the key and data types to facilitate changing
    these types, if necessary.  These types should be sufficiently wide
    that any pointer or scalar can be cast to these types, and then
@@ -86,22 +82,22 @@ typedef void *(*splay_tree_allocate_fn) (int, void *);
 typedef void (*splay_tree_deallocate_fn) (void *, void *);
 
 /* The nodes in the splay tree.  */
-struct GTY(()) splay_tree_node_s {
+struct splay_tree_node_s {
   /* The key.  */
-  splay_tree_key GTY ((use_param1)) key;
+  splay_tree_key key;
 
   /* The value.  */
-  splay_tree_value GTY ((use_param2)) value;
+  splay_tree_value value;
 
   /* The left and right children, respectively.  */
-  splay_tree_node GTY ((use_params)) left;
-  splay_tree_node GTY ((use_params)) right;
+  splay_tree_node left;
+  splay_tree_node right;
 };
 
 /* The splay tree itself.  */
-struct GTY(()) splay_tree_s {
+struct splay_tree_s {
   /* The root of the tree.  */
-  splay_tree_node GTY ((use_params)) root;
+  splay_tree_node root;
 
   /* The comparision function.  */
   splay_tree_compare_fn comp;
@@ -119,7 +115,7 @@ struct GTY(()) splay_tree_s {
   splay_tree_deallocate_fn deallocate;
 
   /* Parameter for allocate/free functions.  */
-  void * GTY((skip)) allocate_data;
+  void *allocate_data;
 };
 
 typedef struct splay_tree_s *splay_tree;