diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 7828d21..fac7190 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -1839,7 +1839,7 @@ strict_aliasing_warning (tree otype, tree type, tree expr)
 
 void
 sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
-				  VEC(tree, gc) *params, tree *sizeof_arg,
+				  vec<tree, va_gc> *params, tree *sizeof_arg,
 				  bool (*comp_types) (tree, tree))
 {
   tree type, dest = NULL_TREE, src = NULL_TREE, tem;
@@ -1849,7 +1849,7 @@ sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
 
   if (TREE_CODE (callee) != FUNCTION_DECL
       || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
-      || VEC_length (tree, params) <= 1)
+      || vec_safe_length (params) <= 1)
     return;
 
   switch (DECL_FUNCTION_CODE (callee))
@@ -1870,55 +1870,55 @@ sizeof_pointer_memaccess_warning (location_t *sizeof_arg_loc, tree callee,
     case BUILT_IN_MEMCPY_CHK:
     case BUILT_IN_MEMMOVE:
     case BUILT_IN_MEMMOVE_CHK:
-      if (VEC_length (tree, params) < 3)
+      if (params->length () < 3)
 	return;
-      src = VEC_index (tree, params, 1);
-      dest = VEC_index (tree, params, 0);
+      src = (*params)[1];
+      dest = (*params)[0];
       idx = 2;
       break;
     case BUILT_IN_BCOPY:
-      if (VEC_length (tree, params) < 3)
+      if (params->length () < 3)
 	return;
-      src = VEC_index (tree, params, 0);
-      dest = VEC_index (tree, params, 1);
+      src = (*params)[0];
+      dest = (*params)[1];
       idx = 2;
       break;
     case BUILT_IN_MEMCMP:
     case BUILT_IN_BCMP:
-      if (VEC_length (tree, params) < 3)
+      if (params->length () < 3)
 	return;
-      src = VEC_index (tree, params, 1);
-      dest = VEC_index (tree, params, 0);
+      src = (*params)[1];
+      dest = (*params)[0];
       idx = 2;
       cmp = true;
       break;
     case BUILT_IN_MEMSET:
     case BUILT_IN_MEMSET_CHK:
-      if (VEC_length (tree, params) < 3)
+      if (params->length () < 3)
 	return;
-      dest = VEC_index (tree, params, 0);
+      dest = (*params)[0];
       idx = 2;
       break;
     case BUILT_IN_BZERO:
-      dest = VEC_index (tree, params, 0);
+      dest = (*params)[0];
       idx = 1;
       break;
     case BUILT_IN_STRNDUP:
-      src = VEC_index (tree, params, 0);
+      src = (*params)[0];
       strop = true;
       idx = 1;
       break;
     case BUILT_IN_MEMCHR:
-      if (VEC_length (tree, params) < 3)
+      if (params->length () < 3)
 	return;
-      src = VEC_index (tree, params, 0);
+      src = (*params)[0];
       idx = 2;
       break;
     case BUILT_IN_SNPRINTF:
     case BUILT_IN_SNPRINTF_CHK:
     case BUILT_IN_VSNPRINTF:
     case BUILT_IN_VSNPRINTF_CHK:
-      dest = VEC_index (tree, params, 0);
+      dest = (*params)[0];
       idx = 1;
       strop = true;
       break;
@@ -8729,9 +8729,7 @@ handle_target_attribute (tree *node, tree name, tree args, int flags,
 
 /* Arguments being collected for optimization.  */
 typedef const char *const_char_p;		/* For DEF_VEC_P.  */
-DEF_VEC_P(const_char_p);
-DEF_VEC_ALLOC_P(const_char_p, gc);
-static GTY(()) VEC(const_char_p, gc) *optimize_args;
+static GTY(()) vec<const_char_p, va_gc> *optimize_args;
 
 
 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
@@ -8752,8 +8750,8 @@ parse_optimize_options (tree args, bool attr_p)
 
   /* Build up argv vector.  Just in case the string is stored away, use garbage
      collected strings.  */
-  VEC_truncate (const_char_p, optimize_args, 0);
-  VEC_safe_push (const_char_p, gc, optimize_args, NULL);
+  vec_safe_truncate (optimize_args, 0);
+  vec_safe_push (optimize_args, (const char *) NULL);
 
   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
     {
@@ -8763,7 +8761,7 @@ parse_optimize_options (tree args, bool attr_p)
 	{
 	  char buffer[20];
 	  sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
-	  VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
+	  vec_safe_push (optimize_args, ggc_strdup (buffer));
 	}
 
       else if (TREE_CODE (value) == STRING_CST)
@@ -8825,17 +8823,17 @@ parse_optimize_options (tree args, bool attr_p)
 
 	      memcpy (r, p, len2);
 	      r[len2] = '\0';
-	      VEC_safe_push (const_char_p, gc, optimize_args, q);
+	      vec_safe_push (optimize_args, (const char *) q);
 	    }
 
 	}
     }
 
-  opt_argc = VEC_length (const_char_p, optimize_args);
+  opt_argc = optimize_args->length ();
   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
 
   for (i = 1; i < opt_argc; i++)
-    opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
+    opt_argv[i] = (*optimize_args)[i];
 
   saved_flag_strict_aliasing = flag_strict_aliasing;
 
@@ -8852,7 +8850,7 @@ parse_optimize_options (tree args, bool attr_p)
   /* Don't allow changing -fstrict-aliasing.  */
   flag_strict_aliasing = saved_flag_strict_aliasing;
 
-  VEC_truncate (const_char_p, optimize_args, 0);
+  optimize_args->truncate (0);
   return ret;
 }
 
