Patchwork [gccgo] Drop -ggo, add -fdump-go-spec

login
register
mail settings
Submitter Ian Taylor
Date Nov. 5, 2010, 4:52 a.m.
Message ID <mcreib0fk2h.fsf@google.com>
Download mbox | patch
Permalink /patch/70238/
State New
Headers show

Comments

Ian Taylor - Nov. 5, 2010, 4:52 a.m.
This gccgo patch drops the -ggo option and instead implements a
-fdump-go-spec option.  This is a cleaner interface suggested by Joseph
Myers.  Committed to gccgo branch.

Ian

Patch

Index: godump.c
===================================================================
--- godump.c	(revision 166266)
+++ godump.c	(working copy)
@@ -30,80 +30,61 @@  along with GCC; see the file COPYING3.  
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "diagnostic-core.h"
 #include "tree.h"
 #include "ggc.h"
 #include "pointer-set.h"
-#include "output.h"
+#include "obstack.h"
 #include "debug.h"
 
-/* A queue of decls to output.  */
+/* We dump this information from the debug hooks.  This gives us a
+   stable and maintainable API to hook into.  In order to work
+   correctly when -g is used, we build our own hooks structure which
+   wraps the hooks we need to change.  */
 
-static GTY(()) tree queue;
+/* Our debug hooks.  This is initialized by dump_go_spec_init.  */
 
-/* A hash table of macros we have seen.  Using macro_hash_node is
-   awkward but I don't know how to avoid it for the GTY machinery.  */
+static struct gcc_debug_hooks go_debug_hooks;
 
-struct GTY(()) macro_hash_node
-{
-  char *name;
-};
+/* The real debug hooks.  */
 
-struct GTY(()) goout_container
-{
-  /* DECLs that we have already seen.  */
-  struct pointer_set_t *decls_seen;
+static const struct gcc_debug_hooks *real_debug_hooks;
 
-  /* Types which may potentially have to be defined as dummy
-     types.  */
-  struct pointer_set_t *pot_dummy_types;
+/* The file where we should write information.  */
 
-  /* Go keywords.  */
-  htab_t keyword_hash;
+static FILE *go_dump_file;
 
-  /* Global type definitions.  */
-  htab_t type_hash;
-};
+/* A queue of decls to output.  */
 
-static GTY ((param_is (struct macro_hash_node))) htab_t macro_hash;
+static GTY(()) VEC(tree,gc) *queue;
 
-#ifdef GO_DEBUGGING_INFO
+/* A hash table of macros we have seen.  */
 
-/* For the macro hash table.  */
+static htab_t macro_hash;
 
-static hashval_t
-macro_hash_hash (const void *x)
-{
-  return htab_hash_string (((const struct macro_hash_node *) x)->name);
-}
+/* For the hash tables.  */
 
 static int
-macro_hash_eq (const void *x1, const void *x2)
-{
-  return strcmp ((((const struct macro_hash_node *) x1)->name),
-		 (const char *) x2) == 0;
-}
-
-/* Initialize.  */
-
-static void
-go_init (const char *filename ATTRIBUTE_UNUSED)
+string_hash_eq (const void *y1, const void *y2)
 {
-  macro_hash = htab_create (100, macro_hash_hash, macro_hash_eq, NULL);
+  return strcmp ((const char *) y1, (const char *) y2) == 0;
 }
 
 /* A macro definition.  */
 
 static void
