--- a/gcc/godump.c	Sun Aug 21 07:07:55 2011 +0900
+++ b/gcc/godump.c	Fri Oct 27 22:46:09 2017 +0900
@@ -1,5 +1,5 @@
 /* Output Go language descriptions of types.
-   Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+   Copyright (C) 2008-2017 Free Software Foundation, Inc.
    Written by Ian Lance Taylor <iant@google.com>.
 
 This file is part of GCC.
@@ -30,12 +30,10 @@
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "tree.h"
 #include "diagnostic-core.h"
-#include "tree.h"
-#include "ggc.h"
-#include "pointer-set.h"
-#include "obstack.h"
 #include "debug.h"
+#include "stor-layout.h"
 
 /* We dump this information from the debug hooks.  This gives us a
    stable and maintainable API to hook into.  In order to work
@@ -56,13 +54,62 @@
 
 /* A queue of decls to output.  */
 
-static GTY(()) VEC(tree,gc) *queue;
+static GTY(()) vec<tree, va_gc> *queue;
 
 /* A hash table of macros we have seen.  */
 
 static htab_t macro_hash;
 
-/* For the hash tables.  */
+/* The type of a value in macro_hash.  */
+
+struct macro_hash_value
+{
+  /* The name stored in the hash table.  */
+  char *name;
+  /* The value of the macro.  */
+  char *value;
+};
+
+/* Returns the number of units necessary to represent an integer with the given
+   PRECISION (in bits).  */
+
+static inline unsigned int
+precision_to_units (unsigned int precision)
+{
+  return (precision + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+}
+
+/* Calculate the hash value for an entry in the macro hash table.  */
+
+static hashval_t
+macro_hash_hashval (const void *val)
+{
+  const struct macro_hash_value *mhval = (const struct macro_hash_value *) val;
+  return htab_hash_string (mhval->name);
+}
+
+/* Compare values in the macro hash table for equality.  */
+
+static int
+macro_hash_eq (const void *v1, const void *v2)
+{
+  const struct macro_hash_value *mhv1 = (const struct macro_hash_value *) v1;
+  const struct macro_hash_value *mhv2 = (const struct macro_hash_value *) v2;
+  return strcmp (mhv1->name, mhv2->name) == 0;
+}
+
+/* Free values deleted from the macro hash table.  */
+
+static void
+macro_hash_del (void *v)
+{
+  struct macro_hash_value *mhv = (struct macro_hash_value *) v;
+  XDELETEVEC (mhv->name);
+  XDELETEVEC (mhv->value);
+  XDELETE (mhv);
+}
+
+/* For the string hash tables.  */
 
 static int
 string_hash_eq (const void *y1, const void *y2)
@@ -77,10 +124,12 @@
 {
   const char *p;
   const char *name_end;
+  size_t out_len;
   char *out_buffer;
   char *q;
   bool saw_operand;
   bool need_operand;
+  struct macro_hash_value *mhval;
   char *copy;
   hashval_t hashval;
   void **slot;
@@ -105,17 +154,17 @@
   memcpy (copy, buffer, name_end - buffer);
   copy[name_end - buffer] = '\0';
 
+  mhval = XNEW (struct macro_hash_value);
+  mhval->name = copy;
+  mhval->value = NULL;
+
   hashval = htab_hash_string (copy);
-  slot = htab_find_slot_with_hash (macro_hash, copy, hashval, NO_INSERT);
-  if (slot != NULL)
-    {
-      XDELETEVEC (copy);
-      return;
-    }
+  slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, NO_INSERT);
 
   /* 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);
+  out_len = strlen (p) * 2 + 1;
+  out_buffer = XNEWVEC (char, out_len);
   q = out_buffer;
   saw_operand = false;
   need_operand = false;
@@ -141,6 +190,7 @@
 	       don't worry about them.  */
 	    const char *start;
 	    char *n;
+	    struct macro_hash_value idval;
 
 	    if (saw_operand)
 	      goto unknown;
@@ -151,8 +201,9 @@
 	    n = XALLOCAVEC (char, p - start + 1);
 	    memcpy (n, start, p - start);
 	    n[p - start] = '\0';
-	    slot = htab_find_slot (macro_hash, n, NO_INSERT);
-	    if (slot == NULL || *slot == NULL)
+	    idval.name = n;
+	    idval.value = NULL;
+	    if (htab_find (macro_hash, &idval) == NULL)
 	      {
 		/* This is a reference to a name which was not defined
 		   as a macro.  */
@@ -300,8 +351,14 @@
 	case '"':
 	case '\'':
 	  {
-	    char quote = *p;
+	    char quote;
+	    int count;
+
+	    if (saw_operand)
+	      goto unknown;
+	    quote = *p;
 	    *q++ = *p++;
+	    count = 0;
 	    while (*p != quote)
 	      {
 		int c;
@@ -309,6 +366,8 @@
 		if (*p == '\0')
 		  goto unknown;
 
+		++count;
+
 		if (*p != '\\')
 		  {
 		    *q++ = *p++;
@@ -354,7 +413,15 @@
 		    goto unknown;
 		  }
 	      }
+
 	    *q++ = *p++;
+
+	    if (quote == '\'' && count != 1)
+	      goto unknown;
+
+	    saw_operand = true;
+	    need_operand = false;
+
 	    break;
 	  }
 
@@ -366,18 +433,30 @@
   if (need_operand)
     goto unknown;
 
+  gcc_assert ((size_t) (q - out_buffer) < out_len);
   *q = '\0';
 
-  slot = htab_find_slot_with_hash (macro_hash, copy, hashval, INSERT);
-  *slot = copy;
+  mhval->value = out_buffer;
 
-  fprintf (go_dump_file, "const _%s = %s\n", copy, out_buffer);
+  if (slot == NULL)
+    {
+      slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, INSERT);
+      gcc_assert (slot != NULL && *slot == NULL);
+    }
+  else
+    {
+      if (*slot != NULL)
+	macro_hash_del (*slot);
+    }
 
-  XDELETEVEC (out_buffer);
+  *slot = mhval;
+
   return;
 
  unknown:
   fprintf (go_dump_file, "// unknowndefine %s\n", buffer);
+  if (slot != NULL)
+    htab_clear_slot (macro_hash, slot);
   XDELETEVEC (out_buffer);
   XDELETEVEC (copy);
 }
