diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c
index 0fa8964..e125883 100644
--- a/gcc/java/boehm.c
+++ b/gcc/java/boehm.c
@@ -233,6 +233,6 @@ uses_jv_markobj_p (tree dtable)
      this function is only used with flag_reduced_reflection.  No
      point in asserting unless we hit the bad case.  */
   gcc_assert (!flag_reduced_reflection || TARGET_VTABLE_USES_DESCRIPTORS == 0);
-  v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3).value;
+  v = (*CONSTRUCTOR_ELTS (dtable))[3].value;
   return (PROCEDURE_OBJECT_DESCRIPTOR == TREE_INT_CST_LOW (v));
 }
diff --git a/gcc/java/class.c b/gcc/java/class.c
index a89b831..7465a9b 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -40,7 +40,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc.  */
 #include "ggc.h"
 #include "cgraph.h"
 #include "tree-iterator.h"
-#include "vecprim.h"
 #include "target.h"
 
 static tree make_method_value (tree);
@@ -98,7 +97,7 @@ static GTY(()) tree class_roots[4];
 #define class_list class_roots[2]
 #define class_dtable_decl class_roots[3]
 
-static GTY(()) VEC(tree,gc) *registered_class;
+static GTY(()) vec<tree, va_gc> *registered_class;
 
 /* A tree that returns the address of the class$ of the class
    currently being compiled.  */
@@ -106,7 +105,7 @@ static GTY(()) tree this_classdollar;
 
 /* A list of static class fields.  This is to emit proper debug
    info for them.  */
-VEC(tree,gc) *pending_static_fields;
+vec<tree, va_gc> *pending_static_fields;
 
 /* Return the node that most closely represents the class whose name
    is IDENT.  Start the search from NODE (followed by its siblings).
@@ -878,7 +877,7 @@ add_field (tree klass, tree name, tree field_type, int flags)
 	 object file.  */
       DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2);
       if (!DECL_EXTERNAL (field))
-	VEC_safe_push (tree, gc, pending_static_fields, field);
+	vec_safe_push (pending_static_fields, field);
     }
 
   return field;
@@ -941,7 +940,7 @@ build_utf8_ref (tree name)
   int name_hash;
   tree ref = IDENTIFIER_UTF8_REF (name);
   tree decl;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   if (ref != NULL_TREE)
     return ref;
 
@@ -1422,7 +1421,7 @@ make_field_value (tree fdecl)
   int flags;
   tree type = TREE_TYPE (fdecl);
   int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
 
   START_RECORD_CONSTRUCTOR (v, field_type_node);
   PUSH_FIELD_VALUE (v, "name", build_utf8_ref (DECL_NAME (fdecl)));
@@ -1480,7 +1479,7 @@ make_method_value (tree mdecl)
   tree class_decl;
 #define ACC_TRANSLATED          0x4000
   int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
 
   class_decl = DECL_CONTEXT (mdecl);
   /* For interfaces, the index field contains the dispatch index. */
@@ -1520,29 +1519,29 @@ make_method_value (tree mdecl)
     /* Compute the `throws' information for the method.  */
     tree table = null_pointer_node;
 
-    if (!VEC_empty (tree, DECL_FUNCTION_THROWS (mdecl)))
+    if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl)))
       {
-	int length = 1 + VEC_length (tree, DECL_FUNCTION_THROWS (mdecl));
+	int length = 1 + DECL_FUNCTION_THROWS (mdecl)->length ();
 	tree t, type, array;
 	char buf[60];
-	VEC(constructor_elt,gc) *v = NULL;
+	vec<constructor_elt, va_gc> *v = NULL;
 	int idx = length - 1;
 	unsigned ix;
 	constructor_elt *e;
 
-	v = VEC_alloc (constructor_elt, gc, length);
-	VEC_safe_grow_cleared (constructor_elt, gc, v, length);
+	vec_alloc (v, length);
+	v->quick_grow_cleared (length);
 
-	e = &VEC_index (constructor_elt, v, idx--);
+	e = &(*v)[idx--];
 	e->value = null_pointer_node;
 
-	FOR_EACH_VEC_ELT (tree, DECL_FUNCTION_THROWS (mdecl), ix, t)
+	FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl), ix, t)
 	  {
 	    tree sig = DECL_NAME (TYPE_NAME (t));
 	    tree utf8
 	      = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
-						    IDENTIFIER_LENGTH (sig)));
-	    e = &VEC_index (constructor_elt, v, idx--);
+		    IDENTIFIER_LENGTH (sig)));
+	    e = &(*v)[idx--];
 	    e->value = utf8;
 	  }
 	gcc_assert (idx == -1);
@@ -1611,7 +1610,7 @@ get_dispatch_table (tree type, tree this_class_addr)
   int nvirtuals = TREE_VEC_LENGTH (vtable);
   int arraysize;
   tree gc_descr;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   constructor_elt *e;
   tree arraytype;
 
@@ -1620,8 +1619,8 @@ get_dispatch_table (tree type, tree this_class_addr)
     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
   arraysize += 2;
 
-  VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize);
-  e = &VEC_index (constructor_elt, v, arraysize - 1);
+  vec_safe_grow_cleared (v, arraysize);
+  e = &(*v)[arraysize - 1];
 
 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
   for (i = nvirtuals;  --i >= 0; )
@@ -1674,7 +1673,7 @@ get_dispatch_table (tree type, tree this_class_addr)
   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
   CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
-  gcc_assert (e == VEC_address (constructor_elt, v));
+  gcc_assert (e == v->address ());
   e->index = integer_zero_node;
   e->value = null_pointer_node;
 #undef CONSTRUCTOR_PREPEND_VALUE
@@ -1737,8 +1736,8 @@ supers_all_compiled (tree type)
 }
 
 static void