@@ -9736,9 +9734,9 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
 	}
       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
 	{
-	  VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
+	  vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
 
-	  if (VEC_empty (constructor_elt, v))
+	  if (vec_safe_is_empty (v))
 	    {
 	      if (pedantic)
 		failure = 3;
@@ -9751,15 +9749,12 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
 	      constructor_elt *ce;
 	      bool fold_p = false;
 
-	      if (VEC_index (constructor_elt, v, 0).index)
+	      if ((*v)[0].index)
 		maxindex = fold_convert_loc (input_location, sizetype,
-					     VEC_index (constructor_elt,
-							v, 0).index);
+					     (*v)[0].index);
 	      curindex = maxindex;
 
-	      for (cnt = 1;
-		   VEC_iterate (constructor_elt, v, cnt, ce);
-		   cnt++)
+	      for (cnt = 1; vec_safe_iterate (v, cnt, &ce); cnt++)
 		{
 		  bool curfold_p = false;
 		  if (ce->index)
@@ -9879,18 +9874,18 @@ builtin_type_for_size (int size, bool unsignedp)
    Returns 0 if an error is encountered.  */
 
 static int
-sync_resolve_size (tree function, VEC(tree,gc) *params)
+sync_resolve_size (tree function, vec<tree, va_gc> *params)
 {
   tree type;
   int size;
 
-  if (VEC_empty (tree, params))
+  if (!params)
     {
       error ("too few arguments to function %qE", function);
       return 0;
     }
 
-  type = TREE_TYPE (VEC_index (tree, params, 0));
+  type = TREE_TYPE ((*params)[0]);
   if (TREE_CODE (type) != POINTER_TYPE)
     goto incompatible;
 
@@ -9914,7 +9909,7 @@ sync_resolve_size (tree function, VEC(tree,gc) *params)
 
 static bool
 sync_resolve_params (location_t loc, tree orig_function, tree function,
-		     VEC(tree, gc) *params, bool orig_format)
+		     vec<tree, va_gc> *params, bool orig_format)
 {
   function_args_iterator iter;
   tree ptype;
@@ -9925,7 +9920,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
      as the pointer parameter, so we shouldn't get any complaints from the
      call to check_function_arguments what ever type the user used.  */
   function_args_iter_next (&iter);
-  ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
+  ptype = TREE_TYPE (TREE_TYPE ((*params)[0]));
 
   /* For the rest of the values, we need to cast these to FTYPE, so that we
      don't get warnings for passing pointer types, etc.  */
@@ -9940,7 +9935,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
 	break;
 
       ++parmnum;
-      if (VEC_length (tree, params) <= parmnum)
+      if (params->length () <= parmnum)
 	{
 	  error_at (loc, "too few arguments to function %qE", orig_function);
 	  return false;
@@ -9956,17 +9951,17 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
 	  /* Ideally for the first conversion we'd use convert_for_assignment
 	     so that we get warnings for anything that doesn't match the pointer
 	     type.  This isn't portable across the C and C++ front ends atm.  */
-	  val = VEC_index (tree, params, parmnum);
+	  val = (*params)[parmnum];
 	  val = convert (ptype, val);
 	  val = convert (arg_type, val);
-	  VEC_replace (tree, params, parmnum, val);
+	  (*params)[parmnum] = val;
 	}
 
       function_args_iter_next (&iter);
     }
 
   /* __atomic routines are not variadic.  */
-  if (!orig_format && VEC_length (tree, params) != parmnum + 1)
+  if (!orig_format && params->length () != parmnum + 1)
     {
       error_at (loc, "too many arguments to function %qE", orig_function);
       return false;
@@ -9976,7 +9971,7 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
      being "an optional list of variables protected by the memory barrier".
      No clue what that's supposed to mean, precisely, but we consider all
      call-clobbered variables to be protected so we're safe.  */
-  VEC_truncate (tree, params, parmnum + 1);
+  params->truncate (parmnum + 1);
 
   return true;
 }
@@ -10004,7 +9999,8 @@ sync_resolve_return (tree first_param, tree result, bool orig_format)
    0 is returned if the parameters are invalid.  */
 
 static int
-get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
+get_atomic_generic_size (location_t loc, tree function,
+			 vec<tree, va_gc> *params)
 {
   unsigned int n_param;
   unsigned int n_model;
@@ -10032,14 +10028,14 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
       gcc_unreachable ();
     }
 
-  if (VEC_length (tree, params) != n_param)
+  if (vec_safe_length (params) != n_param)
     {
       error_at (loc, "incorrect number of arguments to function %qE", function);
       return 0;
     }
 
   /* Get type of first parameter, and determine its size.  */
-  type_0 = TREE_TYPE (VEC_index (tree, params, 0));
+  type_0 = TREE_TYPE ((*params)[0]);
   if (TREE_CODE (type_0) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (type_0)))
     {
       error_at (loc, "argument 1 of %qE must be a non-void pointer type",
@@ -10071,7 +10067,7 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
   for (x = 0; x < n_param - n_model; x++)
     {
       int size;
-      tree type = TREE_TYPE (VEC_index (tree, params, x));
+      tree type = TREE_TYPE ((*params)[x]);
       /* __atomic_compare_exchange has a bool in the 4th postion, skip it.  */
       if (n_param == 6 && x == 3)
         continue;
@@ -10093,7 +10089,7 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
   /* Check memory model parameters for validity.  */
   for (x = n_param - n_model ; x < n_param; x++)
     {
-      tree p = VEC_index (tree, params, x);
+      tree p = (*params)[x];
       if (TREE_CODE (p) == INTEGER_CST)
         {
 	  int i = tree_low_cst (p, 1);
@@ -10126,30 +10122,30 @@ get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
 
 static tree
 add_atomic_size_parameter (unsigned n, location_t loc, tree function, 
-			   VEC(tree,gc) *params)
+			   vec<tree, va_gc> *params)
 {
   tree size_node;
 
   /* Insert a SIZE_T parameter as the first param.  If there isn't
      enough space, allocate a new vector and recursively re-build with that.  */
-  if (!VEC_space (tree, params, 1))
+  if (!params->space (1))
     {
       unsigned int z, len;
-      VEC(tree,gc) *vec;
+      vec<tree, va_gc> *v;
       tree f;
 
-      len = VEC_length (tree, params);
-      vec = VEC_alloc (tree, gc, len + 1);
+      len = params->length ();
+      vec_alloc (v, len + 1);
       for (z = 0; z < len; z++)
-	VEC_quick_push (tree, vec, VEC_index (tree, params, z));
-      f = build_function_call_vec (loc, function, vec, NULL);
-      VEC_free (tree, gc, vec);
+	v->quick_push ((*params)[z]);
+      f = build_function_call_vec (loc, function, v, NULL);
+      vec_free (v);
       return f;
     }
 
   /* Add the size parameter and leave as a function call for processing.  */
   size_node = build_int_cst (size_type_node, n);
-  VEC_quick_insert (tree, params, 0, size_node);
+  params->quick_insert (0, size_node);
   return NULL_TREE;
 }
 
@@ -10165,7 +10161,7 @@ add_atomic_size_parameter (unsigned n, location_t loc, tree function,
    NEW_RETURN is set to the the return value the result is copied into.  */
 static bool
 resolve_overloaded_atomic_exchange (location_t loc, tree function, 
-				    VEC(tree,gc) *params, tree *new_return)
+				    vec<tree, va_gc> *params, tree *new_return)
 {	
   tree p0, p1, p2, p3;
   tree I_type, I_type_ptr;
@@ -10190,10 +10186,10 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
      into
        *return = (T) (fn (In* mem, (In) *desired, model))  */
 
-  p0 = VEC_index (tree, params, 0);
-  p1 = VEC_index (tree, params, 1);
-  p2 = VEC_index (tree, params, 2);
-  p3 = VEC_index (tree, params, 3);
+  p0 = (*params)[0];
+  p1 = (*params)[1];
+  p2 = (*params)[2];
+  p3 = (*params)[3];
   
   /* Create pointer to appropriate size.  */
   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10201,15 +10197,15 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
 
   /* Convert object pointer to required type.  */
   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
-  VEC_replace (tree, params, 0, p0); 
+  (*params)[0] = p0; 
   /* Convert new value to required type, and dereference it.  */
   p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
   p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
-  VEC_replace (tree, params, 1, p1);
+  (*params)[1] = p1;
 
   /* Move memory model to the 3rd position, and end param list.  */
-  VEC_replace (tree, params, 2, p3);
-  VEC_truncate (tree, params, 3);
+  (*params)[2] = p3;
+  params->truncate (3);
 
   /* Convert return pointer and dereference it for later assignment.  */
   *new_return = build_indirect_ref (loc, p2, RO_UNARY_STAR);
@@ -10229,7 +10225,7 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
 
 static bool
 resolve_overloaded_atomic_compare_exchange (location_t loc, tree function, 
-					    VEC(tree,gc) *params, 
+					    vec<tree, va_gc> *params, 
 					    tree *new_return)
 {	
   tree p0, p1, p2;
@@ -10253,9 +10249,9 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
 	 there is no danger this will be done twice.  */
       if (n > 0)
         {
-	  VEC_replace (tree, params, 3, VEC_index (tree, params, 4));
-	  VEC_replace (tree, params, 4, VEC_index (tree, params, 5));
-	  VEC_truncate (tree, params, 5);
+	  (*params)[3] = (*params)[4];
+	  (*params)[4] = (*params)[5];
+	  params->truncate (5);
 	}
       *new_return = add_atomic_size_parameter (n, loc, function, params);
       return true;
@@ -10266,9 +10262,9 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
      into
        bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail)  */
 
-  p0 = VEC_index (tree, params, 0);
-  p1 = VEC_index (tree, params, 1);
-  p2 = VEC_index (tree, params, 2);
+  p0 = (*params)[0];
+  p1 = (*params)[1];
+  p2 = (*params)[2];
   
   /* Create pointer to appropriate size.  */
   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10276,16 +10272,16 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
 
   /* Convert object pointer to required type.  */
   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
-  VEC_replace (tree, params, 0, p0);
+  (*params)[0] = p0;
 
   /* Convert expected pointer to required type.  */
   p1 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p1);
-  VEC_replace (tree, params, 1, p1);
+  (*params)[1] = p1;
 
   /* Convert desired value to required type, and dereference it.  */
   p2 = build_indirect_ref (loc, p2, RO_UNARY_STAR);
   p2 = build1 (VIEW_CONVERT_EXPR, I_type, p2);
-  VEC_replace (tree, params, 2, p2);
+  (*params)[2] = p2;
 
   /* The rest of the parameters are fine. NULL means no special return value
      processing.*/
@@ -10306,7 +10302,7 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
 
 static bool
 resolve_overloaded_atomic_load (location_t loc, tree function, 
-				VEC(tree,gc) *params, tree *new_return)
+				vec<tree, va_gc> *params, tree *new_return)
 {	
   tree p0, p1, p2;
   tree I_type, I_type_ptr;
@@ -10331,9 +10327,9 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
      into
        *return = (T) (fn ((In *) mem, model))  */
 
-  p0 = VEC_index (tree, params, 0);
-  p1 = VEC_index (tree, params, 1);
-  p2 = VEC_index (tree, params, 2);
+  p0 = (*params)[0];
+  p1 = (*params)[1];
+  p2 = (*params)[2];
   
   /* Create pointer to appropriate size.  */
   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10341,11 +10337,11 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
 
   /* Convert object pointer to required type.  */
   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
-  VEC_replace (tree, params, 0, p0);
+  (*params)[0] = p0;
 
   /* Move memory model to the 2nd position, and end param list.  */
-  VEC_replace (tree, params, 1, p2);
-  VEC_truncate (tree, params, 2);
+  (*params)[1] = p2;
+  params->truncate (2);
 
   /* Convert return pointer and dereference it for later assignment.  */
   *new_return = build_indirect_ref (loc, p1, RO_UNARY_STAR);
@@ -10366,7 +10362,7 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
 
 static bool
 resolve_overloaded_atomic_store (location_t loc, tree function, 
-				 VEC(tree,gc) *params, tree *new_return)
+				 vec<tree, va_gc> *params, tree *new_return)
 {	
   tree p0, p1;
   tree I_type, I_type_ptr;
@@ -10391,8 +10387,8 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
      into
        fn ((In *) mem, (In) *value, model)  */
 
-  p0 = VEC_index (tree, params, 0);
-  p1 = VEC_index (tree, params, 1);
+  p0 = (*params)[0];
+  p1 = (*params)[1];
   
   /* Create pointer to appropriate size.  */
   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
@@ -10400,12 +10396,12 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
 
   /* Convert object pointer to required type.  */
   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
-  VEC_replace (tree, params, 0, p0);
+  (*params)[0] = p0;
 
   /* Convert new value to required type, and dereference it.  */
   p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
   p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
-  VEC_replace (tree, params, 1, p1);
+  (*params)[1] = p1;
   
   /* The memory model is in the right spot already. Return is void.  */
   *new_return = NULL_TREE;
@@ -10426,7 +10422,8 @@ resolve_overloaded_atomic_store (location_t loc, tree function,
    continue.  */
 
 tree
-resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
+resolve_overloaded_builtin (location_t loc, tree function,
+			    vec<tree, va_gc> *params)
 {
   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
   bool orig_format = true;
@@ -10550,7 +10547,7 @@ resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
 				  orig_format))
 	  return error_mark_node;
 
-	first_param = VEC_index (tree, params, 0);
+	first_param = (*params)[0];
 	result = build_function_call_vec (loc, new_function, params, NULL);
 	if (result == error_mark_node)
 	  return result;
@@ -11097,9 +11094,9 @@ record_types_used_by_current_var_decl (tree decl)
 {
   gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
 
-  while (!VEC_empty (tree, types_used_by_cur_var_decl))
+  while (types_used_by_cur_var_decl && !types_used_by_cur_var_decl->is_empty ())
     {
-      tree type = VEC_pop (tree, types_used_by_cur_var_decl);
+      tree type = types_used_by_cur_var_decl->pop ();
       types_used_by_var_decl_insert (type, decl);
     }
 }
@@ -11121,7 +11118,7 @@ record_locally_defined_typedef (tree decl)
     return;
 
   l = (struct c_language_function *) cfun->language;
-  VEC_safe_push (tree, gc, l->local_typedefs, decl);
+  vec_safe_push (l->local_typedefs, decl);
 }
 
 /* If T is a TYPE_DECL declared locally, mark it as used.  */
@@ -11159,7 +11156,7 @@ maybe_warn_unused_local_typedefs (void)
   if (warn_unused_local_typedefs
       && errorcount == unused_local_typedefs_warn_count)
     {
-      FOR_EACH_VEC_ELT (tree, l->local_typedefs, i, decl)
+      FOR_EACH_VEC_SAFE_ELT (l->local_typedefs, i, decl)
 	if (!TREE_USED (decl))
 	  warning_at (DECL_SOURCE_LOCATION (decl),
 		      OPT_Wunused_local_typedefs,
@@ -11167,86 +11164,82 @@ maybe_warn_unused_local_typedefs (void)
       unused_local_typedefs_warn_count = errorcount;
     }
 
-  if (l->local_typedefs)
-    {
-      VEC_free (tree, gc, l->local_typedefs);
-      l->local_typedefs = NULL;
-    }
+  vec_free (l->local_typedefs);
 }
 
 /* The C and C++ parsers both use vectors to hold function arguments.
    For efficiency, we keep a cache of unused vectors.  This is the
    cache.  */
 
-typedef VEC(tree,gc)* tree_gc_vec;
-DEF_VEC_P(tree_gc_vec);
-DEF_VEC_ALLOC_P(tree_gc_vec,gc);
-static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
+typedef vec<tree, va_gc> *tree_gc_vec;
+static GTY((deletable)) vec<tree_gc_vec, va_gc> *tree_vector_cache;
 
 /* Return a new vector from the cache.  If the cache is empty,
    allocate a new vector.  These vectors are GC'ed, so it is OK if the
    pointer is not released..  */
 
-VEC(tree,gc) *
+vec<tree, va_gc> *
 make_tree_vector (void)
 {
-  if (!VEC_empty (tree_gc_vec, tree_vector_cache))
-    return VEC_pop (tree_gc_vec, tree_vector_cache);
+  if (tree_vector_cache && !tree_vector_cache->is_empty ())
+    return tree_vector_cache->pop ();
   else
     {
-      /* Passing 0 to VEC_alloc returns NULL, and our callers require
+      /* Passing 0 to vec::alloc returns NULL, and our callers require
 	 that we always return a non-NULL value.  The vector code uses
 	 4 when growing a NULL vector, so we do too.  */
-      return VEC_alloc (tree, gc, 4);
+      vec<tree, va_gc> *v;
+      vec_alloc (v, 4);
+      return v;
     }
 }
 
 /* Release a vector of trees back to the cache.  */
 
 void
-release_tree_vector (VEC(tree,gc) *vec)
+release_tree_vector (vec<tree, va_gc> *vec)
 {
   if (vec != NULL)
     {
-      VEC_truncate (tree, vec, 0);
-      VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
+      vec->truncate (0);
+      vec_safe_push (tree_vector_cache, vec);
     }
 }
 
 /* Get a new tree vector holding a single tree.  */
 
-VEC(tree,gc) *
+vec<tree, va_gc> *
 make_tree_vector_single (tree t)
 {
-  VEC(tree,gc) *ret = make_tree_vector ();
-  VEC_quick_push (tree, ret, t);
+  vec<tree, va_gc> *ret = make_tree_vector ();
+  ret->quick_push (t);
   return ret;
 }
 
 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain.  */
 
-VEC(tree,gc) *
+vec<tree, va_gc> *
 make_tree_vector_from_list (tree list)
 {
-  VEC(tree,gc) *ret = make_tree_vector ();
+  vec<tree, va_gc> *ret = make_tree_vector ();
   for (; list; list = TREE_CHAIN (list))
-    VEC_safe_push (tree, gc, ret, TREE_VALUE (list));
+    vec_safe_push (ret, TREE_VALUE (list));
   return ret;
 }
 
 /* Get a new tree vector which is a copy of an existing one.  */
 
-VEC(tree,gc) *
-make_tree_vector_copy (const VEC(tree,gc) *orig)
+vec<tree, va_gc> *
+make_tree_vector_copy (const vec<tree, va_gc> *orig)
 {
-  VEC(tree,gc) *ret;
+  vec<tree, va_gc> *ret;
   unsigned int ix;
   tree t;
 
   ret = make_tree_vector ();
-  VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
-  FOR_EACH_VEC_ELT (tree, orig, ix, t)
-    VEC_quick_push (tree, ret, t);
+  vec_safe_reserve (ret, vec_safe_length (orig));
+  FOR_EACH_VEC_SAFE_ELT (orig, ix, t)
+    ret->quick_push (t);
   return ret;
 }
 
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 5c545f2..afd8f07 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -486,7 +486,7 @@ typedef enum ref_operator {
 
 struct GTY(()) stmt_tree_s {
   /* A stack of statement lists being collected.  */
-  VEC(tree,gc) *x_cur_stmt_list;
+  vec<tree, va_gc> *x_cur_stmt_list;
 
   /* In C++, Nonzero if we should treat statements as full
      expressions.  In particular, this variable is non-zero if at the
@@ -512,20 +512,16 @@ struct GTY(()) c_language_function {
 
   /* Vector of locally defined typedefs, for
      -Wunused-local-typedefs.  */
-  VEC(tree,gc) *local_typedefs;
+  vec<tree, va_gc> *local_typedefs;
 };
 
 #define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
 
 /* When building a statement-tree, this is the current statement list
-   being collected.  We define it in this convoluted way, rather than
-   using VEC_last, because it must be an lvalue.  */
+   being collected.  */
+#define cur_stmt_list	(stmt_list_stack->last ())
 
-#define cur_stmt_list							\
-  (*(VEC_address (tree, stmt_list_stack)				\
-     + VEC_length (tree, stmt_list_stack) - 1))
-
-#define building_stmt_list_p() (!VEC_empty (tree, stmt_list_stack))
+#define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
 
 /* Language-specific hooks.  */
 
@@ -759,7 +755,7 @@ extern void constant_expression_warning (tree);
 extern void constant_expression_error (tree);
 extern bool strict_aliasing_warning (tree, tree, tree);
 extern void sizeof_pointer_memaccess_warning (location_t *, tree,
-					      VEC(tree, gc) *, tree *,
+					      vec<tree, va_gc> *, tree *,
 					      bool (*) (tree, tree));
 extern void warnings_for_convert_and_check (tree, tree, tree);
 extern tree convert_and_check (tree, tree);
@@ -899,10 +895,10 @@ extern void c_do_switch_warnings (splay_tree, location_t, tree, tree);
 
 extern tree build_function_call (location_t, tree, tree);
 
-extern tree build_function_call_vec (location_t, tree,
-    				     VEC(tree,gc) *, VEC(tree,gc) *);
+extern tree build_function_call_vec (location_t, tree, vec<tree, va_gc> *,
+				     vec<tree, va_gc> *);
 
-extern tree resolve_overloaded_builtin (location_t, tree, VEC(tree,gc) *);
+extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
 
 extern tree finish_label_address_expr (tree, location_t);
 
@@ -997,11 +993,11 @@ extern void set_underlying_type (tree);
 extern void record_locally_defined_typedef (tree);
 extern void maybe_record_typedef_use (tree);
 extern void maybe_warn_unused_local_typedefs (void);
-extern VEC(tree,gc) *make_tree_vector (void);
-extern void release_tree_vector (VEC(tree,gc) *);
-extern VEC(tree,gc) *make_tree_vector_single (tree);
-extern VEC(tree,gc) *make_tree_vector_from_list (tree);
-extern VEC(tree,gc) *make_tree_vector_copy (const VEC(tree,gc) *);
+extern vec<tree, va_gc> *make_tree_vector (void);
+extern void release_tree_vector (vec<tree, va_gc> *);
+extern vec<tree, va_gc> *make_tree_vector_single (tree);
+extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
+extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
 
 /* In c-gimplify.c  */
 extern void c_genericize (tree);
diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c
index 821c5d5..27814e1 100644
--- a/gcc/c-family/c-gimplify.c
+++ b/gcc/c-family/c-gimplify.c
@@ -108,9 +108,9 @@ add_block_to_enclosing (tree block)
   unsigned i;
   tree enclosing;
   gimple bind;
-  VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
+  vec<gimple> stack = gimple_bind_expr_stack ();
 
-  FOR_EACH_VEC_ELT (gimple, stack, i, bind)
+  FOR_EACH_VEC_ELT (stack, i, bind)
     if (gimple_bind_block (bind))
       break;
 
diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c
index 70d8748e..f04cc6f 100644
--- a/gcc/c-family/c-pragma.c
+++ b/gcc/c-family/c-pragma.c
@@ -33,7 +33,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "tm_p.h"		/* For REGISTER_TARGET_PRAGMAS (why is
 				   this not a target hook?).  */
 #include "vec.h"
-#include "vecprim.h"
 #include "target.h"
 #include "diagnostic.h"
 #include "opts.h"
@@ -241,10 +240,8 @@ typedef struct GTY(()) pending_weak_d
   tree value;
 } pending_weak;
 
-DEF_VEC_O(pending_weak);
-DEF_VEC_ALLOC_O(pending_weak,gc);
 
-static GTY(()) VEC(pending_weak,gc) *pending_weaks;
+static GTY(()) vec<pending_weak, va_gc> *pending_weaks;
 
 static void apply_pragma_weak (tree, tree);
 static void handle_pragma_weak (cpp_reader *);
@@ -294,11 +291,11 @@ maybe_apply_pragma_weak (tree decl)
 
   id = DECL_ASSEMBLER_NAME (decl);
 
-  FOR_EACH_VEC_ELT (pending_weak, pending_weaks, i, pe)
+  FOR_EACH_VEC_ELT (*pending_weaks, i, pe)
     if (id == pe->name)
       {
 	apply_pragma_weak (decl, pe->value);
-	VEC_unordered_remove (pending_weak, pending_weaks, i);
+	pending_weaks->unordered_remove (i);
 	break;
       }
 }
@@ -313,7 +310,10 @@ maybe_apply_pending_pragma_weaks (void)
   pending_weak *pe;
   symtab_node target;
 
-  FOR_EACH_VEC_ELT (pending_weak, pending_weaks, i, pe)
+  if (!pending_weaks)
+    return;
+
+  FOR_EACH_VEC_ELT (*pending_weaks, i, pe)
     {
       alias_id = pe->name;
       id = pe->value;
@@ -373,7 +373,7 @@ handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
   else
     {
       pending_weak pe = {name, value};
-      VEC_safe_push (pending_weak, gc, pending_weaks, pe);
+      vec_safe_push (pending_weaks, pe);
     }
 }
 
@@ -414,10 +414,8 @@ typedef struct GTY(()) pending_redefinition_d {
   tree newname;
 } pending_redefinition;
 
-DEF_VEC_O(pending_redefinition);
-DEF_VEC_ALLOC_O(pending_redefinition,gc);
 
-static GTY(()) VEC(pending_redefinition,gc) *pending_redefine_extname;
+static GTY(()) vec<pending_redefinition, va_gc> *pending_redefine_extname;
 
 static void handle_pragma_redefine_extname (cpp_reader *);
 
@@ -488,7 +486,7 @@ add_to_renaming_pragma_list (tree oldname, tree newname)
   unsigned ix;
   pending_redefinition *p;
 
-  FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+  FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
     if (oldname == p->oldname)
       {
 	if (p->newname != newname)
@@ -498,7 +496,7 @@ add_to_renaming_pragma_list (tree oldname, tree newname)
       }
 
   pending_redefinition e = {oldname, newname};
-  VEC_safe_push (pending_redefinition, gc, pending_redefine_extname, e);
+  vec_safe_push (pending_redefine_extname, e);
 }
 
 /* The current prefix set by #pragma extern_prefix.  */
@@ -532,7 +530,7 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
 		   "conflict with previous rename");
 
       /* Take any pending redefine_extname off the list.  */
-      FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+      FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
 	if (DECL_NAME (decl) == p->oldname)
 	  {
 	    /* Only warn if there is a conflict.  */
@@ -540,20 +538,18 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
 	      warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
 		       "conflict with previous rename");
 
-	    VEC_unordered_remove (pending_redefinition,
-				  pending_redefine_extname, ix);
+	    pending_redefine_extname->unordered_remove (ix);
 	    break;
 	  }
       return 0;
     }
 
   /* Find out if we have a pending #pragma redefine_extname.  */