@@ -387,16 +466,16 @@
 static void
 go_undef (unsigned int lineno, const char *buffer)
 {
+  struct macro_hash_value mhval;
   void **slot;
 
   real_debug_hooks->undef (lineno, buffer);
 
-  slot = htab_find_slot (macro_hash, buffer, NO_INSERT);
-  if (slot == NULL)
-    return;
-  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.  */
+  mhval.name = CONST_CAST (char *, buffer);
+  mhval.value = NULL;
+  slot = htab_find_slot (macro_hash, &mhval, NO_INSERT);
+  if (slot != NULL)
+    htab_clear_slot (macro_hash, slot);
 }
 
 /* A function or variable decl.  */
@@ -408,7 +487,7 @@
       || DECL_IS_BUILTIN (decl)
       || DECL_NAME (decl) == NULL_TREE)
     return;
-  VEC_safe_push (tree, gc, queue, decl);
+  vec_safe_push (queue, decl);
 }
 
 /* A function decl.  */
@@ -420,13 +499,20 @@
   go_decl (decl);
 }
 
+static void
+go_early_global_decl (tree decl)
+{
+  go_decl (decl);
+  if (TREE_CODE (decl) != FUNCTION_DECL || DECL_STRUCT_FUNCTION (decl) != NULL)
+    real_debug_hooks->early_global_decl (decl);
+}
+
 /* A global variable decl.  */
 
 static void
-go_global_decl (tree decl)
+go_late_global_decl (tree decl)
 {
-  real_debug_hooks->global_decl (decl);
-  go_decl (decl);
+  real_debug_hooks->late_global_decl (decl);
 }
 
 /* A type declaration.  */
@@ -443,7 +529,7 @@
 	  || TREE_CODE (TYPE_NAME (TREE_TYPE (decl))) != IDENTIFIER_NODE)
       && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
     return;
-  VEC_safe_push (tree, gc, queue, decl);
+  vec_safe_push (queue, decl);
 }
 
 /* A container for the data we pass around when generating information
@@ -452,11 +538,11 @@
 struct godump_container
 {
   /* DECLs that we have already seen.  */
-  struct pointer_set_t *decls_seen;
+  hash_set<tree> decls_seen;
 
   /* Types which may potentially have to be defined as dummy
      types.  */
-  struct pointer_set_t *pot_dummy_types;
+  hash_set<const char *> pot_dummy_types;
 
   /* Go keywords.  */
   htab_t keyword_hash;
@@ -464,6 +550,9 @@
   /* Global type definitions.  */
   htab_t type_hash;
 
+  /* Invalid types.  */
+  htab_t invalid_hash;
+
   /* Obstack used to write out a type definition.  */
   struct obstack type_obstack;
 };
@@ -476,85 +565,193 @@
   obstack_grow (ob, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
 }
 