-add_table_and_syms (VEC(constructor_elt,gc) **v,
-                    VEC(method_entry,gc) *methods,
+add_table_and_syms (vec<constructor_elt, va_gc> **v,
+                    vec<method_entry, va_gc> *methods,
                     const char *table_name, tree table_slot, tree table_type,
                     const char *syms_name, tree syms_slot)
 {
@@ -1785,13 +1784,13 @@ make_class_data (tree type)
   /** Offset from start of virtual function table declaration
       to where objects actually point at, following new g++ ABI. */
   tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
-  VEC(int, heap) *field_indexes;
+  vec<int> field_indexes;
   tree first_real_field;
-  VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL;
+  vec<constructor_elt, va_gc> *v1 = NULL, *v2 = NULL;
   tree reflection_data;
-  VEC(constructor_elt,gc) *static_fields = NULL;
-  VEC(constructor_elt,gc) *instance_fields = NULL;
-  VEC(constructor_elt,gc) *methods = NULL;
+  vec<constructor_elt, va_gc> *static_fields = NULL;
+  vec<constructor_elt, va_gc> *instance_fields = NULL;
+  vec<constructor_elt, va_gc> *methods = NULL;
 
   this_class_addr = build_static_class_ref (type);
   decl = TREE_OPERAND (this_class_addr, 0);
@@ -1850,7 +1849,7 @@ make_class_data (tree type)
 	}
     }
   field_count = static_field_count + instance_field_count;
-  field_indexes = VEC_alloc (int, heap, field_count);
+  field_indexes.create (field_count);
   
   /* gcj sorts fields so that static fields come first, followed by
      instance fields.  Unfortunately, by the time this takes place we
@@ -1879,7 +1878,7 @@ make_class_data (tree type)
 	    field_index = instance_count++;
 	  else
 	    continue;
-	  VEC_quick_push (int, field_indexes, field_index);
+	  field_indexes.quick_push (field_index);
 	}
     }
   }
@@ -1912,14 +1911,12 @@ make_class_data (tree type)
 	}
     }
 
-  gcc_assert (static_field_count
-              == (int) VEC_length (constructor_elt, static_fields));
-  gcc_assert (instance_field_count
-              == (int) VEC_length (constructor_elt, instance_fields));
+  gcc_assert (static_field_count == (int) vec_safe_length (static_fields));
+  gcc_assert (instance_field_count == (int) vec_safe_length (instance_fields));
 
   if (field_count > 0)
     {
-      VEC_safe_splice (constructor_elt, gc, static_fields, instance_fields);
+      vec_safe_splice (static_fields, instance_fields);
       field_array_type = build_prim_array_type (field_type_node, field_count);
       fields_decl = build_decl (input_location,
 				VAR_DECL, mangled_classname ("_FL_", type),
@@ -2021,8 +2018,8 @@ make_class_data (tree type)
     {
       int i;
       tree interface_array_type, idecl;
-      VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc,
-						 interface_len);
+      vec<constructor_elt, va_gc> *init;
+      vec_alloc (init, interface_len);
       interface_array_type
 	= build_prim_array_type (class_ptr_type, interface_len);
       idecl = build_decl (input_location,
@@ -2143,7 +2140,7 @@ make_class_data (tree type)
                       "itable_syms", TYPE_ITABLE_SYMS_DECL (type));
  
   PUSH_FIELD_VALUE (v2, "catch_classes",
-		    build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type))); 
+		    build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
   PUSH_FIELD_VALUE (v2, "interfaces", interfaces);
   PUSH_FIELD_VALUE (v2, "loader", null_pointer_node);
   PUSH_FIELD_VALUE (v2, "interface_count",
@@ -2180,8 +2177,8 @@ make_class_data (tree type)
     {
       int i;
       int count = TYPE_REFLECTION_DATASIZE (current_class);
-      VEC (constructor_elt, gc) *v
-	= VEC_alloc (constructor_elt, gc, count);
+      vec<constructor_elt, va_gc> *v;
+      vec_alloc (v, count);
       unsigned char *data = TYPE_REFLECTION_DATA (current_class);
       tree max_index = build_int_cst (sizetype, count);
       tree index = build_index_type (max_index);
@@ -2194,14 +2191,14 @@ make_class_data (tree type)
       array = build_decl (input_location,
 			  VAR_DECL, get_identifier (buf), type);
 
-      rewrite_reflection_indexes (field_indexes);
+      rewrite_reflection_indexes (&field_indexes);
 
       for (i = 0; i < count; i++)
 	{
 	  constructor_elt elt;
  	  elt.index = build_int_cst (sizetype, i);
 	  elt.value = build_int_cstu (byte_type_node, data[i]);
-	  VEC_quick_push (constructor_elt, v, elt);
+	  v->quick_push (elt);
 	}
 
       DECL_INITIAL (array) = build_constructor (type, v);
@@ -2727,13 +2724,13 @@ register_class (void)
   tree node;
 
   if (!registered_class)
-    registered_class = VEC_alloc (tree, gc, 8);
+    vec_alloc (registered_class, 8);
 
   if (flag_indirect_classes)
     node = current_class;
   else
     node = TREE_OPERAND (build_class_ref (current_class), 0);
-  VEC_safe_push (tree, gc, registered_class, node);
+  vec_safe_push (registered_class, node);
 }
 
 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
@@ -2745,15 +2742,16 @@ emit_indirect_register_classes (tree *list_p)
   tree klass, t, register_class_fn;
   int i;
 
-  int size = VEC_length (tree, registered_class) * 2 + 1;
-  VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size);
+  int size = vec_safe_length (registered_class) * 2 + 1;
+  vec<constructor_elt, va_gc> *init;
+  vec_alloc (init, size);
   tree class_array_type
     = build_prim_array_type (ptr_type_node, size);
   tree cdecl = build_decl (input_location,
 			   VAR_DECL, get_identifier ("_Jv_CLS"),
 			   class_array_type);
   tree reg_class_list;
-  FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+  FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
     {
       t = fold_convert (ptr_type_node, build_static_class_ref (klass));
       CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
@@ -2792,10 +2790,11 @@ emit_register_classes_in_jcr_section (void)
 #ifdef JCR_SECTION_NAME
   tree klass, cdecl, class_array_type;
   int i;
-  int size = VEC_length (tree, registered_class);
-  VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size);
+  int size = vec_safe_length (registered_class);
+  vec<constructor_elt, va_gc> *init;
+  vec_alloc (init, size);
 
-  FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+  FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
     CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, build_fold_addr_expr (klass));
 
   /* ??? I would like to use tree_output_constant_def() but there is no way
@@ -2844,7 +2843,7 @@ emit_Jv_RegisterClass_calls (tree *list_p)
   DECL_EXTERNAL (t) = 1;
   register_class_fn = t;
 
-  FOR_EACH_VEC_ELT (tree, registered_class, i, klass)
+  FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
     {
       t = build_fold_addr_expr (klass);
       t = build_call_expr (register_class_fn, 1, t);
@@ -2890,7 +2889,7 @@ static tree
 build_symbol_table_entry (tree clname, tree name, tree signature)
 {
   tree symbol;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
 
   START_RECORD_CONSTRUCTOR (v, symbol_type);
   PUSH_FIELD_VALUE (v, "clname", clname);
@@ -2935,22 +2934,22 @@ build_symbol_entry (tree decl, tree special)
 
 tree
 emit_symbol_table (tree name, tree the_table,
-		   VEC(method_entry,gc) *decl_table,
+		   vec<method_entry, va_gc> *decl_table,
                    tree the_syms_decl, tree the_array_element_type,
 		   int element_size)
 {
   tree table, null_symbol, table_size, the_array_type;
   unsigned index;
   method_entry *e;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   
   /* Only emit a table if this translation unit actually made any
      references via it. */