-go_define (unsigned int lineno ATTRIBUTE_UNUSED, const char *buffer)
+go_define (unsigned int lineno, const char *buffer)
 {
   const char *p;
   const char *name_end;
   char *out_buffer;
   char *q;
   char *copy;
+  hashval_t hashval;
   void **slot;
 
+  real_debug_hooks->define (lineno, buffer);
+
   /* Skip macro functions.  */
   for (p = buffer; *p != '\0' && *p != ' '; ++p)
     if (*p == '(')
@@ -122,8 +103,8 @@  go_define (unsigned int lineno ATTRIBUTE
   memcpy (copy, buffer, name_end - buffer);
   copy[name_end - buffer] = '\0';
 
-  slot = htab_find_slot_with_hash (macro_hash, copy, htab_hash_string (copy),
-				   NO_INSERT);
+  hashval = htab_hash_string (copy);
+  slot = htab_find_slot_with_hash (macro_hash, copy, hashval, NO_INSERT);
   if (slot != NULL)
     {
       XDELETEVEC (copy);
@@ -144,18 +125,15 @@  go_define (unsigned int lineno ATTRIBUTE
 	  start = p;
 	  while (ISALNUM (*p) || *p == '_')
 	    ++p;
-	  n = (char *) alloca (p - start + 1);
+	  n = XALLOCAVEC (char, p - start + 1);
 	  memcpy (n, start, p - start);
 	  n[p - start] = '\0';
-	  slot = htab_find_slot_with_hash (macro_hash, n,
-					   htab_hash_string (n),
-					   NO_INSERT);
-	  if (slot == NULL
-	      || ((struct macro_hash_node *) *slot)->name == NULL)
+	  slot = htab_find_slot (macro_hash, n, NO_INSERT);
+	  if (slot == NULL || *slot == NULL)
 	    {
 	      /* This is a reference to a name which was not defined
 		 as a macro.  */
-	      fprintf (asm_out_file, "#GO unknowndefine %s\n", buffer);
+	      fprintf (go_dump_file, "// unknowndefine %s\n", buffer);
 	      return;
 	    }
 
@@ -204,18 +182,16 @@  go_define (unsigned int lineno ATTRIBUTE
       else
 	{
 	  /* Something we don't recognize.  */
-	  fprintf (asm_out_file, "#GO unknowndefine %s\n", buffer);
+	  fprintf (go_dump_file, "// unknowndefine %s\n", buffer);
 	  return;
 	}
     }
   *q = '\0';
 
-  slot = htab_find_slot_with_hash (macro_hash, copy, htab_hash_string (copy),
-				   INSERT);
-  *slot = XNEW (struct macro_hash_node);
-  ((struct macro_hash_node *) *slot)->name = copy;
+  slot = htab_find_slot_with_hash (macro_hash, copy, hashval, INSERT);
+  *slot = copy;
 
-  fprintf (asm_out_file, "#GO const _%s = %s\n", copy, out_buffer);
+  fprintf (go_dump_file, "const _%s = %s\n", copy, out_buffer);
 
   XDELETEVEC (out_buffer);
 }
@@ -223,17 +199,16 @@  go_define (unsigned int lineno ATTRIBUTE
 /* A macro undef.  */
 
 static void
-go_undef (unsigned int lineno ATTRIBUTE_UNUSED,
-	  const char *buffer ATTRIBUTE_UNUSED)
+go_undef (unsigned int lineno, const char *buffer)
 {
   void **slot;
 
-  slot = htab_find_slot_with_hash (macro_hash, buffer,
-				   htab_hash_string (buffer),
-				   NO_INSERT);
+  real_debug_hooks->undef (lineno, buffer);
+
+  slot = htab_find_slot (macro_hash, buffer, NO_INSERT);
   if (slot == NULL)
     return;
-  fprintf (asm_out_file, "#GO undef _%s\n", buffer);
+  fprintf (go_dump_file, "// undef _%s\n", buffer);
   /* We don't delete the slot from the hash table because that will
      cause a duplicate const definition.  */
 }
@@ -247,7 +222,25 @@  go_decl (tree decl)
       || DECL_IS_BUILTIN (decl)
       || DECL_NAME (decl) == NULL_TREE)
     return;
-  queue = tree_cons (NULL_TREE, decl, queue);
+  VEC_safe_push (tree, gc, queue, decl);
+}
+
+/* A function decl.  */
+
+static void
+go_function_decl (tree decl)
+{
+  real_debug_hooks->function_decl (decl);
+  go_decl (decl);
+}
+
+/* A global variable decl.  */
+
+static void
+go_global_decl (tree decl)
+{
+  real_debug_hooks->global_decl (decl);
+  go_decl (decl);
 }
 
 /* A type declaration.  */
@@ -255,6 +248,8 @@  go_decl (tree decl)
 static void
 go_type_decl (tree decl, int local)
 {
+  real_debug_hooks->type_decl (decl, local);
+
   if (local || DECL_IS_BUILTIN (decl))
     return;
   if (DECL_NAME (decl) == NULL_TREE
@@ -262,15 +257,55 @@  go_type_decl (tree decl, int local)
 	  || TREE_CODE (TYPE_NAME (TREE_TYPE (decl))) != IDENTIFIER_NODE)
       && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
     return;
-  queue = tree_cons (NULL_TREE, decl, queue);
+  VEC_safe_push (tree, gc, queue, decl);
 }
 
-/* Output a type.  */
+/* A container for the data we pass around when generating information
+   at the end of the compilation.  */
+
+struct godump_container
+{
+  /* DECLs that we have already seen.  */
+  struct pointer_set_t *decls_seen;
+
+  /* Types which may potentially have to be defined as dummy
+     types.  */
+  struct pointer_set_t *pot_dummy_types;
+
+  /* Go keywords.  */
+  htab_t keyword_hash;
+
+  /* Global type definitions.  */
+  htab_t type_hash;
+
+  /* Obstack used to write out a type definition.  */
+  struct obstack type_obstack;
+};
+
+/* Append an IDENTIFIER_NODE to OB.  */
 
 static void
-go_output_type (struct goout_container *container, tree type,
-		bool in_struct_or_func)
+go_append_string (struct obstack *ob, tree id)
 {
+  obstack_grow (ob, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
+}
+
+/* Write the Go version of TYPE to CONTAINER->TYPE_OBSTACK.
+   USE_TYPE_NAME is true if we can simply use a type name here without
+   needing to define it.  IS_FUNC_OK is true if we can output a func
+   type here; the "func" keyword will already have been added.  Return
+   true if the type can be represented in Go, false otherwise.  */
+
+static bool
+go_format_type (struct godump_container *container, tree type,
+		bool use_type_name, bool is_func_ok)
+{
+  bool ret;
+  struct obstack *ob;
+
+  ret = true;
+  ob = &container->type_obstack;
+
   if (TYPE_NAME (type) != NULL_TREE
       && (pointer_set_contains (container->decls_seen, type)
 	  || pointer_set_contains (container->decls_seen, TYPE_NAME (type)))
@@ -283,14 +318,15 @@  go_output_type (struct goout_container *
       name = TYPE_NAME (type);
       if (TREE_CODE (name) == IDENTIFIER_NODE)
 	{
-	  fprintf (asm_out_file, "_%s", IDENTIFIER_POINTER (name));
-	  return;
+	  obstack_1grow (ob, '_');
+	  go_append_string (ob, name);
+	  return ret;
 	}
       else if (TREE_CODE (name) == TYPE_DECL)
 	{
-	  fprintf (asm_out_file, "_%s",
-		   IDENTIFIER_POINTER (DECL_NAME (name)));
-	  return;
+	  obstack_1grow (ob, '_');
+	  go_append_string (ob, DECL_NAME (name));
+	  return ret;
 	}
     }
 
@@ -299,12 +335,12 @@  go_output_type (struct goout_container *
   switch (TREE_CODE (type))
     {
     case ENUMERAL_TYPE:
-	    fprintf (asm_out_file, "int");
-	    break;
+      obstack_grow (ob, "int", 3);
+      break;
 
     case TYPE_DECL:
-      fprintf (asm_out_file, "_%s",
-	       IDENTIFIER_POINTER (DECL_NAME (type)));
+      obstack_1grow (ob, '_');
+      go_append_string (ob, DECL_NAME (type));
       break;
 
     case INTEGER_TYPE:
@@ -331,9 +367,10 @@  go_output_type (struct goout_container *
 		      TYPE_PRECISION (type),
 		      TYPE_UNSIGNED (type) ? "u" : "");
 	    s = buf;
+	    ret = false;
 	    break;
 	  }
-	fprintf (asm_out_file, "%s", s);
+	obstack_grow (ob, s, strlen (s));
       }
       break;
 
@@ -357,18 +394,19 @@  go_output_type (struct goout_container *
 	    snprintf (buf, sizeof buf, "INVALID-float-%u",
 		      TYPE_PRECISION (type));
 	    s = buf;
+	    ret = false;
 	    break;
 	  }
-	fprintf (asm_out_file, "%s", s);
+	obstack_grow (ob, s, strlen (s));
       }
       break;
 
     case BOOLEAN_TYPE:
-      fprintf (asm_out_file, "bool");
+      obstack_grow (ob, "bool", 4);
       break;
 
     case POINTER_TYPE:
-      if (in_struct_or_func
+      if (use_type_name
           && TYPE_NAME (TREE_TYPE (type)) != NULL_TREE
           && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type))
 	      || (POINTER_TYPE_P (TREE_TYPE (type))
@@ -376,41 +414,48 @@  go_output_type (struct goout_container *
 		      == FUNCTION_TYPE))))
         {
 	  tree name;
+
 	  name = TYPE_NAME (TREE_TYPE (type));
 	  if (TREE_CODE (name) == IDENTIFIER_NODE)
 	    {
-	      fprintf (asm_out_file, "*_%s", IDENTIFIER_POINTER (name));
-	      /* If pointing to a struct or union, then the pointer
-		 here can be used without the struct or union definition.
-		 So this struct or union is a can be a potential dummy
-		 type.  */
+	      obstack_grow (ob, "*_", 2);
+	      go_append_string (ob, name);
+
+	      /* The pointer here can be used without the struct or
+		 union definition.  So this struct or union is a a
+		 potential dummy type.  */
 	      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
 		pointer_set_insert (container->pot_dummy_types,
 				    IDENTIFIER_POINTER (name));
-	      return;
+
+	      return ret;
 	    }
 	  else if (TREE_CODE (name) == TYPE_DECL)
 	    {
-	      fprintf (asm_out_file, "*_%s",
-		       IDENTIFIER_POINTER (DECL_NAME (name)));
+	      obstack_grow (ob, "*_", 2);
+	      go_append_string (ob, DECL_NAME (name));
 	      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
 		pointer_set_insert (container->pot_dummy_types,
 				    IDENTIFIER_POINTER (DECL_NAME (name)));
-	      return;
+	      return ret;
 	    }
         }
       if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
-	fprintf (asm_out_file, "func");
+	obstack_grow (ob, "func", 4);
       else
-	fprintf (asm_out_file, "*");
+	obstack_1grow (ob, '*');
       if (VOID_TYPE_P (TREE_TYPE (type)))
-	fprintf (asm_out_file, "byte");
+	obstack_grow (ob, "byte", 4);
       else
-	go_output_type (container, TREE_TYPE (type), in_struct_or_func);
+	{
+	  if (!go_format_type (container, TREE_TYPE (type), use_type_name,
+			       true))
+	    ret = false;
+	}
       break;
 
     case ARRAY_TYPE:
-      fprintf (asm_out_file, "[");
+      obstack_1grow (ob, '[');
       if (TYPE_DOMAIN (type) != NULL_TREE
 	  && TREE_CODE (TYPE_DOMAIN (type)) == INTEGER_TYPE
 	  && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
@@ -419,10 +464,16 @@  go_output_type (struct goout_container *
 	  && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
 	  && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
 	  && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0))
-	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC "+1",
-		 tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0));
-      fprintf (asm_out_file, "]");
-      go_output_type (container, TREE_TYPE (type), in_struct_or_func);
+	{
+	  char buf[100];
+
+	  snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC "+1",
+		    tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0));
+	  obstack_grow (ob, buf, strlen (buf));
+	}
+      obstack_1grow (ob, ']');
+      if (!go_format_type (container, TREE_TYPE (type), use_type_name, false))
+	ret = false;
       break;
 
     case UNION_TYPE:
@@ -431,7 +482,7 @@  go_output_type (struct goout_container *
 	tree field;
 	int i;
 
-	fprintf (asm_out_file, "struct { ");
+	obstack_grow (ob, "struct { ", 9);
 	i = 0;
 	for (field = TYPE_FIELDS (type);
 	     field != NULL_TREE;
@@ -439,7 +490,11 @@  go_output_type (struct goout_container *
 	  {
 	    if (DECL_NAME (field) == NULL)
 	      {
-		fprintf (asm_out_file, "_f%d ", i);
+		char buf[100];
+
+		obstack_grow (ob, "_f", 2);
+		snprintf (buf, sizeof buf, "%d", i);
+		obstack_grow (ob, buf, strlen (buf));
 		i++;
 	      }
 	    else
@@ -451,13 +506,16 @@  go_output_type (struct goout_container *
 		var_name = IDENTIFIER_POINTER (DECL_NAME (field));
 		slot = htab_find_slot (container->keyword_hash, var_name,
 				       NO_INSERT);
-		if (slot == NULL)
-		  fprintf (asm_out_file, "%s ", var_name);
-		else
-		  fprintf (asm_out_file, "_%s ", var_name);
+		if (slot != NULL)
+		  obstack_1grow (ob, '_');
+		go_append_string (ob, DECL_NAME (field));
+		obstack_1grow (ob, ' ');
 	      }
 	    if (DECL_BIT_FIELD (field))
-	      fprintf (asm_out_file, "INVALID-bit-field");
+	      {
+		obstack_grow (ob, "INVALID-bit-field", 17);
+		ret = false;
+	      }
 	    else
               {
 		/* Do not expand type if a record or union type or a
@@ -470,22 +528,31 @@  go_output_type (struct goout_container *
 		  {
 		    tree name = TYPE_NAME (TREE_TYPE (field));
 		    if (TREE_CODE (name) == IDENTIFIER_NODE)
-		      fprintf (asm_out_file, "_%s", IDENTIFIER_POINTER (name));
+		      {
+			obstack_1grow (ob, '_');
+			go_append_string (ob, name);
+		      }
 		    else if (TREE_CODE (name) == TYPE_DECL)
-		      fprintf (asm_out_file, "_%s",
-			       IDENTIFIER_POINTER (DECL_NAME (name)));
+		      {
+			obstack_1grow (ob, '_');
+			go_append_string (ob, DECL_NAME (name));
+		      }
 		  }
 		else
-		  go_output_type (container, TREE_TYPE (field), true);
+		  {
+		    if (!go_format_type (container, TREE_TYPE (field), true,
+					 false))
+		      ret = false;
+		  }
               }
-	    fprintf (asm_out_file, "; ");
+	    obstack_grow (ob, "; ", 2);
 
 	    /* Only output the first field of a union, and hope for
 	       the best.  */
 	    if (TREE_CODE (type) == UNION_TYPE)
 	      break;
 	  }
-	fprintf (asm_out_file, "}");
+	obstack_1grow (ob, '}');
       }
       break;
 
@@ -495,7 +562,15 @@  go_output_type (struct goout_container *
 	bool is_varargs;
 	tree result;
 
-	fprintf (asm_out_file, "(");
+	/* Go has no way to write a type which is a function but not a
+	   pointer to a function.  */
+	if (!is_func_ok)
+	  {
+	    obstack_grow (ob, "func*", 5);
+	    ret = false;
+	  }
+
+	obstack_1grow (ob, '(');
 	is_varargs = true;
 	for (args = TYPE_ARG_TYPES (type);
 	     args != NULL_TREE;
@@ -508,48 +583,69 @@  go_output_type (struct goout_container *
 		break;
 	      }
 	    if (args != TYPE_ARG_TYPES (type))
-	      fprintf (asm_out_file, ", ");
-	    go_output_type (container, TREE_VALUE (args), true);
+	      obstack_grow (ob, ", ", 2);
+	    if (!go_format_type (container, TREE_VALUE (args), true, false))
+	      ret = false;
 	  }
 	if (is_varargs)
 	  {
 	    if (TYPE_ARG_TYPES (type) != NULL_TREE)
-	      fprintf (asm_out_file, ", ");
-	    fprintf (asm_out_file, "...");
+	      obstack_grow (ob, ", ", 2);
+	    obstack_grow (ob, "...interface{}", 14);
 	  }
-	fprintf (asm_out_file, ")");
+	obstack_1grow (ob, ')');
 
 	result = TREE_TYPE (type);
 	if (!VOID_TYPE_P (result))
 	  {
-	    fprintf (asm_out_file, " ");
-	    go_output_type (container, result, in_struct_or_func);
+	    obstack_1grow (ob, ' ');
+	    if (!go_format_type (container, result, use_type_name, false))
+	      ret = false;
 	  }
       }
       break;
 
     default:
-      fprintf (asm_out_file, "INVALID-type");
+      obstack_grow (ob, "INVALID-type", 12);
+      ret = false;
       break;
     }
+
+  return ret;
+}
+
+/* Output the type which was built on the type obstack, and then free
+   it.  */
+
+static void
+go_output_type (struct godump_container *container)
+{
+  struct obstack *ob;
+
+  ob = &container->type_obstack;
+  obstack_1grow (ob, '\0');
+  fputs (obstack_base (ob), go_dump_file);
+  obstack_free (ob, obstack_base (ob));
 }
 
 /* Output a function declaration.  */
 
 static void
-go_output_fndecl (struct goout_container *container, tree decl)
+go_output_fndecl (struct godump_container *container, tree decl)
 {
-  fprintf (asm_out_file, "#GO func _%s ",
+  if (!go_format_type (container, TREE_TYPE (decl), false, true))
+    fprintf (go_dump_file, "// ");
+  fprintf (go_dump_file, "func _%s ",
 	   IDENTIFIER_POINTER (DECL_NAME (decl)));
-  go_output_type (container, TREE_TYPE (decl), false);
-  fprintf (asm_out_file, " __asm__(\"%s\")\n",
+  go_output_type (container);
+  fprintf (go_dump_file, " __asm__(\"%s\")\n",
 	   IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 }
 
 /* Output a typedef or something like a struct definition.  */
 
 static void
-go_output_typedef (struct goout_container *container, tree decl)
+go_output_typedef (struct godump_container *container, tree decl)
 {
   /* If we have an enum type, output the enum constants
      separately.  */
@@ -565,12 +661,13 @@  go_output_typedef (struct goout_containe
       for (element = TYPE_VALUES (TREE_TYPE (decl));
 	   element != NULL_TREE;
 	   element = TREE_CHAIN (element))
-	fprintf (asm_out_file, "#GO const _%s = " HOST_WIDE_INT_PRINT_DEC "\n",
+	fprintf (go_dump_file, "const _%s = " HOST_WIDE_INT_PRINT_DEC "\n",
 		 IDENTIFIER_POINTER (TREE_PURPOSE (element)),
 		 tree_low_cst (TREE_VALUE (element), 0));
       pointer_set_insert (container->decls_seen, TREE_TYPE (decl));
       if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE)
-	pointer_set_insert (container->decls_seen, TYPE_CANONICAL (TREE_TYPE (decl)));
+	pointer_set_insert (container->decls_seen,
+			    TYPE_CANONICAL (TREE_TYPE (decl)));
     }
 
   if (DECL_NAME (decl) != NULL_TREE)
@@ -585,9 +682,11 @@  go_output_typedef (struct goout_containe
 	return;
       *slot = CONST_CAST (void *, (const void *) type);
 
-      fprintf (asm_out_file, "#GO type _%s ",
+      if (!go_format_type (container, TREE_TYPE (decl), false, false))
+	fprintf (go_dump_file, "// ");
+      fprintf (go_dump_file, "type _%s ",
 	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-      go_output_type (container, TREE_TYPE (decl), false);
+      go_output_type (container);
       pointer_set_insert (container->decls_seen, decl);
     }
   else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
@@ -602,38 +701,48 @@  go_output_typedef (struct goout_containe
          return;
        *slot = CONST_CAST (void *, (const void *) type);
 
-       fprintf (asm_out_file, "#GO type _%s ",
+       if (!go_format_type (container, TREE_TYPE (decl), false, false))
+	 fprintf (go_dump_file, "// ");
+       fprintf (go_dump_file, "type _%s ",
 	       IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))));
-       go_output_type (container, TREE_TYPE (decl), false);
+       go_output_type (container);
     }
   else
     return;
 
-  fprintf (asm_out_file, "\n");
+  fprintf (go_dump_file, "\n");
 }
 
 /* Output a variable.  */
 
 static void
-go_output_var (struct goout_container *container, tree decl)
+go_output_var (struct godump_container *container, tree decl)
 {
   if (pointer_set_contains (container->decls_seen, decl)
       || pointer_set_contains (container->decls_seen, DECL_NAME (decl)))
     return;
   pointer_set_insert (container->decls_seen, decl);
   pointer_set_insert (container->decls_seen, DECL_NAME (decl));
-  fprintf (asm_out_file, "#GO var _%s ",
+  if (!go_format_type (container, TREE_TYPE (decl), true, false))
+    fprintf (go_dump_file, "// ");
+  fprintf (go_dump_file, "var _%s ",
 	   IDENTIFIER_POINTER (DECL_NAME (decl)));
-  go_output_type (container, TREE_TYPE (decl), false);
-  fprintf (asm_out_file, "\n");
-}
-
-/* For the type and keywords hash tables.  */
+  go_output_type (container);
+  fprintf (go_dump_file, "\n");
 
-static int
-string_hash_eq (const void *y1, const void *y2)
-{
-  return strcmp ((const char *) y1, (const char *) y2) == 0;
+  /* Sometimes an extern variable is declared with an unknown struct
+     type.  */
+  if (TYPE_NAME (TREE_TYPE (decl)) != NULL_TREE
+      && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
+    {
+      tree type_name = TYPE_NAME (TREE_TYPE (decl));
+      if (TREE_CODE (type_name) == IDENTIFIER_NODE)
+	pointer_set_insert (container->pot_dummy_types,
+			    IDENTIFIER_POINTER (type_name));
+      else if (TREE_CODE (type_name) == TYPE_DECL)
+	pointer_set_insert (container->pot_dummy_types,
+			    IDENTIFIER_POINTER (DECL_NAME (type_name)));
+    }
 }
 
 /* Build a hash table with the Go keywords.  */
@@ -646,7 +755,7 @@  static const char * const keywords[] = {
 };
 
 static void
-keyword_hash_init (struct goout_container *container)
+keyword_hash_init (struct godump_container *container)
 {
   size_t i;
   size_t count = sizeof (keywords) / sizeof (keywords[0]);
@@ -659,31 +768,33 @@  keyword_hash_init (struct goout_containe
     }
 }
 
-/* Traversing the pot_dummy_types and seeing which types are present in the
-   global types hash table and creating dummy definitions if not found.
-   This function is invoked by pointer_set_traverse.  */
+/* Traversing the pot_dummy_types and seeing which types are present
+   in the global types hash table and creating dummy definitions if
+   not found.  This function is invoked by pointer_set_traverse.  */
 
 static bool
 find_dummy_types (const void *ptr, void *adata)
 {
-  struct goout_container *data = (struct goout_container *) adata;
-  void **slot;
+  struct godump_container *data = (struct godump_container *) adata;
   const char *type = (const char *) ptr;
+  void **slot;
 
   slot = htab_find_slot (data->type_hash, type, NO_INSERT);
   if (slot == NULL)
-    fprintf (asm_out_file, "#GO type _%s struct {};\n", type);
+    fprintf (go_dump_file, "type _%s struct {}\n", type);
   return true;
 }
 
 /* Output symbols.  */
 
 static void
-go_finish (const char *filename ATTRIBUTE_UNUSED)
+go_finish (const char *filename)
 {
-  struct goout_container container;
+  struct godump_container container;
+  unsigned int ix;
+  tree decl;
 
-  tree q;
+  real_debug_hooks->finish (filename);
 
   container.decls_seen = pointer_set_create ();
   container.pot_dummy_types = pointer_set_create ();
@@ -691,16 +802,12 @@  go_finish (const char *filename ATTRIBUT
                                      string_hash_eq, NULL);
   container.keyword_hash = htab_create (50, htab_hash_string,
                                         string_hash_eq, NULL);
+  obstack_init (&container.type_obstack);
 
   keyword_hash_init (&container);
 
-  q = nreverse (queue);
-  queue = NULL_TREE;
-  for (; q != NULL_TREE; q = TREE_CHAIN (q))
+  FOR_EACH_VEC_ELT (tree, queue, ix, decl)
     {
-      tree decl;
-
-      decl = TREE_VALUE (q);
       switch (TREE_CODE (decl))
 	{
 	case FUNCTION_DECL:
@@ -719,6 +826,7 @@  go_finish (const char *filename ATTRIBUT
 	  gcc_unreachable();
 	}
     }
+
   /* To emit dummy definitions.  */
   pointer_set_traverse (container.pot_dummy_types, find_dummy_types,
                         (void *) &container);
@@ -727,47 +835,36 @@  go_finish (const char *filename ATTRIBUT
   pointer_set_destroy (container.pot_dummy_types);
   htab_delete (container.type_hash);
   htab_delete (container.keyword_hash);
+  obstack_free (&container.type_obstack, NULL);
+
+  queue = NULL;
 }
 
-/* The debug hooks structure.  */
+/* Set up our hooks.  */
 
-const struct gcc_debug_hooks go_debug_hooks =
+const struct gcc_debug_hooks *
+dump_go_spec_init (const char *filename, const struct gcc_debug_hooks *hooks)
 {
-  go_init,				/* init */
-  go_finish,				/* finish */
-  debug_nothing_void,			/* assembly_start */
-  go_define,				/* define */
-  go_undef,				/* undef */
-  debug_nothing_int_charstar,		/* start_source_file */
-  debug_nothing_int,			/* end_source_file */
-  debug_nothing_int_int,		/* begin_block */
-  debug_nothing_int_int,		/* end_block */
-  debug_true_const_tree,		/* ignore_block */
-  debug_nothing_int_charstar_int_bool,	/* source_line */
-  debug_nothing_int_charstar,		/* begin_prologue */
-  debug_nothing_int_charstar,		/* end_prologue */
-  debug_nothing_int_charstar,		/* begin_epilogue */
-  debug_nothing_int_charstar,		/* end_epilogue */
-  debug_nothing_tree,			/* begin_function */
-  debug_nothing_int,			/* end_function */
-  go_decl,				/* function_decl */
-  go_decl,				/* global_decl */
-  go_type_decl,				/* type_decl */
-  debug_nothing_tree_tree_tree_bool,	/* imported_module_or_decl */
-  debug_nothing_tree,			/* deferred_inline_function */
-  debug_nothing_tree,			/* outlining_inline_function */
-  debug_nothing_rtx,			/* label */
-  debug_nothing_int,			/* handle_pch */
-  debug_nothing_rtx,			/* var_location */
-  debug_nothing_void,			/* switch_text_section */
-  debug_nothing_tree,	        	/* direct_call */
-  debug_nothing_tree_int,		/* virtual_call_token */
-  debug_nothing_rtx_rtx,		/* copy_call_info */
-  debug_nothing_uid,			/* virtual_call */
-  debug_nothing_tree_tree,		/* set_name */
-  0                             	/* start_end_main_source_file */
-};
+  go_dump_file = fopen (filename, "w");
+  if (go_dump_file == NULL)
+    {
+      error ("could not open Go dump file %qs: %m", filename);
+      return hooks;
+    }
+
+  go_debug_hooks = *hooks;
+  real_debug_hooks = hooks;
 
-#endif /* defined(GO_DEBUG_INFO) */
+  go_debug_hooks.finish = go_finish;
+  go_debug_hooks.define = go_define;
+  go_debug_hooks.undef = go_undef;
+  go_debug_hooks.function_decl = go_function_decl;
+  go_debug_hooks.global_decl = go_global_decl;
+  go_debug_hooks.type_decl = go_type_decl;
+
+  macro_hash = htab_create (100, htab_hash_string, string_hash_eq, NULL);
+
+  return &go_debug_hooks;
+}
 
-#include "gt-goout.h"
+#include "gt-godump.h"
Index: tree.h
===================================================================
--- tree.h	(revision 166266)
+++ tree.h	(working copy)
@@ -2076,9 +2076,6 @@  struct GTY(()) tree_block {
 #define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
 #define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
 #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
-#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
-#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
-#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
 #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
 #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
 #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
@@ -2300,6 +2297,33 @@  extern enum machine_mode vector_type_mod
 #define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
   (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
 
+/* The debug output functions use the symtab union field to store
+   information specific to the debugging format.  The different debug
+   output hooks store different types in the union field.  These three
+   macros are used to access different fields in the union.  The debug
+   hooks are responsible for consistently using only a specific
+   macro.  */
+
+/* Symtab field as an integer.  Used by stabs generator in dbxout.c to
+   hold the type's number in the generated stabs.  */
+#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
+
+/* Symtab field as a string.  Used by COFF generator in sdbout.c to
+   hold struct/union type tag names.  */
+#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
+
+/* Symtab field as a pointer to a DWARF DIE.  Used by DWARF generator
+   in dwarf2out.c to point to the DIE generated for the type.  */
+#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
+
+/* The garbage collector needs to know the interpretation of the
+   symtab field.  These constants represent the different types in the
+   union.  */
+
+#define TYPE_SYMTAB_IS_ADDRESS (0)
+#define TYPE_SYMTAB_IS_POINTER (1)
+#define TYPE_SYMTAB_IS_DIE (2)
+
 struct die_struct;
 
 struct GTY(()) tree_type {
@@ -2333,10 +2357,10 @@  struct GTY(()) tree_type {
   tree pointer_to;
   tree reference_to;
   union tree_type_symtab {
-    int GTY ((tag ("0"))) address;
-    const char * GTY ((tag ("1"))) pointer;
-    struct die_struct * GTY ((tag ("2"))) die;
-  } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
+    int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
+    const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer;
+    struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
+  } GTY ((desc ("debug_hooks->tree_type_symtab_field"),
 	  descbits ("2"))) symtab;
   tree name;
   tree minval;
Index: toplev.c
===================================================================
--- toplev.c	(revision 166266)
+++ toplev.c	(working copy)
@@ -1064,7 +1064,7 @@  decode_d_option (const char *arg)
 /* Indexed by enum debug_info_type.  */
 const char *const debug_type_names[] =
 {
-  "none", "stabs", "coff", "dwarf-2", "xcoff", "vms", "go"
+  "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
 };
 
 /* Print version information to FILE.
@@ -1939,10 +1939,6 @@  process_options (void)
   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
     debug_hooks = &vmsdbg_debug_hooks;
 #endif
-#ifdef GO_DEBUGGING_INFO
-  else if (write_symbols == GO_DEBUG)
-    debug_hooks = &go_debug_hooks;
-#endif
   else
     error ("target system does not support the \"%s\" debug format",
 	   debug_type_names[write_symbols]);
@@ -1966,6 +1962,12 @@  process_options (void)
       flag_var_tracking_uninit = 0;
     }
 
+  /* The debug hooks are used to implement -fdump-go-spec because it
+     gives a simple and stable API for all the information we need to
+     dump.  */
+  if (flag_dump_go_spec != NULL)
+    debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
+
   /* If the user specifically requested variable tracking with tagging
      uninitialized variables, we need to turn on variable tracking.
      (We already determined above that variable tracking is feasible.)  */
Index: vmsdbgout.c
===================================================================
--- vmsdbgout.c	(revision 166266)
+++ vmsdbgout.c	(working copy)
@@ -210,7 +210,8 @@  const struct gcc_debug_hooks vmsdbg_debu
    debug_nothing_rtx_rtx,	  /* copy_call_info */
    debug_nothing_uid,		  /* virtual_call */
    debug_nothing_tree_tree,	  /* set_name */
-   0                              /* start_end_main_source_file */
+   0,                             /* start_end_main_source_file */
+   TYPE_SYMTAB_IS_ADDRESS         /* tree_type_symtab_field */
 };
 
 /* Definitions of defaults for assembler-dependent names of various
Index: debug.c
===================================================================
--- debug.c	(revision 166266)
+++ debug.c	(working copy)
@@ -20,6 +20,7 @@ 
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
+#include "tree.h"
 #include "debug.h"
 
 /* The do-nothing debug hooks.  */
@@ -57,7 +58,8 @@  const struct gcc_debug_hooks do_nothing_
   debug_nothing_rtx_rtx,	         /* copy_call_info */
   debug_nothing_uid,		         /* virtual_call */
   debug_nothing_tree_tree,		 /* set_name */
-  0                                      /* start_end_main_source_file */
+  0,                                     /* start_end_main_source_file */
+  TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
 };
 
 /* This file contains implementations of each debug hook that do
Index: debug.h
===================================================================
--- debug.h	(revision 166266)
+++ debug.h	(working copy)
@@ -165,6 +165,10 @@  struct gcc_debug_hooks
   /* This is 1 if the debug writer wants to see start and end commands for the
      main source files, and 0 otherwise.  */
   int start_end_main_source_file;
+
+  /* The type of symtab field used by these debug hooks.  This is one
+     of the TYPE_SYMTAB_IS_xxx values defined in tree.h.  */
+  int tree_type_symtab_field;
 };
 
 extern const struct gcc_debug_hooks *debug_hooks;
@@ -193,7 +197,6 @@  extern const struct gcc_debug_hooks sdb_
 extern const struct gcc_debug_hooks xcoff_debug_hooks;
 extern const struct gcc_debug_hooks dwarf2_debug_hooks;
 extern const struct gcc_debug_hooks vmsdbg_debug_hooks;
-extern const struct gcc_debug_hooks go_debug_hooks;
 
 /* Dwarf2 frame information.  */
 
@@ -218,4 +221,9 @@  extern int symbol_queue_index;
 const char *remap_debug_filename (const char *);
 void add_debug_prefix_map (const char *);
 
+/* For -fdump-go-spec.  */
+
+extern const struct gcc_debug_hooks *
+dump_go_spec_init (const char *, const struct gcc_debug_hooks *);
+
 #endif /* !GCC_DEBUG_H  */
Index: dbxout.c
===================================================================
--- dbxout.c	(revision 166266)
+++ dbxout.c	(working copy)
@@ -384,7 +384,8 @@  const struct gcc_debug_hooks dbx_debug_h
   debug_nothing_rtx_rtx,	         /* copy_call_info */
   debug_nothing_uid,		         /* virtual_call */
   debug_nothing_tree_tree,		 /* set_name */
-  0                                      /* start_end_main_source_file */
+  0,                                     /* start_end_main_source_file */
+  TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
 };
 #endif /* DBX_DEBUGGING_INFO  */
 
@@ -423,7 +424,8 @@  const struct gcc_debug_hooks xcoff_debug
   debug_nothing_rtx_rtx,	         /* copy_call_info */
   debug_nothing_uid,		         /* virtual_call */
   debug_nothing_tree_tree,	         /* set_name */
-  0                                      /* start_end_main_source_file */
+  0,                                     /* start_end_main_source_file */
+  TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
 };
 #endif /* XCOFF_DEBUGGING_INFO  */
 
Index: dwarf2out.c
===================================================================
--- dwarf2out.c	(revision 166266)
+++ dwarf2out.c	(working copy)
@@ -5648,7 +5648,8 @@  const struct gcc_debug_hooks dwarf2_debu
   dwarf2out_copy_call_info,
   dwarf2out_virtual_call,
   dwarf2out_set_name,
-  1                             /* start_end_main_source_file */
+  1,                            /* start_end_main_source_file */
+  TYPE_SYMTAB_IS_DIE            /* tree_type_symtab_field */
 };
 
 /* NOTE: In the comments in this file, many references are made to
Index: opts.c
===================================================================
--- opts.c	(revision 166266)
+++ opts.c	(working copy)
@@ -2170,10 +2170,6 @@  common_handle_option (struct gcc_options
       set_debug_level (NO_DEBUG, 2, arg);
       break;
 
-    case OPT_ggo:
-      set_debug_level (GO_DEBUG, 1, "3");
-      break;
-
     case OPT_gstabs:
     case OPT_gstabs_:
       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
Index: sdbout.c
===================================================================
--- sdbout.c	(revision 166266)
+++ sdbout.c	(working copy)
@@ -345,7 +345,8 @@  const struct gcc_debug_hooks sdb_debug_h
   debug_nothing_rtx_rtx,	         /* copy_call_info */
   debug_nothing_uid,		         /* virtual_call */
   debug_nothing_tree_tree,		 /* set_name */
-  0                                      /* start_end_main_source_file */
+  0,                                     /* start_end_main_source_file */
+  TYPE_SYMTAB_IS_POINTER                 /* tree_type_symtab_field */
 };
 
 /* Return a unique string to name an anonymous type.  */
@@ -1704,47 +1705,6 @@  sdbout_init (const char *input_file_name
   preinit_symbols = 0;
 }
 
-#else  /* SDB_DEBUGGING_INFO */
-
-/* This should never be used, but its address is needed for comparisons.  */
-const struct gcc_debug_hooks sdb_debug_hooks =
-{
-  0,		/* init */
-  0,		/* finish */
-  0,		/* assembly_start */
-  0,		/* define */
-  0,		/* undef */
-  0,		/* start_source_file */
-  0,		/* end_source_file */
-  0,		/* begin_block */
-  0,		/* end_block */
-  0,		/* ignore_block */
-  0,		/* source_line */
-  0,		/* begin_prologue */
-  0,		/* end_prologue */
-  0,		/* begin_epilogue */
-  0,		/* end_epilogue */
-  0,		/* begin_function */
-  0,		/* end_function */
-  0,		/* function_decl */
-  0,		/* global_decl */
-  0,		/* type_decl */
-  0,		/* imported_module_or_decl */
-  0,		/* deferred_inline_function */
-  0,		/* outlining_inline_function */
-  0,		/* label */
-  0,		/* handle_pch */
-  0,		/* var_location */
-  0,		/* switch_text_section */
-  0,		/* direct_call */
-  0,		/* virtual_call_token */
-  0,	        /* copy_call_info */
-  0,		/* virtual_call */
-  0,		/* set_name */
-  0		/* start_end_main_source_file */
-};
-
-
 #endif /* SDB_DEBUGGING_INFO */
 
 #include "gt-sdbout.h"
Index: flag-types.h
===================================================================
--- flag-types.h	(revision 166266)
+++ flag-types.h	(working copy)
@@ -30,9 +30,8 @@  enum debug_info_type
   DWARF2_DEBUG,	    /* Write Dwarf v2 debug info (using dwarf2out.c).  */
   XCOFF_DEBUG,	    /* Write IBM/Xcoff debug info (using dbxout.c).  */
   VMS_DEBUG,        /* Write VMS debug info (using vmsdbgout.c).  */
-  VMS_AND_DWARF2_DEBUG, /* Write VMS debug info (using vmsdbgout.c).
-                           and DWARF v2 debug info (using dwarf2out.c).  */
-  GO_DEBUG	    /* Write Go language exports (using goout.c).  */
+  VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
+                          and DWARF v2 debug info (using dwarf2out.c).  */
 };
 
 enum debug_info_level
Index: common.opt
===================================================================
--- common.opt	(revision 166266)
+++ common.opt	(working copy)
@@ -778,6 +778,10 @@  fdump-final-insns=
 Common RejectNegative Joined Var(flag_dump_final_insns)
 -fdump-final-insns=filename	Dump to filename the insns at the end of translation
 
+fdump-go-spec=
+Common RejectNegative Joined Var(flag_dump_go_spec)
+-fdump-go-spec=filename	Write all declarations to file as Go code
+
 fdump-noaddr
 Common Report Var(flag_dump_noaddr)
 Suppress output of addresses in debugging dumps
@@ -1868,10 +1872,6 @@  ggdb
 Common JoinedOrMissing
 Generate debug information in default extended format
 
-ggo
-Common
-Generate Go language exports
-
 gstabs
 Common JoinedOrMissing Negative(gstabs+)
 Generate debug information in STABS format
Index: goout.c
===================================================================
--- goout.c	(revision 166266)
+++ goout.c	(working copy)
@@ -1,773 +0,0 @@ 
-/* Output Go language descriptions of types.
-   Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
-   Written by Ian Lance Taylor <iant@google.com>.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
-
-/* This file is used during the build process to emit Go language
-   descriptions of declarations from C header files.  It uses the
-   debug info hooks to emit the descriptions.  The Go language
-   descriptions then become part of the Go runtime support
-   library.
-
-   All global names are output with a leading underscore, so that they
-   are all hidden in Go.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "tree.h"
-#include "ggc.h"
-#include "pointer-set.h"
-#include "output.h"
-#include "debug.h"
-
-/* A queue of decls to output.  */
-
-static GTY(()) tree queue;
-
-/* A hash table of macros we have seen.  Using macro_hash_node is
-   awkward but I don't know how to avoid it for the GTY machinery.  */
-
-struct GTY(()) macro_hash_node
-{
-  char *name;
-};
-
-struct GTY(()) goout_container
-{
-  /* DECLs that we have already seen.  */
-  struct pointer_set_t *decls_seen;
-
-  /* Types which may potentially have to be defined as dummy
-     types.  */
-  struct pointer_set_t *pot_dummy_types;
-
-  /* Go keywords.  */
-  htab_t keyword_hash;
-
-  /* Global type definitions.  */
-  htab_t type_hash;
-};
-
-static GTY ((param_is (struct macro_hash_node))) htab_t macro_hash;
-
-#ifdef GO_DEBUGGING_INFO
-
-/* For the macro hash table.  */
-
-static hashval_t
-macro_hash_hash (const void *x)
-{
-  return htab_hash_string (((const struct macro_hash_node *) x)->name);
-}
-
-static int
-macro_hash_eq (const void *x1, const void *x2)
-{
-  return strcmp ((((const struct macro_hash_node *) x1)->name),
-		 (const char *) x2) == 0;
-}
-
-/* Initialize.  */
-
-static void
-go_init (const char *filename ATTRIBUTE_UNUSED)
-{
-  macro_hash = htab_create (100, macro_hash_hash, macro_hash_eq, NULL);
-}
-
-/* A macro definition.  */
-
-static void
-go_define (unsigned int lineno ATTRIBUTE_UNUSED, const char *buffer)
-{
-  const char *p;
-  const char *name_end;
-  char *out_buffer;
-  char *q;
-  char *copy;
-  void **slot;
-
-  /* Skip macro functions.  */
-  for (p = buffer; *p != '\0' && *p != ' '; ++p)
-    if (*p == '(')
-      return;
-
-  if (*p == '\0')
-    return;
-
-  name_end = p;
-
-  ++p;
-  if (*p == '\0')
-    return;
-
-  copy = XNEWVEC (char, name_end - buffer + 1);
-  memcpy (copy, buffer, name_end - buffer);
-  copy[name_end - buffer] = '\0';
-
-  slot = htab_find_slot_with_hash (macro_hash, copy, htab_hash_string (copy),
-				   NO_INSERT);
-  if (slot != NULL)
-    {
-      XDELETEVEC (copy);
-      return;
-    }
-
-  /* For simplicity, we force all names to be hidden by adding an
-     initial underscore, and let the user undo this as needed.  */
-  out_buffer = XNEWVEC (char, strlen (p) * 2 + 1);
-  q = out_buffer;
-  while (*p != '\0')
-    {
-      if (ISALPHA (*p) || *p == '_')
-	{
-	  const char *start;
-	  char *n;
-
-	  start = p;
-	  while (ISALNUM (*p) || *p == '_')
-	    ++p;
-	  n = (char *) alloca (p - start + 1);
-	  memcpy (n, start, p - start);
-	  n[p - start] = '\0';
-	  slot = htab_find_slot_with_hash (macro_hash, n,
-					   htab_hash_string (n),
-					   NO_INSERT);
-	  if (slot == NULL
-	      || ((struct macro_hash_node *) *slot)->name == NULL)
-	    {
-	      /* This is a reference to a name which was not defined
-		 as a macro.  */
-	      fprintf (asm_out_file, "#GO unknowndefine %s\n", buffer);
-	      return;
-	    }
-
-	  *q++ = '_';
-	  memcpy (q, start, p - start);
-	  q += p - start;
-	}
-      else if (ISDIGIT (*p)
-	       || (*p == '.' && ISDIGIT (p[1])))
-	{
-	  const char *start;
-	  bool is_hex;
-
-	  start = p;
-	  is_hex = false;
-	  if (*p == '0' && (p[1] == 'x' || p[1] == 'X'))
-	    {
-	      p += 2;
-	      is_hex = true;
-	    }
-	  while (ISDIGIT (*p) || *p == '.' || *p == 'e' || *p == 'E'
-		 || (is_hex
-		     && ((*p >= 'a' && *p <= 'f')
-			 || (*p >= 'A' && *p <= 'F'))))
-	    ++p;
-	  memcpy (q, start, p - start);
-	  q += p - start;
-	  while (*p == 'u' || *p == 'U' || *p == 'l' || *p == 'L'
-		 || *p == 'f' || *p == 'F'
-		 || *p == 'd' || *p == 'D')
-	    {
-	      /* Go doesn't use any of these trailing type
-		 modifiers.  */
-	      ++p;
-	    }
-	}
-      else if (ISSPACE (*p)
-	       || *p == '+' || *p == '-'
-	       || *p == '*' || *p == '/' || *p == '%'
-	       || *p == '|' || *p == '&'
-	       || *p == '>' || *p == '<'
-	       || *p == '!'
-	       || *p == '(' || *p == ')'
-	       || *p == '"' || *p == '\'')
-	*q++ = *p++;
-      else
-	{
-	  /* Something we don't recognize.  */
-	  fprintf (asm_out_file, "#GO unknowndefine %s\n", buffer);
-	  return;
-	}
-    }
-  *q = '\0';
-
-  slot = htab_find_slot_with_hash (macro_hash, copy, htab_hash_string (copy),
-				   INSERT);
-  *slot = XNEW (struct macro_hash_node);
-  ((struct macro_hash_node *) *slot)->name = copy;
-
-  fprintf (asm_out_file, "#GO const _%s = %s\n", copy, out_buffer);
-
-  XDELETEVEC (out_buffer);
-}
-
-/* A macro undef.  */
-
-static void
-go_undef (unsigned int lineno ATTRIBUTE_UNUSED,
-	  const char *buffer ATTRIBUTE_UNUSED)
-{
-  void **slot;
-
-  slot = htab_find_slot_with_hash (macro_hash, buffer,
-				   htab_hash_string (buffer),
-				   NO_INSERT);
-  if (slot == NULL)
-    return;
-  fprintf (asm_out_file, "#GO undef _%s\n", buffer);
-  /* We don't delete the slot from the hash table because that will
-     cause a duplicate const definition.  */
-}
-
-/* A function or variable decl.  */
-
-static void
-go_decl (tree decl)
-{
-  if (!TREE_PUBLIC (decl)
-      || DECL_IS_BUILTIN (decl)
-      || DECL_NAME (decl) == NULL_TREE)
-    return;
-  queue = tree_cons (NULL_TREE, decl, queue);
-}
-
-/* A type declaration.  */
-
-static void
-go_type_decl (tree decl, int local)
-{
-  if (local || DECL_IS_BUILTIN (decl))
-    return;
-  if (DECL_NAME (decl) == NULL_TREE
-      && (TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE
-	  || TREE_CODE (TYPE_NAME (TREE_TYPE (decl))) != IDENTIFIER_NODE)
-      && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
-    return;
-  queue = tree_cons (NULL_TREE, decl, queue);
-}
-
-/* Output a type.  */
-
-static void
-go_output_type (struct goout_container *container, tree type,
-		bool in_struct_or_func)
-{
-  if (TYPE_NAME (type) != NULL_TREE
-      && (pointer_set_contains (container->decls_seen, type)
-	  || pointer_set_contains (container->decls_seen, TYPE_NAME (type)))
-      && (AGGREGATE_TYPE_P (type)
-	  || POINTER_TYPE_P (type)
-	  || TREE_CODE (type) == FUNCTION_TYPE))
-    {
-      tree name;
-
-      name = TYPE_NAME (type);
-      if (TREE_CODE (name) == IDENTIFIER_NODE)
-	{
-	  fprintf (asm_out_file, "_%s", IDENTIFIER_POINTER (name));
-	  return;
-	}
-      else if (TREE_CODE (name) == TYPE_DECL)
-	{
-	  fprintf (asm_out_file, "_%s",
-		   IDENTIFIER_POINTER (DECL_NAME (name)));
-	  return;
-	}
-    }
-
-  pointer_set_insert (container->decls_seen, type);
-
-  switch (TREE_CODE (type))
-    {
-    case ENUMERAL_TYPE:
-	    fprintf (asm_out_file, "int");
-	    break;
-
-    case TYPE_DECL:
-      fprintf (asm_out_file, "_%s",
-	       IDENTIFIER_POINTER (DECL_NAME (type)));
-      break;
-
-    case INTEGER_TYPE:
-      {
-	const char *s;
-	char buf[100];
-
-	switch (TYPE_PRECISION (type))
-	  {
-	  case 8:
-	    s = TYPE_UNSIGNED (type) ? "uint8" : "int8";
-	    break;
-	  case 16:
-	    s = TYPE_UNSIGNED (type) ? "uint16" : "int16";
-	    break;
-	  case 32:
-	    s = TYPE_UNSIGNED (type) ? "uint32" : "int32";
-	    break;
-	  case 64:
-	    s = TYPE_UNSIGNED (type) ? "uint64" : "int64";
-	    break;
-	  default:
-	    snprintf (buf, sizeof buf, "INVALID-int-%u%s",
-		      TYPE_PRECISION (type),
-		      TYPE_UNSIGNED (type) ? "u" : "");
-	    s = buf;
-	    break;
-	  }
-	fprintf (asm_out_file, "%s", s);
-      }
-      break;
-
-    case REAL_TYPE:
-      {
-	const char *s;
-	char buf[100];
-
-	switch (TYPE_PRECISION (type))
-	  {
-	  case 32:
-	    s = "float32";
-	    break;
-	  case 64:
-	    s = "float64";
-	    break;
-	  case 80:
-	    s = "float80";
-	    break;
-	  default:
-	    snprintf (buf, sizeof buf, "INVALID-float-%u",
-		      TYPE_PRECISION (type));
-	    s = buf;
-	    break;
-	  }
-	fprintf (asm_out_file, "%s", s);
-      }
-      break;
-
-    case BOOLEAN_TYPE:
-      fprintf (asm_out_file, "bool");
-      break;
-
-    case POINTER_TYPE:
-      if (in_struct_or_func
-          && TYPE_NAME (TREE_TYPE (type)) != NULL_TREE
-          && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type))
-	      || (POINTER_TYPE_P (TREE_TYPE (type))
-                  && (TREE_CODE (TREE_TYPE (TREE_TYPE (type)))
-		      == FUNCTION_TYPE))))
-        {
-	  tree name;
-	  name = TYPE_NAME (TREE_TYPE (type));
-	  if (TREE_CODE (name) == IDENTIFIER_NODE)
-	    {
-	      fprintf (asm_out_file, "*_%s", IDENTIFIER_POINTER (name));
-	      /* If pointing to a struct or union, then the pointer
-		 here can be used without the struct or union definition.
-		 So this struct or union is a can be a potential dummy
-		 type.  */
-	      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
-		pointer_set_insert (container->pot_dummy_types,
-				    IDENTIFIER_POINTER (name));
-	      return;
-	    }
-	  else if (TREE_CODE (name) == TYPE_DECL)
-	    {
-	      fprintf (asm_out_file, "*_%s",
-		       IDENTIFIER_POINTER (DECL_NAME (name)));
-	      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
-		pointer_set_insert (container->pot_dummy_types,
-				    IDENTIFIER_POINTER (DECL_NAME (name)));
-	      return;
-	    }
-        }
-      if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
-	fprintf (asm_out_file, "func");
-      else
-	fprintf (asm_out_file, "*");
-      if (VOID_TYPE_P (TREE_TYPE (type)))
-	fprintf (asm_out_file, "byte");
-      else
-	go_output_type (container, TREE_TYPE (type), in_struct_or_func);
-      break;
-
-    case ARRAY_TYPE:
-      fprintf (asm_out_file, "[");
-      if (TYPE_DOMAIN (type) != NULL_TREE
-	  && TREE_CODE (TYPE_DOMAIN (type)) == INTEGER_TYPE
-	  && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
-	  && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
-	  && tree_int_cst_sgn (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == 0
-	  && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
-	  && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
-	  && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0))
-	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC "+1",
-		 tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0));
-      fprintf (asm_out_file, "]");
-      go_output_type (container, TREE_TYPE (type), in_struct_or_func);
-      break;
-
-    case UNION_TYPE:
-    case RECORD_TYPE:
-      {
-	tree field;
-	int i;
-
-	fprintf (asm_out_file, "struct { ");
-	i = 0;
-	for (field = TYPE_FIELDS (type);
-	     field != NULL_TREE;
-	     field = TREE_CHAIN (field))
-	  {
-	    if (DECL_NAME (field) == NULL)
-	      {
-		fprintf (asm_out_file, "_f%d ", i);
-		i++;
-	      }
-	    else
-              {
-		const char *var_name;
-		void **slot;
-
-		/* Start variable name with an underscore if a keyword.  */
-		var_name = IDENTIFIER_POINTER (DECL_NAME (field));
-		slot = htab_find_slot (container->keyword_hash, var_name,
-				       NO_INSERT);
-		if (slot == NULL)
-		  fprintf (asm_out_file, "%s ", var_name);
-		else
-		  fprintf (asm_out_file, "_%s ", var_name);
-	      }
-	    if (DECL_BIT_FIELD (field))
-	      fprintf (asm_out_file, "INVALID-bit-field");
-	    else
-              {
-		/* Do not expand type if a record or union type or a
-		   function pointer.  */
-		if (TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
-		    && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field))
-			|| (POINTER_TYPE_P (TREE_TYPE (field))
-			    && (TREE_CODE (TREE_TYPE (TREE_TYPE (field)))
-                                == FUNCTION_TYPE))))
-		  {
-		    tree name = TYPE_NAME (TREE_TYPE (field));
-		    if (TREE_CODE (name) == IDENTIFIER_NODE)
-		      fprintf (asm_out_file, "_%s", IDENTIFIER_POINTER (name));
-		    else if (TREE_CODE (name) == TYPE_DECL)
-		      fprintf (asm_out_file, "_%s",
-			       IDENTIFIER_POINTER (DECL_NAME (name)));
-		  }
-		else
-		  go_output_type (container, TREE_TYPE (field), true);
-              }
-	    fprintf (asm_out_file, "; ");
-
-	    /* Only output the first field of a union, and hope for
-	       the best.  */
-	    if (TREE_CODE (type) == UNION_TYPE)
-	      break;
-	  }
-	fprintf (asm_out_file, "}");
-      }
-      break;
-
-    case FUNCTION_TYPE:
-      {
-	tree args;
-	bool is_varargs;
-	tree result;
-
-	fprintf (asm_out_file, "(");
-	is_varargs = true;
-	for (args = TYPE_ARG_TYPES (type);
-	     args != NULL_TREE;
-	     args = TREE_CHAIN (args))
-	  {
-	    if (VOID_TYPE_P (TREE_VALUE (args)))
-	      {
-		gcc_assert (TREE_CHAIN (args) == NULL);
-		is_varargs = false;
-		break;
-	      }
-	    if (args != TYPE_ARG_TYPES (type))
-	      fprintf (asm_out_file, ", ");
-	    go_output_type (container, TREE_VALUE (args), true);
-	  }
-	if (is_varargs)
-	  {
-	    if (TYPE_ARG_TYPES (type) != NULL_TREE)
-	      fprintf (asm_out_file, ", ");
-	    fprintf (asm_out_file, "...");
-	  }
-	fprintf (asm_out_file, ")");
-
-	result = TREE_TYPE (type);
-	if (!VOID_TYPE_P (result))
-	  {
-	    fprintf (asm_out_file, " ");
-	    go_output_type (container, result, in_struct_or_func);
-	  }
-      }
-      break;
-
-    default:
-      fprintf (asm_out_file, "INVALID-type");
-      break;
-    }
-}
-
-/* Output a function declaration.  */
-
-static void
-go_output_fndecl (struct goout_container *container, tree decl)
-{
-  fprintf (asm_out_file, "#GO func _%s ",
-	   IDENTIFIER_POINTER (DECL_NAME (decl)));
-  go_output_type (container, TREE_TYPE (decl), false);
-  fprintf (asm_out_file, " __asm__(\"%s\")\n",
-	   IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
-}
-
-/* Output a typedef or something like a struct definition.  */
-
-static void
-go_output_typedef (struct goout_container *container, tree decl)
-{
-  /* If we have an enum type, output the enum constants
-     separately.  */
-  if (TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE
-      && TYPE_SIZE (TREE_TYPE (decl)) != 0
-      && !pointer_set_contains (container->decls_seen, TREE_TYPE (decl))
-      && (TYPE_CANONICAL (TREE_TYPE (decl)) == NULL_TREE
-	  || !pointer_set_contains (container->decls_seen,
-				    TYPE_CANONICAL (TREE_TYPE (decl)))))
-    {
-      tree element;
-
-      for (element = TYPE_VALUES (TREE_TYPE (decl));
-	   element != NULL_TREE;
-	   element = TREE_CHAIN (element))
-	fprintf (asm_out_file, "#GO const _%s = " HOST_WIDE_INT_PRINT_DEC "\n",
-		 IDENTIFIER_POINTER (TREE_PURPOSE (element)),
-		 tree_low_cst (TREE_VALUE (element), 0));
-      pointer_set_insert (container->decls_seen, TREE_TYPE (decl));
-      if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE)
-	pointer_set_insert (container->decls_seen, TYPE_CANONICAL (TREE_TYPE (decl)));
-    }
-
-  if (DECL_NAME (decl) != NULL_TREE)
-    {
-      void **slot;
-      const char *type;
-
-      type = IDENTIFIER_POINTER (DECL_NAME (decl));
-      /* If type defined already, skip.  */
-      slot = htab_find_slot (container->type_hash, type, INSERT);
-      if (*slot != NULL)
-	return;
-      *slot = CONST_CAST (void *, (const void *) type);
-
-      fprintf (asm_out_file, "#GO type _%s ",
-	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-      go_output_type (container, TREE_TYPE (decl), false);
-      pointer_set_insert (container->decls_seen, decl);
-    }
-  else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
-    {
-       void **slot;
-       const char *type;
-
-       type = IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE ((decl))));
-       /* If type defined already, skip.  */
-       slot = htab_find_slot (container->type_hash, type, INSERT);
-       if (*slot != NULL)
-         return;
-       *slot = CONST_CAST (void *, (const void *) type);
-
-       fprintf (asm_out_file, "#GO type _%s ",
-	       IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))));
-       go_output_type (container, TREE_TYPE (decl), false);
-    }
-  else
-    return;
-
-  fprintf (asm_out_file, "\n");
-}
-
-/* Output a variable.  */
-
-static void
-go_output_var (struct goout_container *container, tree decl)
-{
-  if (pointer_set_contains (container->decls_seen, decl)
-      || pointer_set_contains (container->decls_seen, DECL_NAME (decl)))
-    return;
-  pointer_set_insert (container->decls_seen, decl);
-  pointer_set_insert (container->decls_seen, DECL_NAME (decl));
-  fprintf (asm_out_file, "#GO var _%s ",
-	   IDENTIFIER_POINTER (DECL_NAME (decl)));
-  go_output_type (container, TREE_TYPE (decl), false);
-  fprintf (asm_out_file, "\n");
-}
-
-/* For the type and keywords hash tables.  */
-
-static int
-string_hash_eq (const void *y1, const void *y2)
-{
-  return strcmp ((const char *) y1, (const char *) y2) == 0;
-}
-
-/* Build a hash table with the Go keywords.  */
-
-static const char * const keywords[] = {
-  "__asm__", "break", "case", "chan", "const", "continue", "default",
-  "defer", "else", "fallthrough", "for", "func", "go", "goto", "if",
-  "import", "interface", "map", "package", "range", "return", "select",
-  "struct", "switch", "type", "var"
-};
-
-static void
-keyword_hash_init (struct goout_container *container)
-{
-  size_t i;
-  size_t count = sizeof (keywords) / sizeof (keywords[0]);
-  void **slot;
-
-  for (i = 0; i < count; i++)
-    {
-      slot = htab_find_slot (container->keyword_hash, keywords[i], INSERT);
-      *slot = CONST_CAST (void *, (const void *) keywords[i]);
-    }
-}
-
-/* Traversing the pot_dummy_types and seeing which types are present in the
-   global types hash table and creating dummy definitions if not found.
-   This function is invoked by pointer_set_traverse.  */
-
-static bool
-find_dummy_types (const void *ptr, void *adata)
-{
-  struct goout_container *data = (struct goout_container *) adata;
-  void **slot;
-  const char *type = (const char *) ptr;
-
-  slot = htab_find_slot (data->type_hash, type, NO_INSERT);
-  if (slot == NULL)
-    fprintf (asm_out_file, "#GO type _%s struct {};\n", type);
-  return true;
-}
-
-/* Output symbols.  */
-
-static void
-go_finish (const char *filename ATTRIBUTE_UNUSED)
-{
-  struct goout_container container;
-
-  tree q;
-
-  container.decls_seen = pointer_set_create ();
-  container.pot_dummy_types = pointer_set_create ();
-  container.type_hash = htab_create (100, htab_hash_string,
-                                     string_hash_eq, NULL);
-  container.keyword_hash = htab_create (50, htab_hash_string,
-                                        string_hash_eq, NULL);
-
-  keyword_hash_init (&container);
-
-  q = nreverse (queue);
-  queue = NULL_TREE;
-  for (; q != NULL_TREE; q = TREE_CHAIN (q))
-    {
-      tree decl;
-
-      decl = TREE_VALUE (q);
-      switch (TREE_CODE (decl))
-	{
-	case FUNCTION_DECL:
-	  go_output_fndecl (&container, decl);
-	  break;
-
-	case TYPE_DECL:
-	  go_output_typedef (&container, decl);
-	  break;
-
-	case VAR_DECL:
-	  go_output_var (&container, decl);
-	  break;
-
-	default:
-	  gcc_unreachable();
-	}
-    }
-  /* To emit dummy definitions.  */
-  pointer_set_traverse (container.pot_dummy_types, find_dummy_types,
-                        (void *) &container);
-
-  pointer_set_destroy (container.decls_seen);
-  pointer_set_destroy (container.pot_dummy_types);
-  htab_delete (container.type_hash);
-  htab_delete (container.keyword_hash);
-}
-
-/* The debug hooks structure.  */
-
-const struct gcc_debug_hooks go_debug_hooks =
-{
-  go_init,				/* init */
-  go_finish,				/* finish */
-  debug_nothing_void,			/* assembly_start */
-  go_define,				/* define */
-  go_undef,				/* undef */
-  debug_nothing_int_charstar,		/* start_source_file */
-  debug_nothing_int,			/* end_source_file */
-  debug_nothing_int_int,		/* begin_block */
-  debug_nothing_int_int,		/* end_block */
-  debug_true_const_tree,		/* ignore_block */
-  debug_nothing_int_charstar_int_bool,	/* source_line */
-  debug_nothing_int_charstar,		/* begin_prologue */
-  debug_nothing_int_charstar,		/* end_prologue */
-  debug_nothing_int_charstar,		/* begin_epilogue */
-  debug_nothing_int_charstar,		/* end_epilogue */
-  debug_nothing_tree,			/* begin_function */
-  debug_nothing_int,			/* end_function */
-  go_decl,				/* function_decl */
-  go_decl,				/* global_decl */
-  go_type_decl,				/* type_decl */
-  debug_nothing_tree_tree_tree_bool,	/* imported_module_or_decl */
-  debug_nothing_tree,			/* deferred_inline_function */
-  debug_nothing_tree,			/* outlining_inline_function */
-  debug_nothing_rtx,			/* label */
-  debug_nothing_int,			/* handle_pch */
-  debug_nothing_rtx,			/* var_location */
-  debug_nothing_void,			/* switch_text_section */
-  debug_nothing_tree,	        	/* direct_call */
-  debug_nothing_tree_int,		/* virtual_call_token */
-  debug_nothing_rtx_rtx,		/* copy_call_info */
-  debug_nothing_uid,			/* virtual_call */
-  debug_nothing_tree_tree,		/* set_name */
-  0                             	/* start_end_main_source_file */
-};
-
-#endif /* defined(GO_DEBUG_INFO) */
-
-#include "gt-goout.h"
Index: Makefile.in
===================================================================
--- Makefile.in	(revision 166266)
+++ Makefile.in	(working copy)
@@ -1237,7 +1237,7 @@  OBJS-common = \
 	gimple-low.o \
 	gimple-pretty-print.o \
 	gimplify.o \