+/* Given an integer PRECISION in bits, returns a constant string that is the
+   matching go int or uint type (depending on the IS_UNSIGNED flag).  Returns a
+   NULL pointer if there is no matching go type.  */
+
+static const char *
+go_get_uinttype_for_precision (unsigned int precision, bool is_unsigned)
+{
+  switch (precision)
+    {
+    case 8:
+      return is_unsigned ? "uint8" : "int8";
+    case 16:
+      return is_unsigned ? "uint16" : "int16";
+    case 32:
+      return is_unsigned ? "uint32" : "int32";
+    case 64:
+      return is_unsigned ? "uint64" : "int64";
+    default:
+      return NULL;
+    }
+}
+
+/* Append an artificial variable name with the suffix _INDEX to OB.  Returns
+   INDEX + 1.  */
+
+static unsigned int
+go_append_artificial_name (struct obstack *ob, unsigned int index)
+{
+  char buf[100];
+
+  /* FIXME: identifier may not be unique.  */
+  obstack_grow (ob, "Godump_", 7);
+  snprintf (buf, sizeof buf, "%u", index);
+  obstack_grow (ob, buf, strlen (buf));
+
+  return index + 1;
+}
+
+/* Append the variable name from DECL to OB.  If the name is in the
+   KEYWORD_HASH, prepend an '_'.  */
+
+static void
+go_append_decl_name (struct obstack *ob, tree decl, htab_t keyword_hash)
+{
+  const char *var_name;
+  void **slot;
+
+  /* Start variable name with an underscore if a keyword.  */
+  var_name = IDENTIFIER_POINTER (DECL_NAME (decl));
+  slot = htab_find_slot (keyword_hash, var_name, NO_INSERT);
+  if (slot != NULL)
+    obstack_1grow (ob, '_');
+  go_append_string (ob, DECL_NAME (decl));
+}
+
+/* Appends a byte array with the necessary number of elements and the name
+   "Godump_INDEX_pad" to pad from FROM_OFFSET to TO_OFFSET to OB assuming that
+   the next field is automatically aligned to ALIGN_UNITS.  Returns INDEX + 1,
+   or INDEX if no padding had to be appended.  The resulting offset where the
+   next field is allocated is returned through RET_OFFSET.  */
+
+static unsigned int
+go_append_padding (struct obstack *ob, unsigned int from_offset,
+		   unsigned int to_offset, unsigned int align_units,
+		   unsigned int index, unsigned int *ret_offset)
+{
+  if (from_offset % align_units > 0)
+    from_offset += align_units - (from_offset % align_units);
+  gcc_assert (to_offset >= from_offset);
+  if (to_offset > from_offset)
+    {
+      char buf[100];
+
+      index = go_append_artificial_name (ob, index);
+      snprintf (buf, sizeof buf, "_pad [%u]byte; ", to_offset - from_offset);
+      obstack_grow (ob, buf, strlen (buf));
+    }
+  *ret_offset = to_offset;
+
+  return index;
+}
+
+/* Appends an array of type TYPE_STRING with zero elements and the name
+   "Godump_INDEX_align" to OB.  If TYPE_STRING is a null pointer, ERROR_STRING
+   is appended instead of the type.  Returns INDEX + 1.  */
+
+static unsigned int
+go_force_record_alignment (struct obstack *ob, const char *type_string,
+			   unsigned int index, const char *error_string)
+{
+  index = go_append_artificial_name (ob, index);
+  obstack_grow (ob, "_align ", 7);
+  if (type_string == NULL)
+    obstack_grow (ob, error_string, strlen (error_string));
+  else
+    {
+      obstack_grow (ob, "[0]", 3);
+      obstack_grow (ob, type_string, strlen (type_string));
+    }
+  obstack_grow (ob, "; ", 2);
+
+  return index;
+}
+
 /* 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.  */
+   type here; the "func" keyword will already have been added.
+   Return true if the type can be represented in Go, false otherwise.
+   P_ART_I is used for indexing artificial elements in nested structures and
+   should always be a NULL pointer when called, except by certain recursive
+   calls from go_format_type() itself.  */
 
 static bool
 go_format_type (struct godump_container *container, tree type,
-		bool use_type_name, bool is_func_ok)
+		bool use_type_name, bool is_func_ok, unsigned int *p_art_i,
+		bool is_anon_record_or_union)
 {
   bool ret;
   struct obstack *ob;
+  unsigned int art_i_dummy;
+  bool is_union = false;
 
+  if (p_art_i == NULL)
+    {
+      art_i_dummy = 0;
+      p_art_i = &art_i_dummy;
+    }
   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)))
+      && (container->decls_seen.contains (type)
+	  || container->decls_seen.contains (TYPE_NAME (type)))
       && (AGGREGATE_TYPE_P (type)
 	  || POINTER_TYPE_P (type)
 	  || TREE_CODE (type) == FUNCTION_TYPE))
     {
       tree name;
+      void **slot;
 
-      name = TYPE_NAME (type);
-      if (TREE_CODE (name) == IDENTIFIER_NODE)
-	{
-	  obstack_1grow (ob, '_');
-	  go_append_string (ob, name);
-	  return ret;
-	}
-      else if (TREE_CODE (name) == TYPE_DECL)
-	{
-	  obstack_1grow (ob, '_');
-	  go_append_string (ob, DECL_NAME (name));
-	  return ret;
-	}
+      name = TYPE_IDENTIFIER (type);
+
+      slot = htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (name),
+			     NO_INSERT);
+      if (slot != NULL)
+	ret = false;
+
+      obstack_1grow (ob, '_');
+      go_append_string (ob, name);
+      return ret;
     }
 