-  if (decl_table == NULL)
+  if (!decl_table)
     return the_table;
 
   /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
-  FOR_EACH_VEC_ELT (method_entry, decl_table, index, e)
+  FOR_EACH_VEC_ELT (*decl_table, index, e)
     CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
 			    build_symbol_entry (e->method, e->special));
 
@@ -2990,7 +2989,7 @@ make_catch_class_record (tree catch_class, tree classname)
 {
   tree entry;
   tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   START_RECORD_CONSTRUCTOR (v, type);
   PUSH_FIELD_VALUE (v, "address", catch_class);
   PUSH_FIELD_VALUE (v, "classname", classname);
@@ -3008,13 +3007,12 @@ emit_catch_table (tree this_class)
   int n_catch_classes;
   constructor_elt *e;
   /* Fill in the dummy entry that make_class created.  */
-  e = &VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0);
+  e = &(*TYPE_CATCH_CLASSES (this_class))[0];
   e->value = make_catch_class_record (null_pointer_node, null_pointer_node);
   CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE,
 			  make_catch_class_record (null_pointer_node,
 						   null_pointer_node));
-  n_catch_classes = VEC_length (constructor_elt,
-				TYPE_CATCH_CLASSES (this_class));
+  n_catch_classes = TYPE_CATCH_CLASSES (this_class)->length ();
   table_size = build_index_type (build_int_cst (NULL_TREE, n_catch_classes));
   array_type 
     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
