vec.h: Remove all #if IN_GENGTYPE blocks.

	* vec.h: Remove all #if IN_GENGTYPE blocks.
	Add comment saying that changes may require adjustments to gengtype.
	* gengtype.c: Don't include coretypes.h or tm.h.
	Add comment to inclusion of errors.h.
	(note_def_vec, note_def_vec_alloc): New functions.
	* gengtype.h: Declare new functions.
	* gengtype-lex.l: Don't include coretypes.h.
	(YY_INPUT, macro_input, push_macro_expansion, mangle_macro_name):
	Delete.
	(update_lineno): Remove unnecessary prototype.
	(DEF_VEC_* rules): Simplify using note_def_vec / note_def_vec_alloc.
	(VEC rule): Just return VEC_TOKEN.
	* gengtype-yacc.y (VEC_TOKEN): New token type.
	(type): Add a production for VEC(a,b).
	* Makefile.in: Update dependencies.

From-SVN: r123229

7 files changed, 165 insertions, 262 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1eaba11..077fc93 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,21 @@
 2007-03-26  Zack Weinberg  <zackw@panix.com>
 
+	* vec.h: Remove all #if IN_GENGTYPE blocks.
+	Add comment saying that changes may require adjustments to gengtype.
+	* gengtype.c: Don't include coretypes.h or tm.h.
+	Add comment to inclusion of errors.h.
+	(note_def_vec, note_def_vec_alloc): New functions.
+	* gengtype.h: Declare new functions.
+	* gengtype-lex.l: Don't include coretypes.h.
+	(YY_INPUT, macro_input, push_macro_expansion, mangle_macro_name):
+	Delete.
+	(update_lineno): Remove unnecessary prototype.
+	(DEF_VEC_* rules): Simplify using note_def_vec / note_def_vec_alloc.
+	(VEC rule): Just return VEC_TOKEN.
+	* gengtype-yacc.y (VEC_TOKEN): New token type.
+	(type): Add a production for VEC(a,b).
+	* Makefile.in: Update dependencies.
+
 	* gengtype-lex.l: Remove rules for parsing pointer-to-function
 	typedefs that use the old PARAMS macro.
 
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index ea6255f..c51376c 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -3138,11 +3138,11 @@ build/genflags.o : genflags.c $(RTL_BASE_H) $(OBSTACK_H) $(BCONFIG_H)	\
   $(SYSTEM_H) coretypes.h $(GTM_H) errors.h gensupport.h
 build/gengenrtl.o : gengenrtl.c $(BCONFIG_H) $(SYSTEM_H) rtl.def
 build/gengtype-lex.o : gengtype-lex.c gengtype.h gengtype-yacc.h	\
-  $(BCONFIG_H) coretypes.h $(GTM_H) $(SYSTEM_H) vec.h
+  $(BCONFIG_H) $(SYSTEM_H)
 build/gengtype-yacc.o : gengtype-yacc.c gengtype.h $(BCONFIG_H)		\
-  $(SYSTEM_H) coretypes.h $(GTM_H)
-build/gengtype.o : gengtype.c $(BCONFIG_H) $(SYSTEM_H) coretypes.h	\
-  $(GTM_H) gengtype.h gtyp-gen.h rtl.def insn-notes.def errors.h
+  $(SYSTEM_H)
+build/gengtype.o : gengtype.c $(BCONFIG_H) $(SYSTEM_H) gengtype.h 	\
+  gtyp-gen.h rtl.def insn-notes.def errors.h
 build/genmddeps.o: genmddeps.c $(BCONFIG_H) $(SYSTEM_H) coretypes.h	\
   $(GTM_H) $(RTL_BASE_H) errors.h gensupport.h
 build/genmodes.o : genmodes.c $(BCONFIG_H) $(SYSTEM_H) errors.h		\