-  pointer_set_insert (container->decls_seen, type);
+  container->decls_seen.add (type);
 
   switch (TREE_CODE (type))
     {
-    case ENUMERAL_TYPE:
-      obstack_grow (ob, "int", 3);
+    case TYPE_DECL:
+      {
+	void **slot;
+
+	slot = htab_find_slot (container->invalid_hash,
+			       IDENTIFIER_POINTER (DECL_NAME (type)),
+			       NO_INSERT);
+	if (slot != NULL)
+	  ret = false;
+
+	obstack_1grow (ob, '_');
+	go_append_string (ob, DECL_NAME (type));
+      }
       break;
 
-    case TYPE_DECL:
-      obstack_1grow (ob, '_');
-      go_append_string (ob, DECL_NAME (type));
-      break;
-
+    case ENUMERAL_TYPE:
     case INTEGER_TYPE:
       {
 	const char *s;
 	char buf[100];
 
-	switch (TYPE_PRECISION (type))
+	s = go_get_uinttype_for_precision (TYPE_PRECISION (type),
+					   TYPE_UNSIGNED (type));
+	if (s == NULL)
 	  {
-	  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;
 	    ret = false;
-	    break;
 	  }
 	obstack_grow (ob, s, strlen (s));
       }
@@ -584,6 +781,40 @@
       }
       break;
 
+    case COMPLEX_TYPE:
+      {
+	const char *s;
+	char buf[100];
+	tree real_type;
+
+	real_type = TREE_TYPE (type);
+	if (TREE_CODE (real_type) == REAL_TYPE)
+	  {
+	    switch (TYPE_PRECISION (real_type))
+	      {
+	      case 32:
+		s = "complex64";
+		break;
+	      case 64:
+		s = "complex128";
+		break;
+	      default:
+		snprintf (buf, sizeof buf, "INVALID-complex-%u",
+			  2 * TYPE_PRECISION (real_type));
+		s = buf;
+		ret = false;
+		break;
+	      }
+	  }
+	else
+	  {
+	    s = "INVALID-complex-non-real";
+	    ret = false;
+	  }
+	obstack_grow (ob, s, strlen (s));
+      }
+      break;
+
     case BOOLEAN_TYPE:
       obstack_grow (ob, "bool", 4);
       break;
@@ -597,31 +828,25 @@
 		      == FUNCTION_TYPE))))
         {
 	  tree name;
+	  void **slot;
 
-	  name = TYPE_NAME (TREE_TYPE (type));
-	  if (TREE_CODE (name) == IDENTIFIER_NODE)
-	    {
-	      obstack_grow (ob, "*_", 2);
-	      go_append_string (ob, name);
+	  name = TYPE_IDENTIFIER (TREE_TYPE (type));
+
+	  slot = htab_find_slot (container->invalid_hash,
+				 IDENTIFIER_POINTER (name), NO_INSERT);
+	  if (slot != NULL)
+	    ret = false;
 
-	      /* 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));
+	  obstack_grow (ob, "*_", 2);
+	  go_append_string (ob, name);
 
-	      return ret;
-	    }
-	  else if (TREE_CODE (name) == TYPE_DECL)
-	    {
-	      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 ret;
-	    }
+	  /* The pointer here can be used without the struct or union
+	     definition.  So this struct or union is a potential dummy
+	     type.  */
+	  if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
+	    container->pot_dummy_types.add (IDENTIFIER_POINTER (name));
+
+	  return ret;
         }
       if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 	obstack_grow (ob, "func", 4);
@@ -632,7 +857,7 @@
       else
 	{
 	  if (!go_format_type (container, TREE_TYPE (type), use_type_name,
-			       true))
+			       true, NULL, false))
 	    ret = false;
 	}
       break;
@@ -646,104 +871,172 @@
 	  && 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))
+	  && tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
 	{
 	  char buf[100];
 
 	  snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC "+1",
-		    tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0));
+		    tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (type))));
 	  obstack_grow (ob, buf, strlen (buf));
 	}
+      else
+	obstack_1grow (ob, '0');
       obstack_1grow (ob, ']');
-      if (!go_format_type (container, TREE_TYPE (type), use_type_name, false))
+      if (!go_format_type (container, TREE_TYPE (type), use_type_name, false,
+			   NULL, false))
 	ret = false;
       break;
 
     case UNION_TYPE:
+      is_union = true;
+      /* Fall through to RECORD_TYPE case.  */
+      gcc_fallthrough ();
     case RECORD_TYPE:
       {
+	unsigned int prev_field_end;
+	unsigned int known_alignment;
 	tree field;
-	int i;
+	bool emitted_a_field;
 
-	obstack_grow (ob, "struct { ", 9);
-	i = 0;
-	for (field = TYPE_FIELDS (type);
+	/* FIXME: Why is this necessary?  Without it we can get a core
+	   dump on the s390x headers, or from a file containing simply
+	   "typedef struct S T;".  */
+	layout_type (type);
+
+	prev_field_end = 0;
+	known_alignment = 1;
+	/* Anonymous records and unions are flattened, i.e. they are not put
+	   into "struct { ... }".  */
+	if (!is_anon_record_or_union)
+	  obstack_grow (ob, "struct { ", 9);
+	for (field = TYPE_FIELDS (type), emitted_a_field = false;
 	     field != NULL_TREE;
 	     field = TREE_CHAIN (field))
 	  {
-	    if (DECL_NAME (field) == NULL)
+	    if (TREE_CODE (field) != FIELD_DECL)
+	      continue;
+	    if (DECL_BIT_FIELD (field))
+	      /* Bit fields are replaced by padding.  */
+	      continue;
+	    /* Only the first non-bitfield field is emitted for unions.  */
+	    if (!is_union || !emitted_a_field)
 	      {
-		char buf[100];
-
-		obstack_grow (ob, "_f", 2);
-		snprintf (buf, sizeof buf, "%d", i);
-		obstack_grow (ob, buf, strlen (buf));
-		i++;
-	      }
-	    else
-              {
-		const char *var_name;
-		void **slot;
+		/* Emit the field.  */
+		bool field_ok;
+		bool is_anon_substructure;
+		unsigned int decl_align_unit;
+		unsigned int decl_offset;
 
-		/* 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)
-		  obstack_1grow (ob, '_');
-		go_append_string (ob, DECL_NAME (field));
-	      }
-	    obstack_1grow (ob, ' ');
-	    if (DECL_BIT_FIELD (field))
-	      {
-		obstack_grow (ob, "INVALID-bit-field", 17);
-		ret = false;
-	      }
-	    else
-              {
-		/* Do not expand type if a record or union type or a
-		   function pointer.  */
+		field_ok = true;
+		emitted_a_field = true;
+		is_anon_substructure =
+		  (DECL_NAME (field) == NULL
+		   && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
+		       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE));
+		/* Keep track of the alignment of named substructures, either
+		   of the whole record, or the alignment of the emitted field
+		   (for unions).  */
+		decl_align_unit = DECL_ALIGN_UNIT (field);
+		if (!is_anon_substructure && decl_align_unit > known_alignment)
+		  known_alignment = decl_align_unit;
+		/* Pad to start of field.  */
+		decl_offset =
+		  TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
+		  + precision_to_units
+		  (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field)));
+		{
+		  unsigned int align_unit;
+
+		  /* For anonymous records and unions there is no automatic
+		     structure alignment, so use 1 as the alignment.  */
+		  align_unit = (is_anon_substructure) ? 1 : decl_align_unit;
+		  *p_art_i = go_append_padding
+		    (ob, prev_field_end, decl_offset, align_unit, *p_art_i,
+		     &prev_field_end);
+		}
+		if (DECL_SIZE_UNIT (field))
+		  prev_field_end +=
+		    TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
+		/* Emit the field name, but not for anonymous records and
+		   unions.  */
+		if (!is_anon_substructure)
+		  {
+		    if ((DECL_NAME (field) == NULL))
+		      *p_art_i = go_append_artificial_name (ob, *p_art_i);
+		    else
+		      go_append_decl_name
+			(ob, field, container->keyword_hash);
+		    obstack_1grow (ob, ' ');
+		  }
+		/* 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))))
+				== FUNCTION_TYPE))))
 		  {
-		    tree name = TYPE_NAME (TREE_TYPE (field));
-		    if (TREE_CODE (name) == IDENTIFIER_NODE)
-		      {
-			obstack_1grow (ob, '_');
-			go_append_string (ob, name);
-		      }
-		    else if (TREE_CODE (name) == TYPE_DECL)
-		      {
-			obstack_1grow (ob, '_');
-			go_append_string (ob, DECL_NAME (name));
-		      }
+		    tree name;
+		    void **slot;
+
+		    name = TYPE_IDENTIFIER (TREE_TYPE (field));
+
+		    slot = htab_find_slot (container->invalid_hash,
+					   IDENTIFIER_POINTER (name),
+					   NO_INSERT);
+		    if (slot != NULL)
+		      field_ok = false;
+
+		    obstack_1grow (ob, '_');
+		    go_append_string (ob, name);
 		  }
 		else
 		  {
 		    if (!go_format_type (container, TREE_TYPE (field), true,
-					 false))
-		      ret = false;
+					 false, p_art_i, is_anon_substructure))
+		      field_ok = false;
 		  }
-              }
-	    obstack_grow (ob, "; ", 2);
+		if (!is_anon_substructure)
+		  obstack_grow (ob, "; ", 2);
+		if (!field_ok)
+		  ret = false;
+	      }
+	  }
+	/* Padding.  */
+	*p_art_i = go_append_padding (ob, prev_field_end,
+				      TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type)),
+				      1, *p_art_i, &prev_field_end);
+	/* Alignment.  */
+	if (!is_anon_record_or_union
+	    && known_alignment < TYPE_ALIGN_UNIT (type))
+	  {
+	    const char *s;
+	    char buf[100];
 
-	    /* Only output the first field of a union, and hope for
-	       the best.  */
-	    if (TREE_CODE (type) == UNION_TYPE)
-	      break;
+	    /* Enforce proper record alignment.  */
+	    s = go_get_uinttype_for_precision
+	      (TYPE_ALIGN (type), TYPE_UNSIGNED (type));
+	    if (s == NULL)
+	      {
+		snprintf (buf, sizeof buf, "INVALID-int-%u%s",
+			  TYPE_ALIGN (type), TYPE_UNSIGNED (type) ? "u" : "");
+		s = buf;
+		ret = false;
+	      }
+	    *p_art_i = go_force_record_alignment (ob, s, *p_art_i, buf);
 	  }