@@ -3052,7 +3050,7 @@ build_signature_for_libgcj (tree type)
 static tree
 build_assertion_table_entry (tree code, tree op1, tree op2)
 {
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   tree entry;
 
   START_RECORD_CONSTRUCTOR (v, assertion_entry_type);
@@ -3072,7 +3070,8 @@ add_assertion_table_entry (void **htab_entry, void *ptr)
 {
   tree entry;
   tree code_val, op1_utf8, op2_utf8;
-  VEC(constructor_elt,gc) **v = (VEC(constructor_elt,gc) **) ptr;
+  vec<constructor_elt, va_gc> **v
+      = ((vec<constructor_elt, va_gc> **) ptr);
   type_assertion *as = (type_assertion *) *htab_entry;
 
   code_val = build_int_cst (NULL_TREE, as->assertion_code);
@@ -3100,7 +3099,7 @@ emit_assertion_table (tree klass)
 {
   tree null_entry, ctor, table_decl;
   htab_t assertions_htab = TYPE_ASSERTIONS (klass);
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
 
   /* Iterate through the hash table.  */
   htab_traverse (assertions_htab, add_assertion_table_entry, &v);
@@ -3266,11 +3265,11 @@ in_same_package (tree name1, tree name2)
 void
 java_write_globals (void)
 {
-  tree *vec = VEC_address (tree, pending_static_fields);
-  int len = VEC_length (tree, pending_static_fields);
+  tree *vec = vec_safe_address (pending_static_fields);
+  int len = vec_safe_length (pending_static_fields);
   write_global_declarations ();
   emit_debug_global_declarations (vec, len);
-  VEC_free (tree, gc, pending_static_fields);
+  vec_free (pending_static_fields);
 }
 
 #include "gt-java-class.h"
diff --git a/gcc/java/constants.c b/gcc/java/constants.c
index c709fa4..653c3c2 100644
--- a/gcc/java/constants.c
+++ b/gcc/java/constants.c
@@ -502,20 +502,20 @@ build_constants_constructor (void)
   CPool *outgoing_cpool = cpool_for_class (current_class);
   tree tags_value, data_value;
   tree cons;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
   int i;
-  VEC(constructor_elt,gc) *tags = NULL;
-  VEC(constructor_elt,gc) *data = NULL;
+  vec<constructor_elt, va_gc> *tags = NULL;
+  vec<constructor_elt, va_gc> *data = NULL;
   constructor_elt *t = NULL;
   constructor_elt *d = NULL;
 
   if (outgoing_cpool->count > 0)
     {
       int c = outgoing_cpool->count;
-      VEC_safe_grow_cleared (constructor_elt, gc, tags, c);
-      VEC_safe_grow_cleared (constructor_elt, gc, data, c);
-      t = &VEC_index (constructor_elt, tags, c-1);
-      d = &VEC_index (constructor_elt, data, c-1);
+      vec_safe_grow_cleared (tags, c);
+      vec_safe_grow_cleared (data, c);
+      t = &(*tags)[c-1];
+      d = &(*data)[c-1];
     }
 
 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
@@ -569,8 +569,8 @@ build_constants_constructor (void)
       tree tem;
 
       /* Add dummy 0'th element of constant pool. */
-      gcc_assert (t == VEC_address (constructor_elt, tags));
-      gcc_assert (d == VEC_address (constructor_elt, data));
+      gcc_assert (t == tags->address ());
+      gcc_assert (d == data->address ());
       t->value = get_tag_node (0);
       d->value = null_pointer_node;
   
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index 30048fd..c1ddd57 100644
--- a/gcc/java/decl.c
+++ b/gcc/java/decl.c
@@ -1953,7 +1953,7 @@ java_mark_class_local (tree klass)
     if (FIELD_STATIC (t))
       {
 	if (DECL_EXTERNAL (t))
-	  VEC_safe_push (tree, gc, pending_static_fields, t);
+	  vec_safe_push (pending_static_fields, t);
 	java_mark_decl_local (t);
       }
 
diff --git a/gcc/java/expr.c b/gcc/java/expr.c
index 8041cdd..0f6e465 100644
--- a/gcc/java/expr.c
+++ b/gcc/java/expr.c
@@ -74,7 +74,7 @@ static void expand_cond (enum tree_code, tree, int);
 static void expand_java_goto (int);
 static tree expand_java_switch (tree, int);
 static void expand_java_add_case (tree, int, int);
-static VEC(tree,gc) *pop_arguments (tree); 
+static vec<tree, va_gc> *pop_arguments (tree); 
 static void expand_invoke (int, int, int); 
 static void expand_java_field_op (int, int, int); 
 static void java_push_constant_from_pool (struct JCF *, int); 
@@ -96,7 +96,7 @@ tree dtable_ident = NULL_TREE;
 int always_initialize_class_p = 0;
 
 /* We store the stack state in two places:
-   Within a basic block, we use the quick_stack, which is a VEC of expression
+   Within a basic block, we use the quick_stack, which is a vec of expression
    nodes.
    This is the top part of the stack;  below that we use find_stack_slot.
    At the end of a basic block, the quick_stack must be flushed
@@ -122,7 +122,7 @@ int always_initialize_class_p = 0;
    So dup cannot just add an extra element to the quick_stack, but iadd can.
 */
 
-static GTY(()) VEC(tree,gc) *quick_stack;
+static GTY(()) vec<tree, va_gc> *quick_stack;
 
 /* The physical memory page size used in this computer.  See
    build_field_ref().  */
@@ -222,10 +222,10 @@ flush_quick_stack (void)
   tree t;
 
   /* Count the number of slots the quick stack is holding.  */
-  for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++)
+  for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++)
     stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (t));
 
-  for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++)
+  for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++)
     {
       tree decl, type = TREE_TYPE (t);
 
@@ -235,7 +235,7 @@ flush_quick_stack (void)
       stack_index += 1 + TYPE_IS_WIDE (type);
     }
 
-  VEC_truncate (tree, quick_stack, 0);
+  vec_safe_truncate (quick_stack, 0);
 }
 
 /* Push TYPE on the type stack.
@@ -276,7 +276,7 @@ push_value (tree value)
       value = convert (type, value);
     }
   push_type (type);
-  VEC_safe_push (tree, gc, quick_stack, value);
+  vec_safe_push (quick_stack, value);
 
   /* If the value has a side effect, then we need to evaluate it
      whether or not the result is used.  If the value ends up on the
@@ -590,8 +590,8 @@ static tree
 pop_value (tree type)
 {
   type = pop_type (type);
-  if (VEC_length (tree, quick_stack) != 0)
-    return VEC_pop (tree, quick_stack);
+  if (vec_safe_length (quick_stack) != 0)
+    return quick_stack->pop ();
   else
     return find_stack_slot (stack_pointer, promote_type (type));
 }
@@ -1100,17 +1100,17 @@ static void
 expand_java_multianewarray (tree class_type, int ndim)
 {
   int i;
-  VEC(tree,gc) *args = NULL;
+  vec<tree, va_gc> *args = NULL;
 
-  VEC_safe_grow (tree, gc, args, 3 + ndim);
+  vec_safe_grow (args, 3 + ndim);
 
-  VEC_replace (tree, args, 0, build_class_ref (class_type));
-  VEC_replace (tree, args, 1, build_int_cst (NULL_TREE, ndim));
+  (*args)[0] = build_class_ref (class_type);
+  (*args)[1] = build_int_cst (NULL_TREE, ndim);
 
   for(i = ndim - 1; i >= 0; i-- )
-    VEC_replace (tree, args, (unsigned)(2 + i), pop_value (int_type_node));
+    (*args)[(unsigned)(2 + i)] = pop_value (int_type_node);
 
-  VEC_replace (tree, args, 2 + ndim, null_pointer_node);
+  (*args)[2 + ndim] = null_pointer_node;
 
   push_value (build_call_vec (promote_type (class_type),
                               build_address_of (soft_multianewarray_node),
@@ -1808,7 +1808,7 @@ char *instruction_bits;
    indexed by PC.  Each element is a tree vector holding the type
    state at that PC.  We only note type states at basic block
    boundaries.  */
-VEC(tree, gc) *type_states;
+vec<tree, va_gc> *type_states;
 
 static void
 note_label (int current_pc ATTRIBUTE_UNUSED, int target_pc)