-	goout.o \
+	godump.o \
 	graph.o \
 	graphds.o \
 	graphite.o \
@@ -2949,7 +2949,7 @@  dbxout.o : dbxout.c $(CONFIG_H) $(SYSTEM
    $(RTL_H) $(FLAGS_H) $(REGS_H) debug.h $(TM_P_H) $(TARGET_H) $(FUNCTION_H) \
    langhooks.h insn-config.h reload.h $(GSTAB_H) xcoffout.h output.h dbxout.h \
    $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) $(GGC_H) $(OBSTACK_H) $(EXPR_H) gt-dbxout.h
-debug.o : debug.c debug.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H)
+debug.o : debug.c debug.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H)
 sdbout.o : sdbout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) debug.h \
    $(TREE_H) $(GGC_H) $(RTL_H) $(REGS_H) $(FLAGS_H) insn-config.h \
    output.h $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) $(TM_P_H) gsyms.h langhooks.h $(TARGET_H) sdbout.h \
@@ -2969,8 +2969,8 @@  vmsdbgout.o : vmsdbgout.c $(CONFIG_H) $(
 xcoffout.o : xcoffout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
    $(TREE_H) $(RTL_H) xcoffout.h $(FLAGS_H) $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) output.h dbxout.h \
    $(GGC_H) $(TARGET_H) debug.h $(GSTAB_H) xcoff.h