-	obstack_1grow (ob, '}');
+	if (!is_anon_record_or_union)
+	  obstack_1grow (ob, '}');
       }
-      break;
+    break;
 
     case FUNCTION_TYPE:
       {
-	tree args;
+	tree arg_type;
 	bool is_varargs;
 	tree result;
+	function_args_iterator iter;
+	bool seen_arg;
 
 	/* Go has no way to write a type which is a function but not a
 	   pointer to a function.  */
@@ -754,25 +1047,21 @@
 	  }
 
 	obstack_1grow (ob, '(');
-	is_varargs = true;
-	for (args = TYPE_ARG_TYPES (type);
-	     args != NULL_TREE;
-	     args = TREE_CHAIN (args))
+	is_varargs = stdarg_p (type);
+	seen_arg = false;
+	FOREACH_FUNCTION_ARGS (type, arg_type, iter)
 	  {
-	    if (VOID_TYPE_P (TREE_VALUE (args)))
-	      {
-		gcc_assert (TREE_CHAIN (args) == NULL);
-		is_varargs = false;
-		break;
-	      }
-	    if (args != TYPE_ARG_TYPES (type))
+	    if (VOID_TYPE_P (arg_type))
+	      break;
+	    if (seen_arg)
 	      obstack_grow (ob, ", ", 2);
-	    if (!go_format_type (container, TREE_VALUE (args), true, false))
+	    if (!go_format_type (container, arg_type, true, false, NULL, false))
 	      ret = false;
+	    seen_arg = true;
 	  }
 	if (is_varargs)
 	  {
-	    if (TYPE_ARG_TYPES (type) != NULL_TREE)
+	    if (prototype_p (type))
 	      obstack_grow (ob, ", ", 2);
 	    obstack_grow (ob, "...interface{}", 14);
 	  }
@@ -782,7 +1071,8 @@
 	if (!VOID_TYPE_P (result))
 	  {
 	    obstack_1grow (ob, ' ');
-	    if (!go_format_type (container, result, use_type_name, false))
+	    if (!go_format_type (container, result, use_type_name, false, NULL,
+				 false))
 	      ret = false;
 	  }
       }
@@ -807,7 +1097,7 @@
 
   ob = &container->type_obstack;
   obstack_1grow (ob, '\0');
-  fputs (obstack_base (ob), go_dump_file);
+  fputs ((char *) obstack_base (ob), go_dump_file);
   obstack_free (ob, obstack_base (ob));
 }
 