diff --git a/gcc/gengtype-lex.l b/gcc/gengtype-lex.l
index 8ae86bc..ad4b1d5 100644
--- a/gcc/gengtype-lex.l
+++ b/gcc/gengtype-lex.l
@@ -21,7 +21,6 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 
 %{
 #include "bconfig.h"
-#include "coretypes.h"
 #include "system.h"
 
 #define malloc xmalloc
@@ -30,15 +29,6 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "gengtype.h"
 #include "gengtype-yacc.h"
 
-#define YY_INPUT(BUF,RESULT,SIZE) ((RESULT) = macro_input (BUF,SIZE))
-
-static unsigned macro_input (char *buffer, unsigned);
-static const char *push_macro_expansion (const char *, unsigned,
-					 const char *, unsigned);
-static char *mangle_macro_name (const char *, unsigned,
-       			        const char *, unsigned);
-static void update_lineno (const char *l, size_t len);
-
 struct fileloc lexer_line;
 int lexer_toplevel_done;
 
@@ -199,40 +189,58 @@ ITYPE	{IWORD}({WS}{IWORD})*
   return ENT_EXTERNSTATIC;
 }
 
-^"DEF_VEC_"[[:alnum:]_]*{WS}?"("{WS}?{ID}{WS}?(","{WS}?{ID}{WS}?)*")" {
-  char *macro, *arg;
-  unsigned macro_len, arg_len;
-  char *ptr = yytext;
-  const char *additional;
-  type_p t;
-
-  /* Find the macro name.  */
-  for (macro = ptr; *ptr != '(' && !ISSPACE (*ptr); ptr++)
-    continue;
-  for (macro_len = ptr - macro; !(ISALNUM (*ptr) || *ptr == '_'); ptr++)
-    continue;
-
-  /* Find the argument(s).  */
-  for (arg = ptr; *ptr != ')'; ptr++)
-    continue;
-  arg_len = ptr - arg;
-
-  /* Create the struct and typedef.  */
-  ptr = mangle_macro_name ("VEC", 3, arg, arg_len);
-
-  t = find_structure (ptr, 0);
-  do_typedef (ptr, t, &lexer_line);
-
-  /* Push the macro for later expansion.  */
-  additional = push_macro_expansion (macro, macro_len, arg, arg_len);
+^"DEF_VEC_"[IPO]{WS}?"("{WS}?{ID}{WS}?")" {
+  /* Definition of a generic VEC structure.  If the letter after
+     DEF_VEC_ is "I", the structure definition is slightly different
+     than if it is "P" or "O".  */
+
+  char *p = yytext + sizeof("DEF_VEC_") - 1;
+  char *q;
+  const char *type;
+  bool is_I = (*p == 'I');
+
+  /* Extract the argument to the macro.  */
+  p++;
+  while (!ISALNUM(*p) && *p != '_')
+    p++;
+  q = p;
+  while (ISALNUM(*q) || *q == '_')
+    ++;
+  type = xmemdup (p, q - p, q - p + 1);
+
+  note_def_vec (type, is_I, &lexer_line);
+  note_def_vec_alloc (type, "none", &lexer_line);
+}
 
-  if (additional)
-    {
-      ptr = mangle_macro_name (ptr, strlen (ptr),
-			       additional, strlen (additional));
-      t = find_structure (ptr, 0);
-      do_typedef (ptr, t, &lexer_line);
-    }
+^"DEF_VEC_ALLOC_"[IPO]{WS}?"("{WS}?{ID}{WS}?","{WS}?{ID}{WS}?")" {
+  /* Definition of an allocation strategy for a VEC structure.  For
+     purposes of gengtype, this just declares a wrapper structure.  */
+
+  char *p = yytext + sizeof("DEF_VEC_ALLOC_I") - 1;
+  char *q;
+  char *type, *astrat;
+
+  /* Extract the two arguments to the macro.  */
+  while (!ISALNUM(*p) && *p != '_')
+    p++;
+  q = p;
+  while (ISALNUM(*q) || *q == '_')
+    q++;
+  type = alloca (q - p + 1);
+  memcpy (type, p, q - p);
+  type[q - p] = '\0';
+  p = q;
+
+  while (!ISALNUM(*p) && *p != '_')
+    p++;
+  q = p;
+  while (ISALNUM(*q) || *q == '_')
+    q++;
+  astrat = alloca (q - p + 1);
+  memcpy (astrat, p, q - p);
+  astrat[q - p] = '\0';
+
+  note_def_vec_alloc (type, astrat, &lexer_line);
 }
 
 <in_struct>{
@@ -243,6 +251,7 @@ ITYPE	{IWORD}({WS}{IWORD})*
 
 "const"/[^[:alnum:]_]		/* don't care */
 "GTY"/[^[:alnum:]_]		{ return GTY_TOKEN; }
+"VEC"/[^[:alnum:]_]		{ return VEC_TOKEN; }
 "union"/[^[:alnum:]_]		{ return UNION; }
 "struct"/[^[:alnum:]_]		{ return STRUCT; }
 "enum"/[^[:alnum:]_]		{ return ENUM; }
@@ -266,26 +275,6 @@ ITYPE	{IWORD}({WS}{IWORD})*
   return SCALAR;
 }
 
-"VEC"{WS}?"("{WS}?{ID}{WS}?(","{WS}?{ID}{WS}?)*")" {
-  char *macro, *arg;
-  unsigned macro_len, arg_len;
-  char *ptr = yytext;
-
-  /* Find the macro name */
-  for (macro = ptr; *ptr != '(' && !ISSPACE (*ptr); ptr++)
-    continue;
-  for (macro_len = ptr - macro; !(ISALNUM(*ptr) || *ptr == '_'); ptr++)
-    continue;
-
-  /* Find the arguments.  */
-  for (arg = ptr; *ptr != ')'; ptr++)
-    continue;
-  arg_len = ptr - arg;
-
-  ptr = mangle_macro_name (macro, macro_len, arg, arg_len);
-  yylval.s = ptr;
-  return ID;
-}
 
 {ID}/[^[:alnum:]_]		{
   yylval.s = (const char *) xmemdup (yytext, yyleng, yyleng+1);
@@ -353,176 +342,6 @@ ITYPE	{IWORD}({WS}{IWORD})*
 
 %%
 
-/* Deal with the expansion caused by the DEF_VEC_x macros.  */
-
-/* Mangle a macro and argument list as done by cpp concatenation in
-   the compiler proper.  */
-static char *
-mangle_macro_name (const char *macro, unsigned macro_len,
-		   const char *arg, unsigned arg_len)
-{
-  char *ptr = (char *) xmemdup (macro, macro_len, macro_len + arg_len + 2);
-
-  /* Now copy and concatenate each argument */
-  while (arg_len)
-    {
-      ptr[macro_len++] = '_';
-      for (; arg_len && (ISALNUM(*arg) || *arg == '_'); arg_len--)
-        ptr[macro_len++] = *arg++;
-      for (; arg_len && !(ISALNUM(*arg) || *arg == '_'); arg_len--)
-        arg++;
-    }
-  ptr[macro_len] = 0;
-
-  return ptr;
-}
-
-typedef struct macro_def
-{
-  const char *name;
-  const char *expansion;
-  const char *additional;
-} macro_def_t;
-
-typedef struct macro
-{
-  const macro_def_t *def;
-  struct macro *next;
-  const char *args[10];
-} macro_t;
-
-static const macro_def_t macro_defs[] = 
-{
-#define IN_GENGTYPE 1
-#include "vec.h"
-  {NULL, NULL, NULL}
-};
-
-/* Chain of macro expansions to do at end of scanning.  */
-static macro_t *macro_expns;
-static macro_t *macro_expns_end;
-
-/* Push macro NAME (NAME_LEN) with argument ARG (ARG_LEN) onto the
-   expansion queue.  We ensure NAME is known at this point.  */
-
-static const char *
-push_macro_expansion (const char *name, unsigned name_len,
-		      const char *arg, unsigned arg_len)
-{
-  unsigned ix;
-
-  for (ix = 0; macro_defs[ix].name; ix++)
-    if (strlen (macro_defs[ix].name) == name_len
-        && !memcmp (name, macro_defs[ix].name, name_len))
-      {
-        macro_t *expansion = XNEW (macro_t);
-        char *args;
-	unsigned argno, last_arg;
-
-	expansion->def = &macro_defs[ix];
-	expansion->next = NULL;
-	args = (char *) xmemdup (arg, arg_len, arg_len+1);
-	args[arg_len] = 0;
-        for (argno = 0; *args;)
-	  {
-   	    expansion->args[argno++] = args;
-	    while (*args && (ISALNUM (*args) || *args == '_'))
-	      args++;
-	    if (argno == 1)
-	      expansion->args[argno++] = "base";
-	    if (!*args)
-	      break;
-	    *args++ = 0;
-	    while (*args && !(ISALNUM (*args) || *args == '_'))
-	      args++;
-          }
-	last_arg = argno;
-        for (; argno != 10; argno++)
-	  expansion->args[argno] = NULL;
-	if (macro_expns_end)
-          macro_expns_end->next = expansion;
-	else
-	  macro_expns = expansion;
-	macro_expns_end = expansion;
-	if (macro_defs[ix].additional)
-	  {
-	    macro_t *expn2 = XNEW (macro_t);
-            memcpy (expn2, expansion, sizeof (*expn2));
-	    expansion = expn2;
-	    expansion->def += 1;
-	    expansion->args[last_arg++] = macro_defs[ix].additional;
-	    macro_expns_end->next = expansion;
-	    macro_expns_end = expansion;
-	  }
-        if (last_arg > 2 && strcmp (expansion->args[last_arg - 1], "heap"))
-	  expansion->args[last_arg++] = "GTY (())";
-	return macro_defs[ix].additional;
-      }
-  error_at_line (&lexer_line, "unrecognized macro `%.*s(%.*s)'",
-		 name_len, name, arg_len, arg);
-  return NULL;
-}
-
-/* Attempt to read some input.  Use fread until we're at the end of
-   file.  At end of file expand the next queued macro.  We presume the
-   buffer is large enough for the entire expansion.  */
-
-static unsigned
-macro_input (char *buffer, unsigned size)
-{
-  unsigned result;
-
-  result = fread (buffer, 1, size, yyin);
-  if (result)
-    /*NOP*/;
-  else if (ferror (yyin))
-    YY_FATAL_ERROR ("read of source file failed");
-  else if (macro_expns)
-    {
-      const char *expn;
-      unsigned len;
-
-      for (expn = macro_expns->def->expansion; *expn; expn++)
-        {
-	  if (*expn == '#')
-	    {
-	      int argno;
-
-	      argno = expn[1] - '0';
-	      expn += 1;
-
-	      /* Remove inserted space? */
-	      if (buffer[result-1] == ' ' && buffer[result-2] == '_')
-	        result--;
-
-	      /* Insert the argument value */
-	      if (macro_expns->args[argno])
-	        {
-		  len = strlen (macro_expns->args[argno]);
-		  memcpy (&buffer[result], macro_expns->args[argno], len);
-		  result += len;
-		}
-
-	      /* Skip next space? */
-	      if (expn[1] == ' ' && expn[2] == '_')
-	        expn++;
-	    }
-	  else
-	    {
-	      buffer[result++] = *expn;
-	      if (*expn == ';' || *expn == '{')
-	        buffer[result++] = '\n';
-	    }
-        }
-      if (result > size)
-        YY_FATAL_ERROR ("buffer too small to expand macro");
-      macro_expns = macro_expns->next;
-      if (!macro_expns)
-        macro_expns_end = NULL;
-    }
-  return result;
-}
-
 void
 yyerror (const char *s)
 {
diff --git a/gcc/gengtype-yacc.y b/gcc/gengtype-yacc.y
index 2ce01e7..e97e88a 100644
--- a/gcc/gengtype-yacc.y
+++ b/gcc/gengtype-yacc.y
@@ -39,6 +39,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 %token <t>ENT_STRUCT
 %token ENT_EXTERNSTATIC
 %token GTY_TOKEN
+%token VEC_TOKEN
 %token UNION
 %token STRUCT
 %token ENUM
@@ -160,6 +161,9 @@ type: SCALAR
          { $$ = $1; }
       | ID
          { $$ = resolve_typedef ($1, &lexer_line); }
+      | VEC_TOKEN '(' ID ',' ID ')'
+         { $$ = resolve_typedef (concat ("VEC_", $3, "_", $5, (char *)0),
+	      			 &lexer_line); }
       | type '*'
          { $$ = create_pointer ($1); }
       | STRUCT ID '{' struct_fields '}'
diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index 250712c..beec069 100644
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -21,11 +21,9 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 
 #include "bconfig.h"
 #include "system.h"
-#include "coretypes.h"
-#include "tm.h"
 #include "gengtype.h"
 #include "gtyp-gen.h"
-#include "errors.h"
+#include "errors.h"	/* for fatal */
 
 /* Nonzero iff an error has occurred.  */
 static int hit_error = 0;
@@ -2996,6 +2994,86 @@ write_roots (pair_p variables)
 		     "gt_pch_scalar_rtab");
 }
 
+/* Record the definition of a generic VEC structure, as if we had expanded
+   the macros in vec.h:
+
+   typedef struct VEC_<type>_base GTY(()) {
+   unsigned num;
+   unsigned alloc;
+   <type> GTY((length ("%h.num"))) vec[1];
+   } VEC_<type>_base
+
+   where the GTY(()) tags are only present if is_scalar is _false_.  */
+
+void
+note_def_vec (const char *typename, bool is_scalar, struct fileloc *pos)
+{
+  pair_p f, fields;
+  type_p t;
+  options_p o;
+  const char *name = concat ("VEC_", typename, "_base", (char *)0);
+
+  if (is_scalar)
+    {
+      t = create_scalar_type (typename, strlen (typename));
+      o = 0;
+    }
+  else
+    {
+      t = resolve_typedef (typename, pos);
+      o = create_option (0, "length", "%h.num");
+    }
+
+  /* We assemble the field list in reverse order.  */
+  f = XNEW (struct pair);
+  f->type = adjust_field_type (create_array (t, "1"), o);
+  f->name = "vec";
+  f->opt = o;
+  f->line = *pos;
+  f->next = 0;
+  fields = f;
+
+  f = XNEW (struct pair);
+  f->type = adjust_field_type (create_scalar_type ("unsigned", 8), 0);
+  f->name = "alloc";
+  f->opt = 0;
+  f->line = *pos;
+  f->next = fields;
+  fields = f;
+
+  f = XNEW (struct pair);
+  f->type = adjust_field_type (create_scalar_type ("unsigned", 8), 0);
+  f->name = "num";
+  f->opt = 0;
+  f->line = *pos;
+  f->next = fields;
+  fields = f;
+
+  do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
+}
+
+/* Record the definition of an allocation-specific VEC structure, as if
+   we had expanded the macros in vec.h:
+
+   typedef struct VEC_<type>_<astrat> {
+     VEC_<type>_base base;
+   } VEC_<type>_<astrat>;
+*/
+void
+note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
+{
+  const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0);
+  const char *basename = concat ("VEC_", type, "_base", (char *)0);
+
+  pair_p field = XNEW (struct pair);
+  field->name = "base";
+  field->type = adjust_field_type (resolve_typedef (basename, pos), 0);
+  field->line = *pos;
+  field->next = 0;
+
+  do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
+}
+
 
 extern int main (int argc, char **argv);
 int