-  FOR_EACH_VEC_ELT (pending_redefinition, pending_redefine_extname, ix, p)
+  FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
     if (DECL_NAME (decl) == p->oldname)
       {
 	tree newname = p->newname;
-	VEC_unordered_remove (pending_redefinition,
-			      pending_redefine_extname, ix);
+	pending_redefine_extname->unordered_remove (ix);
 
 	/* If we already have an asmname, #pragma redefine_extname is
 	   ignored (with a warning if it conflicts).  */
@@ -600,7 +596,7 @@ maybe_apply_renaming_pragma (tree decl, tree asmname)
 
 static void handle_pragma_visibility (cpp_reader *);
 
-static VEC (int, heap) *visstack;
+static vec<int> visstack;
 
 /* Push the visibility indicated by STR onto the top of the #pragma
    visibility stack.  KIND is 0 for #pragma GCC visibility, 1 for
@@ -612,8 +608,7 @@ static VEC (int, heap) *visstack;
 void
 push_visibility (const char *str, int kind)
 {
-  VEC_safe_push (int, heap, visstack,
-		 ((int) default_visibility) | (kind << 8));
+  visstack.safe_push (((int) default_visibility) | (kind << 8));
   if (!strcmp (str, "default"))
     default_visibility = VISIBILITY_DEFAULT;
   else if (!strcmp (str, "internal"))
@@ -633,14 +628,14 @@ push_visibility (const char *str, int kind)
 bool
 pop_visibility (int kind)
 {
-  if (!VEC_length (int, visstack))
+  if (!visstack.length ())
     return false;
-  if ((VEC_last (int, visstack) >> 8) != kind)
+  if ((visstack.last () >> 8) != kind)
     return false;
   default_visibility
-    = (enum symbol_visibility) (VEC_pop (int, visstack) & 0xff);
+    = (enum symbol_visibility) (visstack.pop () & 0xff);
   visibility_options.inpragma
-    = VEC_length (int, visstack) != 0;
+    = visstack.length () != 0;
   return true;
 }
 
@@ -1152,10 +1147,8 @@ handle_pragma_float_const_decimal64 (cpp_reader *ARG_UNUSED (dummy))
 }
 
 /* A vector of registered pragma callbacks, which is never freed.   */
-DEF_VEC_O (internal_pragma_handler);
-DEF_VEC_ALLOC_O (internal_pragma_handler, heap);
 
-static VEC(internal_pragma_handler, heap) *registered_pragmas;
+static vec<internal_pragma_handler> registered_pragmas;
 
 typedef struct
 {
@@ -1163,10 +1156,8 @@ typedef struct
   const char *name;
 } pragma_ns_name;
 
-DEF_VEC_O (pragma_ns_name);
-DEF_VEC_ALLOC_O (pragma_ns_name, heap);
 
-static VEC(pragma_ns_name, heap) *registered_pp_pragmas;
+static vec<pragma_ns_name> registered_pp_pragmas;
 
 struct omp_pragma_def { const char *name; unsigned int id; };
 static const struct omp_pragma_def omp_pragmas[] = {
@@ -1202,13 +1193,10 @@ c_pp_lookup_pragma (unsigned int id, const char **space, const char **name)
       }
 
   if (id >= PRAGMA_FIRST_EXTERNAL
-      && (id < PRAGMA_FIRST_EXTERNAL
-	  + VEC_length (pragma_ns_name, registered_pp_pragmas)))
+      && (id < PRAGMA_FIRST_EXTERNAL + registered_pp_pragmas.length ()))
     {
-      *space = VEC_index (pragma_ns_name, registered_pp_pragmas,
-			  id - PRAGMA_FIRST_EXTERNAL).space;
-      *name = VEC_index (pragma_ns_name, registered_pp_pragmas,
-			 id - PRAGMA_FIRST_EXTERNAL).name;
+      *space = registered_pp_pragmas[id - PRAGMA_FIRST_EXTERNAL].space;
+      *name = registered_pp_pragmas[id - PRAGMA_FIRST_EXTERNAL].name;
       return;
     }
 