@@ -816,7 +1106,7 @@
 static void
 go_output_fndecl (struct godump_container *container, tree decl)
 {
-  if (!go_format_type (container, TREE_TYPE (decl), false, true))
+  if (!go_format_type (container, TREE_TYPE (decl), false, true, NULL, false))
     fprintf (go_dump_file, "// ");
   fprintf (go_dump_file, "func _%s ",
 	   IDENTIFIER_POINTER (DECL_NAME (decl)));
@@ -834,23 +1124,49 @@
      separately.  */
   if (TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE
       && TYPE_SIZE (TREE_TYPE (decl)) != 0
-      && !pointer_set_contains (container->decls_seen, TREE_TYPE (decl))
+      && !container->decls_seen.contains (TREE_TYPE (decl))
       && (TYPE_CANONICAL (TREE_TYPE (decl)) == NULL_TREE
-	  || !pointer_set_contains (container->decls_seen,
-				    TYPE_CANONICAL (TREE_TYPE (decl)))))
+	  || !container->decls_seen.contains
+				    (TYPE_CANONICAL (TREE_TYPE (decl)))))
     {
       tree element;
 
       for (element = TYPE_VALUES (TREE_TYPE (decl));
 	   element != NULL_TREE;
 	   element = TREE_CHAIN (element))
-	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));
+	{
+	  const char *name;
+	  struct macro_hash_value *mhval;
+	  void **slot;
+	  char buf[WIDE_INT_PRINT_BUFFER_SIZE];
+
+	  name = IDENTIFIER_POINTER (TREE_PURPOSE (element));
+
+	  /* Sometimes a name will be defined as both an enum constant
+	     and a macro.  Avoid duplicate definition errors by
+	     treating enum constants as macros.  */
+	  mhval = XNEW (struct macro_hash_value);
+	  mhval->name = xstrdup (name);
+	  mhval->value = NULL;
+	  slot = htab_find_slot (macro_hash, mhval, INSERT);
+	  if (*slot != NULL)
+	    macro_hash_del (*slot);
+
+	  if (tree_fits_shwi_p (TREE_VALUE (element)))
+	    snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC,
+		     tree_to_shwi (TREE_VALUE (element)));
+	  else if (tree_fits_uhwi_p (TREE_VALUE (element)))
+	    snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_UNSIGNED,
+		      tree_to_uhwi (TREE_VALUE (element)));
+	  else
+	    print_hex (wi::to_wide (element), buf);
+
+	  mhval->value = xstrdup (buf);
+	  *slot = mhval;
+	}
+      container->decls_seen.add (TREE_TYPE (decl));
       if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE)
-	pointer_set_insert (container->decls_seen,
-			    TYPE_CANONICAL (TREE_TYPE (decl)));
+	container->decls_seen.add (TYPE_CANONICAL (TREE_TYPE (decl)));
     }
 
   if (DECL_NAME (decl) != NULL_TREE)
@@ -865,17 +1181,35 @@
 	return;
       *slot = CONST_CAST (void *, (const void *) type);
 
-      if (!go_format_type (container, TREE_TYPE (decl), false, false))
-	fprintf (go_dump_file, "// ");
+      if (!go_format_type (container, TREE_TYPE (decl), false, false, NULL,
+			   false))
+	{
+	  fprintf (go_dump_file, "// ");
+	  slot = htab_find_slot (container->invalid_hash, type, INSERT);
+	  *slot = CONST_CAST (void *, (const void *) type);
+	}
       fprintf (go_dump_file, "type _%s ",
 	       IDENTIFIER_POINTER (DECL_NAME (decl)));
       go_output_type (container);
-      pointer_set_insert (container->decls_seen, decl);
+
+      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
+	{
+	  HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
+
+	  if (size > 0)
+	    fprintf (go_dump_file,
+		     "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC,
+		     IDENTIFIER_POINTER (DECL_NAME (decl)),
+		     size);
+	}
+
+      container->decls_seen.add (decl);
     }
   else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
     {
        void **slot;
        const char *type;
+       HOST_WIDE_INT size;
 
        type = IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE ((decl))));
        /* If type defined already, skip.  */
@@ -884,11 +1218,23 @@
          return;
        *slot = CONST_CAST (void *, (const void *) type);
 
-       if (!go_format_type (container, TREE_TYPE (decl), false, false))
-	 fprintf (go_dump_file, "// ");
+       if (!go_format_type (container, TREE_TYPE (decl), false, false, NULL,
+			    false))
+	 {
+	   fprintf (go_dump_file, "// ");
+	   slot = htab_find_slot (container->invalid_hash, type, INSERT);
+	   *slot = CONST_CAST (void *, (const void *) type);
+	 }
        fprintf (go_dump_file, "type _%s ",
 	       IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))));
        go_output_type (container);
+
+       size = int_size_in_bytes (TREE_TYPE (decl));
+       if (size > 0)
+	 fprintf (go_dump_file,
+		  "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC,
+		  IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))),
+		  size);
     }
   else
     return;