-goout.o : goout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
-   $(GGC_H) pointer-set.h output.h debug.h
+godump.o : godump.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(DIAGNOSTIC_CORE_H) \
+   $(TREE_H) $(GGC_H) pointer-set.h $(OBSTACK_H) debug.h
 emit-rtl.o : emit-rtl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
    $(TREE_H) $(FLAGS_H) $(FUNCTION_H) $(REGS_H) insn-config.h $(RECOG_H) \
    $(GGC_H) $(EXPR_H) hard-reg-set.h $(BITMAP_H) $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) $(BASIC_BLOCK_H) \
@@ -3743,7 +3743,7 @@  GTFILES = $(CPP_ID_DATA_H) $(srcdir)/inp
   $(srcdir)/emit-rtl.c $(srcdir)/except.h $(srcdir)/explow.c $(srcdir)/expr.c \
   $(srcdir)/expr.h \
   $(srcdir)/function.c $(srcdir)/except.c \
-  $(srcdir)/gcse.c $(srcdir)/goout.c \
+  $(srcdir)/gcse.c $(srcdir)/godump.c \
   $(srcdir)/integrate.c $(srcdir)/lists.c $(srcdir)/optabs.c \
   $(srcdir)/profile.c $(srcdir)/mcf.c \
   $(srcdir)/reg-stack.c $(srcdir)/cfglayout.c $(srcdir)/cfglayout.h \
Index: c-family/c-lex.c
===================================================================
--- c-family/c-lex.c	(revision 166266)
+++ c-family/c-lex.c	(working copy)
@@ -87,10 +87,10 @@  init_c_lex (void)
   cb->read_pch = c_common_read_pch;
 
   /* Set the debug callbacks if we can use them.  */
-  if (debug_info_level == DINFO_LEVEL_VERBOSE
-      && (write_symbols == DWARF2_DEBUG
-	  || write_symbols == VMS_AND_DWARF2_DEBUG
-	  || write_symbols == GO_DEBUG))
+  if ((debug_info_level == DINFO_LEVEL_VERBOSE
+       && (write_symbols == DWARF2_DEBUG
+	   || write_symbols == VMS_AND_DWARF2_DEBUG))
+      || flag_dump_go_spec != NULL)
     {
       cb->define = cb_define;
       cb->undef = cb_undef;