@@ -1233,15 +1221,14 @@ c_register_pragma_1 (const char *space, const char *name,
 
       ns_name.space = space;
       ns_name.name = name;
-      VEC_safe_push (pragma_ns_name, heap, registered_pp_pragmas, ns_name);
-      id = VEC_length (pragma_ns_name, registered_pp_pragmas);
+      registered_pp_pragmas.safe_push (ns_name);
+      id = registered_pp_pragmas.length ();
       id += PRAGMA_FIRST_EXTERNAL - 1;
     }
   else
     {
-      VEC_safe_push (internal_pragma_handler, heap, registered_pragmas,
-                     ihandler);
-      id = VEC_length (internal_pragma_handler, registered_pragmas);
+      registered_pragmas.safe_push (ihandler);
+      id = registered_pragmas.length ();
       id += PRAGMA_FIRST_EXTERNAL - 1;
 
       /* The C++ front end allocates 6 bits in cp_token; the C front end
@@ -1331,7 +1318,7 @@ c_invoke_pragma_handler (unsigned int id)
   pragma_handler_2arg handler_2arg;
 
   id -= PRAGMA_FIRST_EXTERNAL;
-  ihandler = &VEC_index (internal_pragma_handler, registered_pragmas, id);
+  ihandler = &registered_pragmas[id];
   if (ihandler->extra_data)
     {
       handler_2arg = ihandler->handler.handler_2arg;
diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c
index edeccce..c8df1ac 100644
--- a/gcc/c-family/c-pretty-print.c
+++ b/gcc/c-family/c-pretty-print.c
@@ -1662,7 +1662,7 @@ pp_c_expression_list (c_pretty_printer *pp, tree e)
 /* Print out V, which contains the elements of a constructor.  */
 
 void
-pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
+pp_c_constructor_elts (c_pretty_printer *pp, vec<constructor_elt, va_gc> *v)
 {
   unsigned HOST_WIDE_INT ix;
   tree value;
@@ -1670,7 +1670,7 @@ pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
   FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
     {
       pp_expression (pp, value);
-      if (ix != VEC_length (constructor_elt, v) - 1)
+      if (ix != vec_safe_length (v) - 1)
 	pp_separate_with (pp, ',');
     }
 }
diff --git a/gcc/c-family/c-pretty-print.h b/gcc/c-family/c-pretty-print.h
index 2f9f94a..801663c 100644
--- a/gcc/c-family/c-pretty-print.h
+++ b/gcc/c-family/c-pretty-print.h
@@ -198,7 +198,7 @@ void pp_c_statement (c_pretty_printer *, tree);
 void pp_c_expression (c_pretty_printer *, tree);
 void pp_c_logical_or_expression (c_pretty_printer *, tree);
 void pp_c_expression_list (c_pretty_printer *, tree);
-void pp_c_constructor_elts (c_pretty_printer *, VEC(constructor_elt,gc) *);
+void pp_c_constructor_elts (c_pretty_printer *, vec<constructor_elt, va_gc> *);
 void pp_c_call_argument_list (c_pretty_printer *, tree);
 void pp_c_unary_expression (c_pretty_printer *, tree);
 void pp_c_cast_expression (c_pretty_printer *, tree);
diff --git a/gcc/c-family/c-semantics.c b/gcc/c-family/c-semantics.c
index 1a21ec1..dca7ec9 100644
--- a/gcc/c-family/c-semantics.c
+++ b/gcc/c-family/c-semantics.c
@@ -37,7 +37,7 @@ push_stmt_list (void)
 {
   tree t;
   t = alloc_stmt_list ();
-  VEC_safe_push (tree, gc, stmt_list_stack, t);
+  vec_safe_push (stmt_list_stack, t);
   return t;
 }
 
@@ -52,10 +52,10 @@ pop_stmt_list (tree t)
      nestings will be due to outstanding cleanups.  */
   while (1)
     {
-      u = VEC_pop (tree, stmt_list_stack);
-      if (!VEC_empty (tree, stmt_list_stack))
+      u = stmt_list_stack->pop ();
+      if (!stmt_list_stack->is_empty ())
 	{
-	  tree x = VEC_last (tree, stmt_list_stack);
+	  tree x = stmt_list_stack->last ();
 	  STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
 	}
       if (t == u)
diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
index f031466..b1c88bd 100644
--- a/gcc/c/c-decl.c
+++ b/gcc/c/c-decl.c
@@ -286,8 +286,6 @@ struct GTY(()) c_goto_bindings {
 };
 
 typedef struct c_goto_bindings *c_goto_bindings_p;
-DEF_VEC_P(c_goto_bindings_p);
-DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
 
 /* The additional information we keep track of for a label binding.
    These fields are updated as scopes are popped.  */
@@ -302,11 +300,11 @@ struct GTY(()) c_label_vars {
      warn if a goto branches to this label from later in the function.
      Decls are added to this list as scopes are popped.  We only add
      the decls that matter.  */
-  VEC(tree,gc) *decls_in_scope;
+  vec<tree, va_gc> *decls_in_scope;
   /* A list of goto statements to this label.  This is only used for
      goto statements seen before the label was defined, so that we can
      issue appropriate warnings for them.  */
-  VEC(c_goto_bindings_p,gc) *gotos;
+  vec<c_goto_bindings_p, va_gc> *gotos;
 };
 
 /* Each c_scope structure describes the complete contents of one
@@ -496,11 +494,9 @@ static bool keep_next_level_flag;
 
 static bool next_is_function_body;
 
-/* A VEC of pointers to c_binding structures.  */
+/* A vector of pointers to c_binding structures.  */
 
 typedef struct c_binding *c_binding_ptr;
-DEF_VEC_P(c_binding_ptr);
-DEF_VEC_ALLOC_P(c_binding_ptr,heap);
 
 /* Information that we keep for a struct or union while it is being
    parsed.  */
@@ -509,15 +505,15 @@ struct c_struct_parse_info
 {
   /* If warn_cxx_compat, a list of types defined within this
      struct.  */
-  VEC(tree,heap) *struct_types;
+  vec<tree> struct_types;
   /* If warn_cxx_compat, a list of field names which have bindings,
      and which are defined in this struct, but which are not defined
      in any enclosing struct.  This is used to clear the in_struct
      field of the c_bindings structure.  */
-  VEC(c_binding_ptr,heap) *fields;
+  vec<c_binding_ptr> fields;
   /* If warn_cxx_compat, a list of typedef names used when defining
      fields in this struct.  */
-  VEC(tree,heap) *typedefs_seen;
+  vec<tree> typedefs_seen;
 };
 
 /* Information for the struct or union currently being parsed, or
@@ -1019,16 +1015,14 @@ update_label_decls (struct c_scope *scope)
 			     of B1, if any.  Save it to issue a
 			     warning if needed.  */
 			  if (decl_jump_unsafe (b1->decl))
-			    VEC_safe_push (tree, gc,
-					   label_vars->decls_in_scope,
-					   b1->decl);
+			    vec_safe_push(label_vars->decls_in_scope, b1->decl);
 			}
 		    }
 		}
 
 	      /* Update the bindings of any goto statements associated
 		 with this label.  */