@@ -1901,12 +1901,12 @@ expand_java_add_case (tree switch_expr, int match, int target_pc)
   append_to_statement_list (x, &SWITCH_BODY (switch_expr));
 }
 
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
 pop_arguments (tree method_type)
 {
   function_args_iterator fnai;
   tree type;
-  VEC(tree,gc) *args = NULL;
+  vec<tree, va_gc> *args = NULL;
   int arity;
 
   FOREACH_FUNCTION_ARGS (method_type, type, fnai)
@@ -1915,14 +1915,14 @@ pop_arguments (tree method_type)
       if (type == void_type_node)
         break;
 
-      VEC_safe_push (tree, gc, args, type);
+      vec_safe_push (args, type);
     }
 
-  arity = VEC_length (tree, args);
+  arity = vec_safe_length (args);
 
   while (arity--)
     {
-      tree arg = pop_value (VEC_index (tree, args, arity));
+      tree arg = pop_value ((*args)[arity]);
 
       /* We simply cast each argument to its proper type.  This is
 	 needed since we lose type information coming out of the
@@ -1935,7 +1935,7 @@ pop_arguments (tree method_type)
 	       && INTEGRAL_TYPE_P (type))
 	arg = convert (integer_type_node, arg);
 
-      VEC_replace (tree, args, arity, arg);
+      (*args)[arity] = arg;
     }
 
   return args;
@@ -2063,14 +2063,14 @@ typedef struct
   const char *new_classname;
   const char *new_signature;
   int flags;
-  void (*rewrite_arglist) (VEC(tree,gc) **);
+  void (*rewrite_arglist) (vec<tree, va_gc> **);
 } rewrite_rule;
 
 /* Add __builtin_return_address(0) to the end of an arglist.  */
 
 
 static void
-rewrite_arglist_getcaller (VEC(tree,gc) **arglist)
+rewrite_arglist_getcaller (vec<tree, va_gc> **arglist)
 {
   tree retaddr 
     = build_call_expr (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS),
@@ -2078,15 +2078,15 @@ rewrite_arglist_getcaller (VEC(tree,gc) **arglist)
 
   DECL_UNINLINABLE (current_function_decl) = 1;
 
-  VEC_safe_push (tree, gc, *arglist, retaddr);
+  vec_safe_push (*arglist, retaddr);
 }
 
 /* Add this.class to the end of an arglist.  */
 
 static void
-rewrite_arglist_getclass (VEC(tree,gc) **arglist)
+rewrite_arglist_getclass (vec<tree, va_gc> **arglist)
 {
-  VEC_safe_push (tree, gc, *arglist, build_class_ref (output_class));
+  vec_safe_push (*arglist, build_class_ref (output_class));
 }
 
 static rewrite_rule rules[] =
@@ -2137,7 +2137,7 @@ special_method_p (tree candidate_method)
    method, update SPECIAL.*/
 
 void
-maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p, 
+maybe_rewrite_invocation (tree *method_p, vec<tree, va_gc> **arg_list_p, 
 			  tree *method_signature_p, tree *special)
 {
   tree context = DECL_NAME (TYPE_NAME (DECL_CONTEXT (*method_p)));
@@ -2185,7 +2185,7 @@ maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p,
 tree
 build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
 			tree self_type, tree method_signature ATTRIBUTE_UNUSED,
-			VEC(tree,gc) *arg_list ATTRIBUTE_UNUSED, tree special)
+			vec<tree, va_gc> *arg_list ATTRIBUTE_UNUSED, tree special)
 {
   tree func;
   if (is_compiled_class (self_type))
@@ -2261,12 +2261,12 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
 }
 
 tree
-invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list)
+invoke_build_dtable (int is_invoke_interface, vec<tree, va_gc> *arg_list)
 {
   tree dtable, objectref;
-  tree saved = save_expr (VEC_index (tree, arg_list, 0));
+  tree saved = save_expr ((*arg_list)[0]);
 
-  VEC_replace (tree, arg_list, 0, saved);
+  (*arg_list)[0] = saved;
 
   /* If we're dealing with interfaces and if the objectref
      argument is an array then get the dispatch table of the class
@@ -2292,17 +2292,17 @@ invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list)
 
 int
 get_symbol_table_index (tree t, tree special,
-			VEC(method_entry,gc) **symbol_table)
+			vec<method_entry, va_gc> **symbol_table)
 {
   method_entry *e;
   unsigned i;
   method_entry elem = {t, special};
 
-  FOR_EACH_VEC_ELT (method_entry, *symbol_table, i, e)
+  FOR_EACH_VEC_SAFE_ELT (*symbol_table, i, e)
     if (t == e->method && special == e->special)
       goto done;
 
-  VEC_safe_push (method_entry, gc, *symbol_table, elem);
+  vec_safe_push (*symbol_table, elem);
 
  done:
   return i + 1;
@@ -2428,7 +2428,7 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
   const char *const self_name
     = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
   tree call, func, method, method_type;
-  VEC(tree,gc) *arg_list;
+  vec<tree, va_gc> *arg_list;
   tree check = NULL_TREE;
 
   tree special = NULL_TREE;
@@ -2569,8 +2569,8 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
 	 We do omit the check if we're calling <init>.  */
       /* We use a SAVE_EXPR here to make sure we only evaluate
 	 the new `self' expression once.  */
-      tree save_arg = save_expr (VEC_index (tree, arg_list, 0));
-      VEC_replace (tree, arg_list, 0, save_arg);
+      tree save_arg = save_expr ((*arg_list)[0]);
+      (*arg_list)[0] = save_arg;
       check = java_check_reference (save_arg, ! DECL_INIT_P (method));
       func = build_known_method_ref (method, method_type, self_type,
 				     method_signature, arg_list, special);
@@ -2622,7 +2622,7 @@ build_jni_stub (tree method)
   tree method_args;
   tree meth_var;
   tree bind;
-  VEC(tree,gc) *args = NULL;
+  vec<tree, va_gc> *args = NULL;
   int args_size = 0;
 
   tree klass = DECL_CONTEXT (method);
@@ -2657,7 +2657,7 @@ build_jni_stub (tree method)
 
   /* The JNIEnv structure is the first argument to the JNI function.  */
   args_size += int_size_in_bytes (TREE_TYPE (env_var));
-  VEC_safe_push (tree, gc, args, env_var);
+  vec_safe_push (args, env_var);
 
   /* For a static method the second argument is the class.  For a
      non-static method the second argument is `this'; that is already
@@ -2665,7 +2665,7 @@ build_jni_stub (tree method)
   if (METHOD_STATIC (method))
     {
       args_size += int_size_in_bytes (TREE_TYPE (klass));
-      VEC_safe_push (tree, gc, args, klass);
+      vec_safe_push (args, klass);
     }
 
   /* All the arguments to this method become arguments to the
@@ -2680,7 +2680,7 @@ build_jni_stub (tree method)
 #endif
       args_size += (arg_bits / BITS_PER_UNIT);
 
-      VEC_safe_push (tree, gc, args, tem);
+      vec_safe_push (args, tem);
     }
   arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
 
@@ -2967,7 +2967,7 @@ static void
 load_type_state (int pc)
 {
   int i;
-  tree vec = VEC_index (tree, type_states, pc);
+  tree vec = (*type_states)[pc];
   int cur_length = TREE_VEC_LENGTH (vec);
   stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
   for (i = 0; i < cur_length; i++)
@@ -3010,8 +3010,8 @@ note_instructions (JCF *jcf, tree method)
   byte_ops = jcf->read_ptr;
   instruction_bits = XRESIZEVAR (char, instruction_bits, length + 1);
   memset (instruction_bits, 0, length + 1);
-  type_states = VEC_alloc (tree, gc, length + 1);
-  VEC_safe_grow_cleared (tree, gc, type_states, length + 1);
+  vec_alloc (type_states, length + 1);
+  type_states->quick_grow_cleared (length + 1);
 
   /* This pass figures out which PC can be the targets of jumps. */
   for (PC = 0; PC < length;)
diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h
index 5167b9b..11b780b 100644
--- a/gcc/java/java-tree.h
+++ b/gcc/java/java-tree.h
@@ -724,7 +724,7 @@ struct GTY(()) lang_decl_func {
   int max_stack;
   int arg_slot_count;
   source_location last_line;	/* End line number for a function decl */
-  VEC(tree,gc) *throws_list;	/* Exception specified by `throws' */
+  vec<tree, va_gc> *throws_list;	/* Exception specified by `throws' */
   tree exc_obj;			/* Decl holding the exception object.  */
 
   /* Class initialization test variables  */
@@ -869,8 +869,6 @@ typedef struct GTY(()) method_entry_d {
   tree special;
 } method_entry;
 
-DEF_VEC_O(method_entry);
-DEF_VEC_ALLOC_O(method_entry,gc);
 
 /* FIXME: the variable_size annotation here is needed because these types are
    variable-sized in some other frontends.  Due to gengtype deficiency the GTY
@@ -882,24 +880,24 @@ struct GTY((variable_size)) lang_type {
   tree cpool_data_ref;		/* Cached */
   tree package_list;		/* List of package names, progressive */
 
-  VEC(method_entry,gc) *otable_methods; /* List of static decls referred
+  vec<method_entry, va_gc> *otable_methods; /* List of static decls referred
 					   to by this class.  */
   tree otable_decl;		/* The static address table.  */
   tree otable_syms_decl;
 
-  VEC(method_entry,gc) *atable_methods; /* List of abstract methods
+  vec<method_entry, va_gc> *atable_methods; /* List of abstract methods
 					   referred to by this class.  */
   tree atable_decl;		/* The static address table.  */
   tree atable_syms_decl;
 
-  VEC(method_entry,gc) *itable_methods; /* List of interface methods
+  vec<method_entry, va_gc> *itable_methods; /* List of interface methods
 					   referred to by this class.  */
   tree itable_decl;		/* The interfaces table.  */
   tree itable_syms_decl;
 
   tree ctable_decl;             /* The table of classes for the runtime
 				   type matcher.  */
-  VEC(constructor_elt,gc) *catch_classes;
+  vec<constructor_elt, va_gc> *catch_classes;
 
   htab_t GTY ((param_is (struct treetreehash_entry))) type_to_runtime_map;   
                                 /* The mapping of classes to exception region
@@ -1016,14 +1014,16 @@ extern void initialize_builtins (void);
 
 extern tree lookup_name (tree);
 extern bool special_method_p (tree);
-extern void maybe_rewrite_invocation (tree *, VEC(tree,gc) **, tree *, tree *);
-extern tree build_known_method_ref (tree, tree, tree, tree, VEC(tree,gc) *, tree);
+extern void maybe_rewrite_invocation (tree *, vec<tree, va_gc> **, tree *,
+				      tree *);
+extern tree build_known_method_ref (tree, tree, tree, tree, vec<tree, va_gc> *,
+				    tree);
 extern tree build_class_init (tree, tree);
 extern int attach_init_test_initialization_flags (void **, void *);
 extern tree build_invokevirtual (tree, tree, tree);
 extern tree build_invokeinterface (tree, tree);
 extern tree build_jni_stub (tree);
-extern tree invoke_build_dtable (int, VEC(tree,gc) *);
+extern tree invoke_build_dtable (int, vec<tree, va_gc> *);
 extern tree build_field_ref (tree, tree, tree);
 extern tree java_modify_addr_for_volatile (tree);
 extern void pushdecl_force_head (tree);
@@ -1062,7 +1062,7 @@ extern void make_class_data (tree);
 extern int alloc_name_constant (int, tree);
 extern int alloc_constant_fieldref (tree, tree);
 extern void emit_register_classes (tree *);
-extern tree emit_symbol_table (tree, tree, VEC(method_entry,gc) *,
+extern tree emit_symbol_table (tree, tree, vec<method_entry, va_gc> *,
 			       tree, tree, int);
 extern void lang_init_source (int);
 extern void write_classfile (tree);
@@ -1165,7 +1165,7 @@ extern void register_exception_range(struct eh_range *, int, int);
 extern void finish_method (tree);
 extern void java_expand_body (tree);
 
-extern int get_symbol_table_index (tree, tree, VEC(method_entry,gc) **);
+extern int get_symbol_table_index (tree, tree, vec<method_entry, va_gc> **);
 
 extern tree make_catch_class_record (tree, tree);
 extern tree emit_catch_table (tree);
@@ -1180,7 +1180,7 @@ extern void rewrite_reflection_indexes (void *);
 
 int cxx_keyword_p (const char *name, int length);
 
-extern GTY(()) VEC(tree,gc) *pending_static_fields;
+extern GTY(()) vec<tree, va_gc> *pending_static_fields;
 
 extern void java_write_globals (void);   
 
@@ -1268,7 +1268,7 @@ extern void java_write_globals (void);
 #define CLASS_COMPLETE_P(DECL) DECL_LANG_FLAG_2 (DECL) 
 
 /* A vector used to track type states for the current method.  */
-extern VEC(tree, gc) *type_states;
+extern vec<tree, va_gc> *type_states;
 
 /* This maps a bytecode offset (PC) to various flags,
    listed below (starting with BCODE_). */
@@ -1419,7 +1419,7 @@ extern tree *type_map;
 #define START_RECORD_CONSTRUCTOR(V, CTYPE) \
   do \
     { \
-      V = VEC_alloc (constructor_elt, gc, 0); \
+      vec_alloc (V, 0); \
       CONSTRUCTOR_APPEND_ELT (V, TYPE_FIELDS (CTYPE), NULL); \
     } \
   while (0)
@@ -1430,7 +1430,7 @@ extern tree *type_map;
 #define PUSH_SUPER_VALUE(V, VALUE) \
   do \
     { \
-      constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \
+      constructor_elt *_elt___ = &(V)->last (); \
       tree _next___ = DECL_CHAIN (_elt___->index); \
       gcc_assert (!DECL_NAME (_elt___->index)); \
       _elt___->value = VALUE; \
@@ -1444,7 +1444,7 @@ extern tree *type_map;
 #define PUSH_FIELD_VALUE(V, NAME, VALUE) 				\
   do \
     { \
-      constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \
+      constructor_elt *_elt___ = &(V)->last (); \
       tree _next___ = DECL_CHAIN (_elt___->index); \
       gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \
 			  NAME) == 0); \
@@ -1457,7 +1457,7 @@ extern tree *type_map;
 #define FINISH_RECORD_CONSTRUCTOR(CONS, V, CTYPE)        \
   do \
     { \
-      VEC_pop (constructor_elt, V); \
+      V->pop (); \
       CONS = build_constructor (CTYPE, V); \
       TREE_CONSTANT (CONS) = 0; \
     } \
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 92f032cb..c97b12f 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -39,7 +39,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc.  */
 #include "ggc.h"
 #include "debug.h"
 #include "cgraph.h"
-#include "vecprim.h"
 #include "bitmap.h"
 #include "target.h"
 
@@ -86,7 +85,7 @@ static location_t file_start_location;
 static GTY(()) struct JCF * main_jcf;
 
 /* A list of all the class DECLs seen so far.  */
-static GTY(()) VEC(tree,gc) *all_class_list;
+static GTY(()) vec<tree, va_gc> *all_class_list;
 
 /* The number of source files passed to us by -fsource-filename and an
    array of pointers to each name.  Used by find_sourcefile().  */
@@ -744,7 +743,7 @@ rewrite_reflection_indexes (void *arg)
 {
   bitmap_iterator bi;
   unsigned int offset;
-  VEC(int, heap) *map = (VEC(int, heap) *) arg;
+  vec<int> *map = (vec<int> *) arg;
   unsigned char *data = TYPE_REFLECTION_DATA (current_class);
 
   if (map)
@@ -753,7 +752,7 @@ rewrite_reflection_indexes (void *arg)
 	{
 	  uint16 index = annotation_read_short (data + offset);
 	  annotation_rewrite_short 
-	    (VEC_index (int, map, index), data + offset);
+	    ((*map)[index], data + offset);
 	}
     }
 }
@@ -933,12 +932,13 @@ handle_signature_attribute (int member_index, JCF *jcf,
 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
 { \
   int n = COUNT; \
-  VEC (tree,gc) *v = VEC_alloc (tree, gc, n); \
-  gcc_assert (DECL_FUNCTION_THROWS (current_method) == NULL); \
+  vec<tree, va_gc> *v; \
+  vec_alloc (v, n); \
+  gcc_assert (!DECL_FUNCTION_THROWS (current_method)); \
   while (--n >= 0) \
     { \
       tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
-      VEC_quick_push (tree, v, thrown_class); \
+      v->quick_push (thrown_class); \
     } \
   DECL_FUNCTION_THROWS (current_method) = v; \
 }
@@ -1480,7 +1480,7 @@ jcf_parse (JCF* jcf)
   if (current_class == object_type_node)
     layout_class_methods (object_type_node);
   else
-    VEC_safe_push (tree, gc, all_class_list, TYPE_NAME (current_class));
+    vec_safe_push (all_class_list, TYPE_NAME (current_class));
 }
 
 /* If we came across inner classes, load them now. */
@@ -1512,7 +1512,7 @@ static void
 java_layout_seen_class_methods (void)
 {
   unsigned start = 0;
-  unsigned end = VEC_length (tree, all_class_list);
+  unsigned end = vec_safe_length (all_class_list);
 
   while (1)
     {
@@ -1521,7 +1521,7 @@ java_layout_seen_class_methods (void)
 
       for (ix = start; ix != end; ix++)
         {
-	  tree decl = VEC_index (tree, all_class_list, ix);
+	  tree decl = (*all_class_list)[ix];
           tree cls = TREE_TYPE (decl);
 
 	  input_location = DECL_SOURCE_LOCATION (decl);
@@ -1534,7 +1534,7 @@ java_layout_seen_class_methods (void)
 
       /* Note that new classes might have been added while laying out
          methods, changing the value of all_class_list.  */
-      new_length = VEC_length (tree, all_class_list);
+      new_length = vec_safe_length (all_class_list);
       if (end != new_length)
 	{
 	  start = end;
@@ -1665,12 +1665,12 @@ parse_class_file (void)
   input_location = save_location;
 }
 
-static VEC(tree,gc) *predefined_filenames;
+static vec<tree, va_gc> *predefined_filenames;
 
 void
 add_predefined_file (tree name)
 {
-  VEC_safe_push (tree, gc, predefined_filenames, name);
+  vec_safe_push (predefined_filenames, name);
 }
 
 int
@@ -1679,7 +1679,7 @@ predefined_filename_p (tree node)
   unsigned ix;
   tree f;
 
-  FOR_EACH_VEC_ELT (tree, predefined_filenames, ix, f)
+  FOR_EACH_VEC_SAFE_ELT (predefined_filenames, ix, f)
     if (f == node)
       return 1;
 
@@ -1853,18 +1853,17 @@ java_parse_file (void)
       const char *resource_filename;
       
       /* Only one resource file may be compiled at a time.  */
-      gcc_assert (VEC_length (tree, all_translation_units) == 1);
+      gcc_assert (all_translation_units->length () == 1);
 
       resource_filename
-	= IDENTIFIER_POINTER
-	    (DECL_NAME (VEC_index (tree, all_translation_units, 0)));
+	= IDENTIFIER_POINTER (DECL_NAME ((*all_translation_units)[0]));
       compile_resource_file (resource_name, resource_filename);
 
       goto finish;
     }
 
   current_jcf = main_jcf;
-  FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node)
+  FOR_EACH_VEC_ELT (*all_translation_units, ix, node)
     {
       unsigned char magic_string[4];
       char *real_path;
@@ -1951,7 +1950,7 @@ java_parse_file (void)
 	}
     }
 
-  FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node)
+  FOR_EACH_VEC_ELT (*all_translation_units, ix, node)
     {
       input_location = DECL_SOURCE_LOCATION (node);
       if (CLASS_FILE_P (node))
diff --git a/gcc/java/resource.c b/gcc/java/resource.c
index 1558dcd..52e99c4 100644
--- a/gcc/java/resource.c
+++ b/gcc/java/resource.c
@@ -37,13 +37,13 @@ The Free Software Foundation is independent of Sun Microsystems, Inc.  */
 #include "cgraph.h"
 
 /* A list of all the resources files.  */
-static GTY(()) VEC(tree,gc) *resources;
+static GTY(()) vec<tree, va_gc> *resources;
 
 void
 compile_resource_data (const char *name, const char *buffer, int length)
 {
   tree rtype, field = NULL_TREE, data_type, rinit, data, decl;
-  VEC(constructor_elt,gc) *v = NULL;
+  vec<constructor_elt, va_gc> *v = NULL;
 
   data_type = build_prim_array_type (unsigned_byte_type_node,
 				     strlen (name) + length);
@@ -80,7 +80,7 @@ compile_resource_data (const char *name, const char *buffer, int length)
   rest_of_decl_compilation (decl, global_bindings_p (), 0);
   varpool_finalize_decl (decl);
 
-  VEC_safe_push (tree, gc, resources, decl);
+  vec_safe_push (resources, decl);
 }
 
 void
@@ -100,7 +100,7 @@ write_resource_constructor (tree *list_p)
   register_resource_fn = t;
 
   /* Write out entries in the same order in which they were defined.  */
-  FOR_EACH_VEC_ELT (tree, resources, ix, decl)
+  FOR_EACH_VEC_ELT (*resources, ix, decl)
     {
       t = build_fold_addr_expr (decl);
       t = build_call_expr (register_resource_fn, 1, t);
diff --git a/gcc/java/verify-glue.c b/gcc/java/verify-glue.c
index c9eee07..86cd289 100644
--- a/gcc/java/verify-glue.c
+++ b/gcc/java/verify-glue.c
@@ -394,7 +394,7 @@ void
 vfy_note_stack_depth (vfy_method *method, int pc, int depth)
 {
   tree val = make_tree_vec (method->max_locals + depth);
-  VEC_replace (tree, type_states, pc, val);
+  (*type_states)[pc] = val;
   /* Called for side effects.  */
   lookup_label (pc);
 }
@@ -409,7 +409,7 @@ vfy_note_stack_type (vfy_method *method, int pc, int slot, vfy_jclass type)
   if (type == object_type_node)
     type = object_ptr_type_node;
 
-  vec = VEC_index (tree, type_states, pc);
+  vec = (*type_states)[pc];
   TREE_VEC_ELT (vec, slot) = type;
   /* Called for side effects.  */
   lookup_label (pc);
@@ -424,7 +424,7 @@ vfy_note_local_type (vfy_method *method ATTRIBUTE_UNUSED, int pc, int slot,
   if (type == object_type_node)
     type = object_ptr_type_node;
 
-  vec = VEC_index (tree, type_states, pc);
+  vec = (*type_states)[pc];
   TREE_VEC_ELT (vec, slot) = type;
   /* Called for side effects.  */
   lookup_label (pc);