@@ -902,14 +1248,42 @@
 go_output_var (struct godump_container *container, tree decl)
 {
   bool is_valid;
+  tree type_name;
+  tree id;
 
-  if (pointer_set_contains (container->decls_seen, decl)
-      || pointer_set_contains (container->decls_seen, DECL_NAME (decl)))
+  if (container->decls_seen.contains (decl)
+      || container->decls_seen.contains (DECL_NAME (decl)))
     return;
-  pointer_set_insert (container->decls_seen, decl);
-  pointer_set_insert (container->decls_seen, DECL_NAME (decl));
+  container->decls_seen.add (decl);
+  container->decls_seen.add (DECL_NAME (decl));
 
-  is_valid = go_format_type (container, TREE_TYPE (decl), true, false);
+  type_name = TYPE_NAME (TREE_TYPE (decl));
+  id = NULL_TREE;
+  if (type_name != NULL_TREE && TREE_CODE (type_name) == IDENTIFIER_NODE)
+    id = type_name;
+  else if (type_name != NULL_TREE && TREE_CODE (type_name) == TYPE_DECL
+	   && DECL_SOURCE_LOCATION (type_name) != BUILTINS_LOCATION
+	   && DECL_NAME (type_name))
+    id = DECL_NAME (type_name);
+  if (id != NULL_TREE
+      && (!htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id),
+			   NO_INSERT)
+	  || htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (id),
+			     NO_INSERT)))
+    id = NULL_TREE;
+  if (id != NULL_TREE)
+    {
+      struct obstack *ob;
+
+      ob = &container->type_obstack;
+      obstack_1grow (ob, '_');
+      go_append_string (ob, id);
+      is_valid = htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id),
+				 NO_INSERT) != NULL;
+    }
+  else
+    is_valid = go_format_type (container, TREE_TYPE (decl), true, false, NULL,
+			       false);
   if (is_valid
       && htab_find_slot (container->type_hash,
 			 IDENTIFIER_POINTER (DECL_NAME (decl)),
@@ -929,19 +1303,27 @@
 
   /* 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)))
+  if (type_name != 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));
+	container->pot_dummy_types.add (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)));
+	container->pot_dummy_types.add
+			    (IDENTIFIER_POINTER (DECL_NAME (type_name)));
     }
 }
 
+/* Output the final value of a preprocessor macro or enum constant.
+   This is called via htab_traverse_noresize.  */
+
+static int
+go_print_macro (void **slot, void *arg ATTRIBUTE_UNUSED)
+{
+  struct macro_hash_value *mhval = (struct macro_hash_value *) *slot;
+  fprintf (go_dump_file, "const _%s = %s\n", mhval->name, mhval->value);
+  return 1;
+}
+
 /* Build a hash table with the Go keywords.  */
 
 static const char * const keywords[] = {
@@ -967,17 +1349,19 @@
 
 /* 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.  */
+   not found.  This function is invoked by hash_set::traverse.  */
 
-static bool
-find_dummy_types (const void *ptr, void *adata)
+bool
+find_dummy_types (const char *const &ptr, godump_container *adata)
 {
   struct godump_container *data = (struct godump_container *) adata;
   const char *type = (const char *) ptr;
   void **slot;
+  void **islot;
 
   slot = htab_find_slot (data->type_hash, type, NO_INSERT);
-  if (slot == NULL)
+  islot = htab_find_slot (data->invalid_hash, type, NO_INSERT);
+  if (slot == NULL || islot != NULL)
     fprintf (go_dump_file, "type _%s struct {}\n", type);
   return true;
 }
@@ -993,17 +1377,17 @@
 
   real_debug_hooks->finish (filename);
 
-  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.invalid_hash = htab_create (10, htab_hash_string,
+					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);
 
-  FOR_EACH_VEC_ELT (tree, queue, ix, decl)
+  FOR_EACH_VEC_SAFE_ELT (queue, ix, decl)
     {
       switch (TREE_CODE (decl))
 	{
@@ -1020,21 +1404,22 @@
 	  break;
 
 	default:
-	  gcc_unreachable();
+	  gcc_unreachable ();
 	}
     }
 
-  /* To emit dummy definitions.  */
-  pointer_set_traverse (container.pot_dummy_types, find_dummy_types,
-                        (void *) &container);
+  htab_traverse_noresize (macro_hash, go_print_macro, NULL);
 
-  pointer_set_destroy (container.decls_seen);
-  pointer_set_destroy (container.pot_dummy_types);
+  /* To emit dummy definitions.  */
+  container.pot_dummy_types.traverse<godump_container *, find_dummy_types>
+                        (&container);
+
   htab_delete (container.type_hash);
+  htab_delete (container.invalid_hash);
   htab_delete (container.keyword_hash);
   obstack_free (&container.type_obstack, NULL);
 
-  queue = NULL;
+  vec_free (queue);
 
   if (fclose (go_dump_file) != 0)
     error ("could not close Go dump file: %m");
@@ -1060,10 +1445,12 @@
   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.early_global_decl = go_early_global_decl;
+  go_debug_hooks.late_global_decl = go_late_global_decl;
   go_debug_hooks.type_decl = go_type_decl;
 
-  macro_hash = htab_create (100, htab_hash_string, string_hash_eq, NULL);
+  macro_hash = htab_create (100, macro_hash_hashval, macro_hash_eq,
+			    macro_hash_del);
 
   return &go_debug_hooks;
 }