-	      FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	      FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 		update_spot_bindings (scope, &g->goto_bindings);
 	    }
 	}
@@ -1375,7 +1369,7 @@ c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
 	    continue;
 	  label_vars = b->u.label;
 	  ++label_vars->label_bindings.stmt_exprs;
-	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 	    ++g->goto_bindings.stmt_exprs;
 	}
     }
@@ -1413,7 +1407,7 @@ c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
 	      label_vars->label_bindings.left_stmt_expr = true;
 	      label_vars->label_bindings.stmt_exprs = 0;
 	    }
-	  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+	  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
 	    {
 	      --g->goto_bindings.stmt_exprs;
 	      if (g->goto_bindings.stmt_exprs < 0)
@@ -3056,7 +3050,7 @@ make_label (location_t location, tree name, bool defining,
   label_vars->shadowed = NULL;
   set_spot_bindings (&label_vars->label_bindings, defining);
   label_vars->decls_in_scope = make_tree_vector ();
-  label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
+  label_vars->gotos = NULL;
   *p_label_vars = label_vars;
 
   return label;
@@ -3153,7 +3147,7 @@ lookup_label_for_goto (location_t loc, tree name)
       g = ggc_alloc_c_goto_bindings ();
       g->loc = loc;
       set_spot_bindings (&g->goto_bindings, true);
-      VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
+      vec_safe_push (label_vars->gotos, g);
       return label;
     }
 
@@ -3165,7 +3159,7 @@ lookup_label_for_goto (location_t loc, tree name)
        ...
        goto lab;
      Issue a warning or error.  */
-  FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
+  FOR_EACH_VEC_SAFE_ELT (label_vars->decls_in_scope, ix, decl)
     warn_about_goto (loc, label, decl);
 
   if (label_vars->label_bindings.left_stmt_expr)
@@ -3217,7 +3211,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
   unsigned int ix;
   struct c_goto_bindings *g;
 
-  FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
+  FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
     {
       struct c_binding *b;
       struct c_scope *scope;
@@ -3267,7 +3261,7 @@ check_earlier_gotos (tree label, struct c_label_vars* label_vars)
 
   /* Now that the label is defined, we will issue warnings about
      subsequent gotos to this label when we see them.  */
-  VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
+  vec_safe_truncate (label_vars->gotos, 0);
   label_vars->gotos = NULL;
 }
 
@@ -3939,10 +3933,10 @@ add_flexible_array_elts_to_size (tree decl, tree init)
 {
   tree elt, type;
 
-  if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
+  if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
     return;
 
-  elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init)).value;
+  elt = CONSTRUCTOR_ELTS (init)->last ().value;
   type = TREE_TYPE (elt);
   if (TREE_CODE (type) == ARRAY_TYPE
       && TYPE_SIZE (type) == NULL_TREE
@@ -4509,15 +4503,15 @@ finish_decl (tree decl, location_t init_loc, tree init,
 	  tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
 	  tree cleanup_decl = lookup_name (cleanup_id);
 	  tree cleanup;
-	  VEC(tree,gc) *vec;
+	  vec<tree, va_gc> *v;
 
 	  /* Build "cleanup(&decl)" for the destructor.  */
 	  cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
-	  vec = VEC_alloc (tree, gc, 1);
-	  VEC_quick_push (tree, vec, cleanup);
+	  vec_alloc (v, 1);
+	  v->quick_push (cleanup);
 	  cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
-	      				     cleanup_decl, vec, NULL);
-	  VEC_free (tree, gc, vec);
+	      				     cleanup_decl, v, NULL);
+	  vec_free (v);
 
 	  /* Don't warn about decl unused; the cleanup uses it.  */
 	  TREE_USED (decl) = 1;
@@ -5656,7 +5650,7 @@ grokdeclarator (const struct c_declarator *declarator,
 	      c_arg_tag *tag;
 	      unsigned ix;
 
-	      FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+	      FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
 		TYPE_CONTEXT (tag->type) = type;
 	    }
 	    break;
@@ -6398,7 +6392,7 @@ get_parm_info (bool ellipsis, tree expr)
   struct c_arg_info *arg_info = build_arg_info ();
 
   tree parms    = 0;
-  VEC(c_arg_tag,gc) *tags = NULL;
+  vec<c_arg_tag, va_gc> *tags = NULL;
   tree types    = 0;
   tree others   = 0;
 