diff --git a/gcc/gengtype.h b/gcc/gengtype.h
index 7be47b8..034a731 100644
--- a/gcc/gengtype.h
+++ b/gcc/gengtype.h
@@ -144,6 +144,10 @@ extern options_p create_option (options_p, const char *name, const void *info);
 extern type_p adjust_field_type (type_p, options_p);
 extern void note_variable (const char *s, type_p t, options_p o,
 			   struct fileloc *pos);
+extern void note_def_vec (const char *typename, bool is_scalar,
+			  struct fileloc *pos);
+extern void note_def_vec_alloc (const char *type, const char *astrat,
+				struct fileloc *pos);
 
 /* Lexer and parser routines, most automatically generated.  */
 extern int yylex (void);
diff --git a/gcc/vec.h b/gcc/vec.h
index 3bc6566..c8eabc9 100644
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -417,7 +417,6 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define VEC_lower_bound(T,V,O,LT)    \
        (VEC_OP(T,base,lower_bound)(VEC_BASE(V),O,LT VEC_CHECK_INFO))
 
-#if !IN_GENGTYPE
 /* Reallocate an array of elements with prefix.  */
 extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL);
 extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL);
@@ -451,14 +450,12 @@ extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL)
 #define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR)
 #endif
 
+/* Note: gengtype has hardwired knowledge of the expansions of the
+   VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros.  If you change the
+   expansions of these macros you may need to change gengtype too.  */
+
 #define VEC(T,A) VEC_##T##_##A
 #define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP
-#else  /* IN_GENGTYPE */
-#define VEC(T,A) VEC_ T _ A
-#define VEC_STRINGIFY(X) VEC_STRINGIFY_(X)
-#define VEC_STRINGIFY_(X) #X
-#undef GTY
-#endif /* IN_GENGTYPE */
 
 /* Base of vector type, not user visible.  */     
 #define VEC_T(T,B)							  \
@@ -488,10 +485,6 @@ typedef struct VEC(T,A) GTY						  \
 #define VEC_BASE(P)  ((P) ? &(P)->base : 0)
 
 /* Vector of integer-like object.  */
-#if IN_GENGTYPE
-{"DEF_VEC_I", VEC_STRINGIFY (VEC_T(#0,#1)) ";", "none"},
-{"DEF_VEC_ALLOC_I", VEC_STRINGIFY (VEC_TA (#0,#1,#2,#3)) ";", NULL},
-#else
 #define DEF_VEC_I(T)							  \
 static inline void VEC_OP (T,must_be,integral_type) (void) 		  \
 {									  \
@@ -506,13 +499,8 @@ struct vec_swallow_trailing_semi
 VEC_TA_GTY(T,base,A,);							  \
 DEF_VEC_ALLOC_FUNC_I(T,A)						  \
 struct vec_swallow_trailing_semi
-#endif
 
 /* Vector of pointer to object.  */
-#if IN_GENGTYPE
-{"DEF_VEC_P", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"},
-{"DEF_VEC_ALLOC_P", VEC_STRINGIFY (VEC_TA_GTY (#0,#1,#2,#3)) ";", NULL},
-#else
 #define DEF_VEC_P(T) 							  \
 static inline void VEC_OP (T,must_be,pointer_type) (void) 		  \
 {									  \
@@ -527,7 +515,6 @@ struct vec_swallow_trailing_semi
 VEC_TA_GTY(T,base,A,);							  \
 DEF_VEC_ALLOC_FUNC_P(T,A)						  \
 struct vec_swallow_trailing_semi
-#endif
 
 #define DEF_VEC_FUNC_P(T)						  \
 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_)   \
@@ -809,10 +796,6 @@ static inline T *VEC_OP (T,A,safe_insert)		     	  	  \
 }
 
 /* Vector of object.  */
-#if IN_GENGTYPE
-{"DEF_VEC_O", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"},
-{"DEF_VEC_ALLOC_O", VEC_STRINGIFY (VEC_TA_GTY(#0,#1,#2,#3)) ";", NULL},
-#else
 #define DEF_VEC_O(T)							  \
 VEC_T_GTY(T,base);							  \
 VEC_TA_GTY(T,base,none,);						  \
@@ -822,7 +805,6 @@ struct vec_swallow_trailing_semi
 VEC_TA_GTY(T,base,A,);							  \
 DEF_VEC_ALLOC_FUNC_O(T,A)						  \
 struct vec_swallow_trailing_semi
-#endif
 
 #define DEF_VEC_FUNC_O(T)						  \
 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_)	  \