@@ -6523,7 +6517,7 @@ get_parm_info (bool ellipsis, tree expr)
 
 	  tag.id = b->id;
 	  tag.type = decl;
-	  VEC_safe_push (c_arg_tag, gc, tags, tag);
+	  vec_safe_push (tags, tag);
 	  break;
 
 	case CONST_DECL:
@@ -6735,9 +6729,9 @@ start_struct (location_t loc, enum tree_code code, tree name,
 
   *enclosing_struct_parse_info = struct_parse_info;
   struct_parse_info = XNEW (struct c_struct_parse_info);
-  struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
-  struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
-  struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
+  struct_parse_info->struct_types.create (0);
+  struct_parse_info->fields.create (0);
+  struct_parse_info->typedefs_seen.create (0);
 
   /* FIXME: This will issue a warning for a use of a type defined
      within a statement expr used within sizeof, et. al.  This is not
@@ -6847,8 +6841,7 @@ grokfield (location_t loc,
 	     to be cleared when this struct is finished.  */
 	  if (!b->in_struct)
 	    {
-	      VEC_safe_push (c_binding_ptr, heap,
-			     struct_parse_info->fields, b);
+	      struct_parse_info->fields.safe_push (b);
 	      b->in_struct = 1;
 	    }
 	}
@@ -7028,7 +7021,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
      because the flag is used to issue visibility warnings, and we
      only want to issue those warnings if the type is referenced
      outside of the struct declaration.  */
-  FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
+  FOR_EACH_VEC_ELT (struct_parse_info->struct_types, ix, x)
     C_TYPE_DEFINED_IN_STRUCT (x) = 1;
 
   /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
@@ -7037,14 +7030,14 @@ warn_cxx_compat_finish_struct (tree fieldlist)
      not parse in C++, because the C++ lookup rules say that the
      typedef name would be looked up in the context of the struct, and
      would thus be the field rather than the typedef.  */
-  if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
+  if (!struct_parse_info->typedefs_seen.is_empty ()
       && fieldlist != NULL_TREE)
     {
       /* Use a pointer_set using the name of the typedef.  We can use
 	 a pointer_set because identifiers are interned.  */
       struct pointer_set_t *tset = pointer_set_create ();
 
-      FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
+      FOR_EACH_VEC_ELT (struct_parse_info->typedefs_seen, ix, x)
 	pointer_set_insert (tset, DECL_NAME (x));
 
       for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
@@ -7066,7 +7059,7 @@ warn_cxx_compat_finish_struct (tree fieldlist)
 
   /* For each field which has a binding and which was not defined in
      an enclosing struct, clear the in_struct field.  */
-  FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
+  FOR_EACH_VEC_ELT (struct_parse_info->fields, ix, b)
     b->in_struct = 0;
 }
 
@@ -7353,9 +7346,9 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
   if (warn_cxx_compat)
     warn_cxx_compat_finish_struct (fieldlist);
 
-  VEC_free (tree, heap, struct_parse_info->struct_types);
-  VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
-  VEC_free (tree, heap, struct_parse_info->typedefs_seen);
+  struct_parse_info->struct_types.release ();
+  struct_parse_info->fields.release ();
+  struct_parse_info->typedefs_seen.release ();
   XDELETE (struct_parse_info);
 
   struct_parse_info = enclosing_struct_parse_info;
@@ -7365,7 +7358,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
   if (warn_cxx_compat
       && struct_parse_info != NULL
       && !in_sizeof && !in_typeof && !in_alignof)
-    VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
+    struct_parse_info->struct_types.safe_push (t);
 
   return t;
 }
@@ -7583,7 +7576,7 @@ finish_enum (tree enumtype, tree values, tree attributes)
   if (warn_cxx_compat
       && struct_parse_info != NULL
       && !in_sizeof && !in_typeof && !in_alignof)
-    VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
+    struct_parse_info->struct_types.safe_push (enumtype);
 
   return enumtype;
 }
@@ -7981,7 +7974,7 @@ store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
     }
 
   /* And all the tag declarations.  */
-  FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
+  FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
     if (tag->id)
       bind (tag->id, tag->type, current_scope,
 	    /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
@@ -8598,8 +8591,7 @@ c_push_function_context (void)
     cfun->language = p = ggc_alloc_cleared_language_function ();
 
   p->base.x_stmt_tree = c_stmt_tree;
-  c_stmt_tree.x_cur_stmt_list
-    = VEC_copy (tree, gc, c_stmt_tree.x_cur_stmt_list);
+  c_stmt_tree.x_cur_stmt_list = vec_safe_copy (c_stmt_tree.x_cur_stmt_list);
   p->x_break_label = c_break_label;
   p->x_cont_label = c_cont_label;
   p->x_switch_stack = c_switch_stack;
@@ -9538,7 +9530,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
 	  /* If we are parsing a struct, record that a struct field
 	     used a typedef.  */
 	  if (warn_cxx_compat && struct_parse_info != NULL)
-	    VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
+	    struct_parse_info->typedefs_seen.safe_push (type);
 	}
     }
   else if (TREE_CODE (type) == IDENTIFIER_NODE)
@@ -10040,7 +10032,7 @@ collect_all_refs (const char *source_file)
   tree t;
   unsigned i;
 
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
 
   collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
@@ -10056,7 +10048,7 @@ for_each_global_decl (void (*callback) (tree decl))
   tree decl;
   unsigned i;
 
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     { 
       decls = DECL_INITIAL (t);
       for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
@@ -10116,7 +10108,7 @@ c_write_global_declarations (void)
 
   /* Process all file scopes in this compilation, and the external_scope,
      through wrapup_global_declarations and check_global_declarations.  */
-  FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+  FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
   c_write_global_declarations_1 (BLOCK_VARS (ext_block));
 
@@ -10135,7 +10127,7 @@ c_write_global_declarations (void)
   if (!seen_error ())
     {
       timevar_push (TV_SYMOUT);
-      FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
+      FOR_EACH_VEC_ELT (*all_translation_units, i, t)
 	c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
       c_write_global_declarations_2 (BLOCK_VARS (ext_block));
       timevar_pop (TV_SYMOUT);
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index bfa98af..d85bff0 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -1178,9 +1178,9 @@ static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
 static tree c_parser_transaction_cancel (c_parser *);
 static struct c_expr c_parser_expression (c_parser *);
 static struct c_expr c_parser_expression_conv (c_parser *);
-static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
-					 VEC(tree,gc) **, location_t *,
-					 tree *);
+static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
+					     vec<tree, va_gc> **, location_t *,
+					     tree *);
 static void c_parser_omp_construct (c_parser *);
 static void c_parser_omp_threadprivate (c_parser *);
 static void c_parser_omp_barrier (c_parser *);
@@ -3540,7 +3540,7 @@ c_parser_attributes (c_parser *parser)
 	     || c_parser_next_token_is (parser, CPP_KEYWORD))
 	{
 	  tree attr, attr_name, attr_args;
-	  VEC(tree,gc) *expr_list;
+	  vec<tree, va_gc> *expr_list;
 	  if (c_parser_next_token_is (parser, CPP_COMMA))
 	    {
 	      c_parser_consume_token (parser);
@@ -6123,10 +6123,10 @@ c_parser_alignof_expression (c_parser *parser)
    stores the arguments in CEXPR_LIST.  */
 static bool
 c_parser_get_builtin_args (c_parser *parser, const char *bname,
-			   VEC(c_expr_t,gc) **ret_cexpr_list)
+			   vec<c_expr_t, va_gc> **ret_cexpr_list)
 {
   location_t loc = c_parser_peek_token (parser)->location;
-  VEC (c_expr_t,gc) *cexpr_list;
+  vec<c_expr_t, va_gc> *cexpr_list;
   c_expr_t expr;
 
   *ret_cexpr_list = NULL;
@@ -6145,7 +6145,7 @@ c_parser_get_builtin_args (c_parser *parser, const char *bname,
     }
 
   expr = c_parser_expr_no_commas (parser, NULL);
-  cexpr_list = VEC_alloc (c_expr_t, gc, 1);
+  vec_alloc (cexpr_list, 1);
   C_EXPR_APPEND (cexpr_list, expr);
   while (c_parser_next_token_is (parser, CPP_COMMA))
     {
@@ -6511,7 +6511,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  break;
 	case RID_CHOOSE_EXPR:
 	  {
-	    VEC (c_expr_t, gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    c_expr_t *e1_p, *e2_p, *e3_p;
 	    tree c;
 
@@ -6524,7 +6524,7 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    if (VEC_length (c_expr_t, cexpr_list) != 3)
+	    if (vec_safe_length (cexpr_list) != 3)
 	      {
 		error_at (loc, "wrong number of arguments to "
 			       "%<__builtin_choose_expr%>");
@@ -6532,9 +6532,9 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
-	    e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
-	    e3_p = &VEC_index (c_expr_t, cexpr_list, 2);
+	    e1_p = &(*cexpr_list)[0];
+	    e2_p = &(*cexpr_list)[1];
+	    e3_p = &(*cexpr_list)[2];
 
 	    c = e1_p->value;
 	    mark_exp_read (e2_p->value);
@@ -6594,7 +6594,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  break;
 	case RID_BUILTIN_COMPLEX:
 	  {
-	    VEC(c_expr_t, gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    c_expr_t *e1_p, *e2_p;
 
 	    c_parser_consume_token (parser);
@@ -6606,7 +6606,7 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    if (VEC_length (c_expr_t, cexpr_list) != 2)
+	    if (vec_safe_length (cexpr_list) != 2)
 	      {
 		error_at (loc, "wrong number of arguments to "
 			       "%<__builtin_complex%>");
@@ -6614,8 +6614,8 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
-	    e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
+	    e1_p = &(*cexpr_list)[0];
+	    e2_p = &(*cexpr_list)[1];
 
 	    mark_exp_read (e1_p->value);
 	    if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR)
@@ -6655,7 +6655,7 @@ c_parser_postfix_expression (c_parser *parser)
 	  }
 	case RID_BUILTIN_SHUFFLE:
 	  {
-	    VEC(c_expr_t,gc) *cexpr_list;
+	    vec<c_expr_t, va_gc> *cexpr_list;
 	    unsigned int i;
 	    c_expr_t *p;
 
@@ -6668,21 +6668,21 @@ c_parser_postfix_expression (c_parser *parser)
 		break;
 	      }
 
-	    FOR_EACH_VEC_ELT (c_expr_t, cexpr_list, i, p)
+	    FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
 	      mark_exp_read (p->value);
 
-	    if (VEC_length (c_expr_t, cexpr_list) == 2)
+	    if (vec_safe_length (cexpr_list) == 2)
 	      expr.value =
 		c_build_vec_perm_expr
-		  (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
-		   NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value);
+		  (loc, (*cexpr_list)[0].value,
+		   NULL_TREE, (*cexpr_list)[1].value);
 
-	    else if (VEC_length (c_expr_t, cexpr_list) == 3)
+	    else if (vec_safe_length (cexpr_list) == 3)
 	      expr.value =
 		c_build_vec_perm_expr
-		  (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
-		   VEC_index (c_expr_t, cexpr_list, 1).value,
-		   VEC_index (c_expr_t, cexpr_list, 2).value);
+		  (loc, (*cexpr_list)[0].value,
+		   (*cexpr_list)[1].value,
+		   (*cexpr_list)[2].value);
 	    else
 	      {
 		error_at (loc, "wrong number of arguments to "
@@ -6872,8 +6872,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
   location_t sizeof_arg_loc[3];
   tree sizeof_arg[3];
   unsigned int i;
-  VEC(tree,gc) *exprlist;
-  VEC(tree,gc) *origtypes;
+  vec<tree, va_gc> *exprlist;
+  vec<tree, va_gc> *origtypes;
   while (true)
     {
       location_t op_loc = c_parser_peek_token (parser)->location;
@@ -6922,7 +6922,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
 	      && DECL_FUNCTION_CODE (orig_expr.value) == BUILT_IN_CONSTANT_P)
 	    expr.original_code = C_MAYBE_CONST_EXPR;
 	  expr.original_type = NULL;
-	  if (exprlist != NULL)
+	  if (exprlist)
 	    {
 	      release_tree_vector (exprlist);
 	      release_tree_vector (origtypes);
@@ -7069,13 +7069,13 @@ c_parser_expression_conv (c_parser *parser)
      nonempty-expr-list , assignment-expression
 */
 
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
 c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
-		    VEC(tree,gc) **p_orig_types, location_t *sizeof_arg_loc,
-		    tree *sizeof_arg)
+		    vec<tree, va_gc> **p_orig_types,
+		    location_t *sizeof_arg_loc, tree *sizeof_arg)
 {
-  VEC(tree,gc) *ret;
-  VEC(tree,gc) *orig_types;
+  vec<tree, va_gc> *ret;
+  vec<tree, va_gc> *orig_types;
   struct c_expr expr;
   location_t loc = c_parser_peek_token (parser)->location;
   location_t cur_sizeof_arg_loc = UNKNOWN_LOCATION;
@@ -7095,9 +7095,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
     expr = default_function_array_read_conversion (loc, expr);
   if (fold_p)
     expr.value = c_fully_fold (expr.value, false, NULL);
-  VEC_quick_push (tree, ret, expr.value);
-  if (orig_types != NULL)
-    VEC_quick_push (tree, orig_types, expr.original_type);
+  ret->quick_push (expr.value);
+  if (orig_types)
+    orig_types->quick_push (expr.original_type);
   if (sizeof_arg != NULL
       && cur_sizeof_arg_loc != UNKNOWN_LOCATION
       && expr.original_code == SIZEOF_EXPR)
@@ -7119,9 +7119,9 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
 	expr = default_function_array_read_conversion (loc, expr);
       if (fold_p)
 	expr.value = c_fully_fold (expr.value, false, NULL);
-      VEC_safe_push (tree, gc, ret, expr.value);
-      if (orig_types != NULL)
-	VEC_safe_push (tree, gc, orig_types, expr.original_type);
+      vec_safe_push (ret, expr.value);
+      if (orig_types)
+	vec_safe_push (orig_types, expr.original_type);
       if (++idx < 3
 	  && sizeof_arg != NULL
 	  && cur_sizeof_arg_loc != UNKNOWN_LOCATION
@@ -7131,7 +7131,7 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
 	  sizeof_arg_loc[idx] = cur_sizeof_arg_loc;
 	}
     }
-  if (orig_types != NULL)
+  if (orig_types)
     *p_orig_types = orig_types;
   return ret;
 }
@@ -8209,13 +8209,13 @@ static tree
 c_parser_objc_keywordexpr (c_parser *parser)
 {
   tree ret;
-  VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true,
+  vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
 						NULL, NULL, NULL);
-  if (VEC_length (tree, expr_list) == 1)
+  if (vec_safe_length (expr_list) == 1)
     {
       /* Just return the expression, remove a level of
 	 indirection.  */
-      ret = VEC_index (tree, expr_list, 0);
+      ret = (*expr_list)[0];
     }
   else
     {
@@ -9923,7 +9923,7 @@ c_parser_omp_for_loop (location_t loc,
   bool fail = false, open_brace_parsed = false;
   int i, collapse = 1, nbraces = 0;
   location_t for_loc;
-  VEC(tree,gc) *for_block = make_tree_vector ();
+  vec<tree, va_gc> *for_block = make_tree_vector ();
 
   for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
     if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
@@ -9955,7 +9955,7 @@ c_parser_omp_for_loop (location_t loc,
       if (c_parser_next_tokens_start_declaration (parser))
 	{
 	  if (i > 0)
-	    VEC_safe_push (tree, gc, for_block, c_begin_compound_stmt (true));
+	    vec_safe_push (for_block, c_begin_compound_stmt (true));
 	  c_parser_declaration_or_fndef (parser, true, true, true, true, true, NULL);
 	  decl = check_for_loop_decls (for_loc, flag_isoc99);
 	  if (decl == NULL)
@@ -10186,12 +10186,12 @@ c_parser_omp_for_loop (location_t loc,
       ret = stmt;
     }
 pop_scopes:
-  while (!VEC_empty (tree, for_block))
+  while (!for_block->is_empty ())
     {
       /* FIXME diagnostics: LOC below should be the actual location of
 	 this particular for block.  We need to build a list of
 	 locations to go along with FOR_BLOCK.  */
-      stmt = c_end_compound_stmt (loc, VEC_pop (tree, for_block), true);
+      stmt = c_end_compound_stmt (loc, for_block->pop (), true);
       add_stmt (stmt);
     }
   release_tree_vector (for_block);
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 17fc719..531cc7c 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -135,15 +135,12 @@ struct c_expr
 typedef struct c_expr c_expr_t;
 
 /* A varray of c_expr_t.  */
-DEF_VEC_O (c_expr_t);
-DEF_VEC_ALLOC_O (c_expr_t, gc);
-DEF_VEC_ALLOC_O (c_expr_t, heap);
 
 /* Append a new c_expr_t element to V.  */
 #define C_EXPR_APPEND(V, ELEM) \
   do { \
     c_expr_t __elem = (ELEM); \
-    VEC_safe_push (c_expr_t, gc, V, __elem); \
+    vec_safe_push (V, __elem); \
   } while (0)
 
 /* A kind of type specifier.  Note that this information is currently
@@ -363,15 +360,13 @@ typedef struct c_arg_tag_d {
   tree type;
 } c_arg_tag;
 
-DEF_VEC_O(c_arg_tag);
-DEF_VEC_ALLOC_O(c_arg_tag,gc);
 
 /* Information about the parameters in a function declarator.  */
 struct c_arg_info {
   /* A list of parameter decls.  */
   tree parms;
   /* A list of structure, union and enum tags defined.  */
-  VEC(c_arg_tag,gc) *tags;
+  vec<c_arg_tag, va_gc> *tags;
   /* A list of argument types to go in the FUNCTION_TYPE.  */
   tree types;
   /* A list of non-parameter decls (notably enumeration constants)
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index cf63355..2032f66 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -80,8 +80,8 @@ static int function_types_compatible_p (const_tree, const_tree, bool *,
 					bool *);
 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
 static tree lookup_field (tree, tree);
-static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
-			      tree);
+static int convert_arguments (tree, vec<tree, va_gc> *, vec<tree, va_gc> *,
+			      tree, tree);
 static tree pointer_diff (location_t, tree, tree);
 static tree convert_for_assignment (location_t, tree, tree, tree,
 				    enum impl_conv, bool, tree, tree, int);
@@ -2662,14 +2662,14 @@ c_expr_sizeof_type (location_t loc, struct c_type_name *t)
 tree
 build_function_call (location_t loc, tree function, tree params)
 {
-  VEC(tree,gc) *vec;
+  vec<tree, va_gc> *v;
   tree ret;
 
-  vec = VEC_alloc (tree, gc, list_length (params));
+  vec_alloc (v, list_length (params));
   for (; params; params = TREE_CHAIN (params))
-    VEC_quick_push (tree, vec, TREE_VALUE (params));
-  ret = build_function_call_vec (loc, function, vec, NULL);
-  VEC_free (tree, gc, vec);
+    v->quick_push (TREE_VALUE (params));
+  ret = build_function_call_vec (loc, function, v, NULL);
+  vec_free (v);
   return ret;
 }
 
@@ -2690,8 +2690,9 @@ static void inform_declaration (tree decl)
    PARAMS.  */
 
 tree
-build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
-			 VEC(tree,gc) *origtypes)
+build_function_call_vec (location_t loc, tree function,
+			 vec<tree, va_gc> *params,
+			 vec<tree, va_gc> *origtypes)
 {
   tree fntype, fundecl = 0;
   tree name = NULL_TREE, result;
@@ -2729,9 +2730,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 
   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
      expressions, like those used for ObjC messenger dispatches.  */
-  if (!VEC_empty (tree, params))
-    function = objc_rewrite_function_call (function,
-					   VEC_index (tree, params, 0));
+  if (params && !params->is_empty ())
+    function = objc_rewrite_function_call (function, (*params)[0]);
 
   function = c_fully_fold (function, false, NULL);
 
@@ -2800,8 +2800,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
       /* Before the abort, allow the function arguments to exit or
 	 call longjmp.  */
       for (i = 0; i < nargs; i++)
-	trap = build2 (COMPOUND_EXPR, void_type_node,
-		       VEC_index (tree, params, i), trap);
+	trap = build2 (COMPOUND_EXPR, void_type_node, (*params)[i], trap);
 
       if (VOID_TYPE_P (return_type))
 	{
@@ -2816,7 +2815,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 
 	  if (AGGREGATE_TYPE_P (return_type))
 	    rhs = build_compound_literal (loc, return_type,
-					  build_constructor (return_type, 0),
+					  build_constructor (return_type,
+					    NULL),
 					  false);
 	  else
 	    rhs = build_zero_cst (return_type);
@@ -2826,7 +2826,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
 	}
     }
 
-  argarray = VEC_address (tree, params);
+  argarray = vec_safe_address (params);
 
   /* Check that arguments to builtin functions match the expectations.  */
   if (fundecl
@@ -2886,8 +2886,8 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
    failure.  */
 
 static int
-convert_arguments (tree typelist, VEC(tree,gc) *values,
-		   VEC(tree,gc) *origtypes, tree function, tree fundecl)
+convert_arguments (tree typelist, vec<tree, va_gc> *values,
+		   vec<tree, va_gc> *origtypes, tree function, tree fundecl)
 {
   tree typetail, val;
   unsigned int parmnum;
@@ -2934,7 +2934,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
      converted arguments.  */
 
   for (typetail = typelist, parmnum = 0;
-       VEC_iterate (tree, values, parmnum, val);
+       values && values->iterate (parmnum, &val);
        ++parmnum)
     {
       tree type = typetail ? TREE_VALUE (typetail) : 0;
@@ -3127,9 +3127,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 		 sake of better warnings from convert_and_check.  */
 	      if (excess_precision)
 		val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
-	      origtype = (origtypes == NULL
-			  ? NULL_TREE
-			  : VEC_index (tree, origtypes, parmnum));
+	      origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
 	      parmval = convert_for_assignment (input_location, type, val,
 						origtype, ic_argpass, npc,
 						fundecl, function,
@@ -3173,7 +3171,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 	/* Convert `short' and `char' to full-size `int'.  */
 	parmval = default_conversion (val);
 
-      VEC_replace (tree, values, parmnum, parmval);
+      (*values)[parmnum] = parmval;
       if (parmval == error_mark_node)
 	error_args = true;
 
@@ -3181,7 +3179,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 	typetail = TREE_CHAIN (typetail);
     }
 
-  gcc_assert (parmnum == VEC_length (tree, values));
+  gcc_assert (parmnum == vec_safe_length (values));
 
   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
     {
@@ -6341,7 +6339,7 @@ static tree constructor_bit_index;
 /* If we are saving up the elements rather than allocating them,
    this is the list of elements so far (in reverse order,
    most recent first).  */
-static VEC(constructor_elt,gc) *constructor_elements;
+static vec<constructor_elt, va_gc> *constructor_elements;
 
 /* 1 if constructor should be incrementally stored into a constructor chain,
    0 if all the elements should be kept in AVL tree.  */
@@ -6417,7 +6415,7 @@ struct constructor_stack
   tree unfilled_index;
   tree unfilled_fields;
   tree bit_index;
-  VEC(constructor_elt,gc) *elements;
+  vec<constructor_elt, va_gc> *elements;
   struct init_node *pending_elts;
   int offset;
   int depth;
@@ -6462,7 +6460,7 @@ struct initializer_stack
   tree decl;
   struct constructor_stack *constructor_stack;
   struct constructor_range_stack *constructor_range_stack;
-  VEC(constructor_elt,gc) *elements;
+  vec<constructor_elt, va_gc> *elements;
   struct spelling *spelling;
   struct spelling *spelling_base;
   int spelling_size;
@@ -6611,7 +6609,7 @@ really_start_incremental_init (tree type)
   constructor_simple = 1;
   constructor_nonconst = 0;
   constructor_depth = SPELLING_DEPTH ();
-  constructor_elements = 0;
+  constructor_elements = NULL;
   constructor_pending_elts = 0;
   constructor_type = type;
   constructor_incremental = 1;
@@ -6757,7 +6755,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
   constructor_simple = 1;
   constructor_nonconst = 0;
   constructor_depth = SPELLING_DEPTH ();
-  constructor_elements = 0;
+  constructor_elements = NULL;
   constructor_incremental = 1;
   constructor_designated = 0;
   constructor_pending_elts = 0;
@@ -6807,7 +6805,7 @@ push_init_level (int implicit, struct obstack * braced_init_obstack)
       constructor_simple = TREE_STATIC (value);
       constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
       constructor_elements = CONSTRUCTOR_ELTS (value);
-      if (!VEC_empty (constructor_elt, constructor_elements)
+      if (!vec_safe_is_empty (constructor_elements)
 	  && (TREE_CODE (constructor_type) == RECORD_TYPE
 	      || TREE_CODE (constructor_type) == ARRAY_TYPE))
 	set_nonincremental_init (braced_init_obstack);
@@ -6957,9 +6955,8 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
       && constructor_unfilled_fields)
     {
 	bool constructor_zeroinit =
-	 (VEC_length (constructor_elt, constructor_elements) == 1
-	  && integer_zerop
-	      (VEC_index (constructor_elt, constructor_elements, 0).value));
+	 (vec_safe_length (constructor_elements) == 1
+	  && integer_zerop ((*constructor_elements)[0].value));
 
 	/* Do not warn for flexible array members or zero-length arrays.  */
 	while (constructor_unfilled_fields
@@ -6997,19 +6994,19 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
     {
       /* A nonincremental scalar initializer--just return
 	 the element, after verifying there is just one.  */
-      if (VEC_empty (constructor_elt,constructor_elements))
+      if (vec_safe_is_empty (constructor_elements))
 	{
 	  if (!constructor_erroneous)
 	    error_init ("empty scalar initializer");
 	  ret.value = error_mark_node;
 	}
-      else if (VEC_length (constructor_elt,constructor_elements) != 1)
+      else if (vec_safe_length (constructor_elements) != 1)
 	{
 	  error_init ("extra elements in scalar initializer");
-	  ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+	  ret.value = (*constructor_elements)[0].value;
 	}
       else
-	ret.value = VEC_index (constructor_elt,constructor_elements,0).value;
+	ret.value = (*constructor_elements)[0].value;
     }
   else
     {
@@ -7534,7 +7531,7 @@ set_nonincremental_init (struct obstack * braced_init_obstack)
       add_pending_init (index, value, NULL_TREE, true,
 			braced_init_obstack);
     }
-  constructor_elements = 0;
+  constructor_elements = NULL;
   if (TREE_CODE (constructor_type) == RECORD_TYPE)
     {
       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
@@ -7679,10 +7676,9 @@ find_init_member (tree field, struct obstack * braced_init_obstack)
     }
   else if (TREE_CODE (constructor_type) == UNION_TYPE)
     {
-      if (!VEC_empty (constructor_elt, constructor_elements)
-	  && (VEC_last (constructor_elt, constructor_elements).index
-	      == field))
-	return VEC_last (constructor_elt, constructor_elements).value;
+      if (!vec_safe_is_empty (constructor_elements)
+	  && (constructor_elements->last ().index == field))
+	return constructor_elements->last ().value;
     }
   return 0;
 }
@@ -7859,12 +7855,11 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
       return;
     }
   else if (TREE_CODE (constructor_type) == UNION_TYPE
-	   && !VEC_empty (constructor_elt, constructor_elements))
+	   && !vec_safe_is_empty (constructor_elements))
     {
       if (!implicit)
 	{
-	  if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
-					   constructor_elements).value))
+	  if (TREE_SIDE_EFFECTS (constructor_elements->last ().value))
 	    warning_init (0,
 			  "initialized field with side-effects overwritten");
 	  else if (warn_override_init)
@@ -7872,14 +7867,14 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
 	}
 
       /* We can have just one union field set.  */
-      constructor_elements = 0;
+      constructor_elements = NULL;
     }
 
   /* Otherwise, output this element either to
      constructor_elements or to the assembler file.  */
 
   constructor_elt celt = {field, value};
-  VEC_safe_push (constructor_elt, gc, constructor_elements, celt);
+  vec_safe_push (constructor_elements, celt);
 
   /* Advance the variable that indicates sequential elements output.  */
   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
