compiler, runtime: replace hashmap code with Go 1.7 hashmap

    
    This change removes the gccgo-specific hashmap code and replaces it with
    the hashmap code from the Go 1.7 runtime.  The Go 1.7 hashmap code is
    more efficient, does a better job on details like when to update a key,
    and provides some support against denial-of-service attacks.
    
    The compiler is changed to call the new hashmap functions instead of the
    old ones.
    
    The compiler now tracks which types are reflexive and which require
    updating when used as a map key, and records the information in map type
    descriptors.
    
    Map_index_expression is simplified.  The special case for a map index on
    the right hand side of a tuple expression has been unnecessary for some
    time, and is removed.  The support for specially marking a map index as
    an lvalue is removed, in favor of lowering an assignment to a map index
    into a function call.  The long-obsolete support for a map index of a
    pointer to a map is removed.
    
    The __go_new_map_big function (known to the compiler as
    Runtime::MAKEMAPBIG) is no longer needed, as the new runtime.makemap
    function takes an int64 hint argument.
    
    The old map descriptor type and supporting expression is removed.
    
    The compiler was still supporting the long-obsolete syntax `m[k] = 0,
    false` to delete a value from a map.  That is now removed, requiring a
    change to one of the gccgo-specific tests.
    
    The builtin len function applied to a map or channel p is now compiled
    as `p == nil ? 0 : *(*int)(p)`.  The __go_chan_len function (known to
    the compiler as Runtime::CHAN_LEN) is removed.
    
    Support for a shared zero value for maps to large value types is
    introduced, along the lines of the gc compiler.  The zero value is
    handled as a common variable.
    
    The hash function is changed to take a seed argument, changing the
    runtime hash functions and the compiler-generated hash functions.
    Unlike the gc compiler, both the hash and equal functions continue to
    take the type length.
    
    Types that can not be compared now store nil for the hash and equal
    functions, rather than pointing to functions that throw.  Interface hash
    and comparison functions now check explicitly for nil.  This matches the
    gc compiler and permits a simple implementation for ismapkey.
    
    The compiler is changed to permit marking struct and array types as
    incomparable, meaning that they have no hash or equal function.  We use
    this for thunk types, removing the existing special code to avoid
    generating hash/equal functions for them.
    
    The C runtime code adds memclr, memequal, and memmove functions.
    
    The hashmap code uses go:linkname comments to make the functions
    visible, as otherwise the compiler would discard them.
    
    The hashmap code comments out the unused reference to the address of the
    first parameter in the race code, as otherwise the compiler thinks that
    the parameter escapes and copies it onto the heap.  This is probably not
    needed when we enable escape analysis.
    
    Several runtime map tests that ere previously skipped for gccgo are now
    run.
    
    The Go runtime picks up type kind information and stubs.  The type kind
    information causes the generated runtime header file to define some
    constants, including `empty`, and the C code is adjusted accordingly.
    
    A Go-callable version of runtime.throw, that takes a Go string, is
    added to be called from the hashmap code.
    
    Reviewed-on: https://go-review.googlesource.com/29447

	* go.go-torture/execute/map-1.go: Replace old map deletion syntax
	with call to builtin delete function.

From-SVN: r240334

35 files changed, 208 insertions, 917 deletions

diff --git a/libgo/runtime/chan.goc b/libgo/runtime/chan.goc
index 44402d4..6e4c8fd 100644
--- a/libgo/runtime/chan.goc
+++ b/libgo/runtime/chan.goc
@@ -1064,12 +1064,6 @@ func reflect.chanlen(c *Hchan) (len int) {
 		len = c->qcount;
 }
 
-intgo
-__go_chan_len(Hchan *c)
-{
-	return reflect_chanlen(c);
-}
-
 func reflect.chancap(c *Hchan) (cap int) {
 	if(c == nil)
 		cap = 0;
diff --git a/libgo/runtime/go-construct-map.c b/libgo/runtime/go-construct-map.c
index 4bd79d2..c1a8bb7 100644
--- a/libgo/runtime/go-construct-map.c
+++ b/libgo/runtime/go-construct-map.c
@@ -9,25 +9,30 @@
 #include <stdlib.h>
 
 #include "runtime.h"
-#include "map.h"
 
-struct __go_map *
-__go_construct_map (const struct __go_map_descriptor *descriptor,
+extern void *makemap (const struct __go_map_type *, int64_t hint,
+		      void *, void *)
+  __asm__ (GOSYM_PREFIX "runtime.makemap");
+
+extern void mapassign1 (const struct __go_map_type *, void *hmap,
+			const void *key, const void *val)
+  __asm__ (GOSYM_PREFIX "runtime.mapassign1");
+
+void *
+__go_construct_map (const struct __go_map_type *type,
 		    uintptr_t count, uintptr_t entry_size,
-		    uintptr_t val_offset, uintptr_t val_size,
-		    const void *ventries)
+		    uintptr_t val_offset, const void *ventries)
 {
-  struct __go_map *ret;
+  void *ret;
   const unsigned char *entries;
   uintptr_t i;
 
-  ret = __go_new_map (descriptor, count);
+  ret = makemap(type, (int64_t) count, NULL, NULL);
 
   entries = (const unsigned char *) ventries;
   for (i = 0; i < count; ++i)
     {
-      void *val = __go_map_index (ret, entries, 1);
-      __builtin_memcpy (val, entries + val_offset, val_size);
+      mapassign1 (type, ret, entries, entries + val_offset);
       entries += entry_size;
     }
 
diff --git a/libgo/runtime/go-eface-compare.c b/libgo/runtime/go-eface-compare.c
index 40b716e..62302b5 100644
--- a/libgo/runtime/go-eface-compare.c
+++ b/libgo/runtime/go-eface-compare.c
@@ -26,6 +26,8 @@ __go_empty_interface_compare (struct __go_empty_interface left,
   if (!__go_type_descriptors_equal (left_descriptor,
 				    right.__type_descriptor))
     return 1;
+  if (left_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (left_descriptor))
     return left.__object == right.__object ? 0 : 1;
   if (!__go_call_equalfn (left_descriptor->__equalfn, left.__object,
diff --git a/libgo/runtime/go-eface-val-compare.c b/libgo/runtime/go-eface-val-compare.c
index e810750..839d189 100644
--- a/libgo/runtime/go-eface-val-compare.c
+++ b/libgo/runtime/go-eface-val-compare.c
@@ -24,6 +24,8 @@ __go_empty_interface_value_compare (
     return 1;
   if (!__go_type_descriptors_equal (left_descriptor, right_descriptor))
     return 1;
+  if (left_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (left_descriptor))
     return left.__object == val ? 0 : 1;
   if (!__go_call_equalfn (left_descriptor->__equalfn, left.__object, val,
diff --git a/libgo/runtime/go-fieldtrack.c b/libgo/runtime/go-fieldtrack.c
index a7e2c13..2b3ac32 100644
--- a/libgo/runtime/go-fieldtrack.c
+++ b/libgo/runtime/go-fieldtrack.c
@@ -6,7 +6,6 @@
 
 #include "runtime.h"
 #include "go-type.h"
-#include "map.h"
 
 /* The compiler will track fields that have the tag go:"track".  Any
    function that refers to such a field will call this function with a
@@ -34,16 +33,26 @@ extern const char _edata[] __attribute__ ((weak));
 extern const char __edata[] __attribute__ ((weak));
 extern const char __bss_start[] __attribute__ ((weak));
 
-void runtime_Fieldtrack (struct __go_map *) __asm__ (GOSYM_PREFIX "runtime.Fieldtrack");
+extern void mapassign1 (const struct __go_map_type *, void *hmap,
+			const void *key, const void *val)
+  __asm__ (GOSYM_PREFIX "runtime.mapassign1");
+
+// The type descriptor for map[string] bool.  */
+extern const char __go_td_MN6_string__N4_bool[] __attribute__ ((weak));
+
+void runtime_Fieldtrack (void *) __asm__ (GOSYM_PREFIX "runtime.Fieldtrack");
 
 void
-runtime_Fieldtrack (struct __go_map *m)
+runtime_Fieldtrack (void *m)
 {
   const char *p;
   const char *pend;
   const char *prefix;
   size_t prefix_len;
 
+  if (__go_td_MN6_string__N4_bool == NULL)
+    return;
+
   p = __data_start;
   if (p == NULL)
     p = __etext;
@@ -86,14 +95,12 @@ runtime_Fieldtrack (struct __go_map *m)
       if (__builtin_memchr (q1, '\0', q2 - q1) == NULL)
 	{
 	  String s;
-	  void *v;
-	  _Bool *pb;
+	  _Bool b;
 
 	  s.str = (const byte *) q1;
 	  s.len = q2 - q1;
-	  v = __go_map_index (m, &s, 1);
-	  pb = (_Bool *) v;
-	  *pb = 1;
+	  b = 1;
+	  mapassign1((const void*) __go_td_MN6_string__N4_bool, m, &s, &b);
 	}
 
       p = q2;
diff --git a/libgo/runtime/go-interface-compare.c b/libgo/runtime/go-interface-compare.c
index 1d36775..14999df 100644
--- a/libgo/runtime/go-interface-compare.c
+++ b/libgo/runtime/go-interface-compare.c
@@ -26,6 +26,8 @@ __go_interface_compare (struct __go_interface left,
   left_descriptor = left.__methods[0];
   if (!__go_type_descriptors_equal (left_descriptor, right.__methods[0]))
     return 1;
+  if (left_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (left_descriptor))
     return left.__object == right.__object ? 0 : 1;
   if (!__go_call_equalfn (left_descriptor->__equalfn, left.__object,
diff --git a/libgo/runtime/go-interface-eface-compare.c b/libgo/runtime/go-interface-eface-compare.c
index d1e6fd0..4c47b7c 100644
--- a/libgo/runtime/go-interface-eface-compare.c
+++ b/libgo/runtime/go-interface-eface-compare.c
@@ -25,6 +25,8 @@ __go_interface_empty_compare (struct __go_interface left,
   left_descriptor = left.__methods[0];
   if (!__go_type_descriptors_equal (left_descriptor, right.__type_descriptor))
     return 1;
+  if (left_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (left_descriptor))
     return left.__object == right.__object ? 0 : 1;
   if (!__go_call_equalfn (left_descriptor->__equalfn, left.__object,
diff --git a/libgo/runtime/go-interface-val-compare.c b/libgo/runtime/go-interface-val-compare.c
index 36b6efd..5dc91d0 100644
--- a/libgo/runtime/go-interface-val-compare.c
+++ b/libgo/runtime/go-interface-val-compare.c
@@ -24,6 +24,8 @@ __go_interface_value_compare (
   left_descriptor = left.__methods[0];
   if (!__go_type_descriptors_equal (left_descriptor, right_descriptor))
     return 1;
+  if (left_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (left_descriptor))
     return left.__object == val ? 0 : 1;
   if (!__go_call_equalfn (left_descriptor->__equalfn, left.__object, val,
diff --git a/libgo/runtime/go-map-delete.c b/libgo/runtime/go-map-delete.c
deleted file mode 100644
index fb7c331..0000000
--- a/libgo/runtime/go-map-delete.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/* go-map-delete.c -- delete an entry from a map.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "runtime.h"
-#include "malloc.h"
-#include "go-alloc.h"
-#include "go-assert.h"
-#include "map.h"
-
-/* Delete the entry matching KEY from MAP.  */
-
-void
-__go_map_delete (struct __go_map *map, const void *key)
-{
-  const struct __go_map_descriptor *descriptor;
-  const struct __go_type_descriptor *key_descriptor;
-  uintptr_t key_offset;
-  const FuncVal *equalfn;
-  size_t key_hash;
-  size_t key_size;
-  size_t bucket_index;
-  void **pentry;
-
-  if (map == NULL)
-    return;
-
-  descriptor = map->__descriptor;
-
-  key_descriptor = descriptor->__map_descriptor->__key_type;
-  key_offset = descriptor->__key_offset;
-  key_size = key_descriptor->__size;
-  if (key_size == 0)
-    return;
-
-  __go_assert (key_size != -1UL);
-  equalfn = key_descriptor->__equalfn;
-
-  key_hash = __go_call_hashfn (key_descriptor->__hashfn, key, key_size);
-  bucket_index = key_hash % map->__bucket_count;
-
-  pentry = map->__buckets + bucket_index;
-  while (*pentry != NULL)
-    {
-      char *entry = (char *) *pentry;
-      if (__go_call_equalfn (equalfn, key, entry + key_offset, key_size))
-	{
-	  *pentry = *(void **) entry;
-	  if (descriptor->__entry_size >= TinySize)
-	    __go_free (entry);
-	  map->__element_count -= 1;
-	  break;
-	}
-      pentry = (void **) entry;
-    }
-}
diff --git a/libgo/runtime/go-map-index.c b/libgo/runtime/go-map-index.c
deleted file mode 100644
index 353041d..0000000
--- a/libgo/runtime/go-map-index.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/* go-map-index.c -- find or insert an entry in a map.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "runtime.h"
-#include "malloc.h"
-#include "go-alloc.h"
-#include "go-assert.h"
-#include "map.h"
-
-/* Rehash MAP to a larger size.  */
-
-static void
-__go_map_rehash (struct __go_map *map)
-{
-  const struct __go_map_descriptor *descriptor;
-  const struct __go_type_descriptor *key_descriptor;
-  uintptr_t key_offset;
-  size_t key_size;
-  const FuncVal *hashfn;
-  uintptr_t old_bucket_count;
-  void **old_buckets;
-  uintptr_t new_bucket_count;
-  void **new_buckets;
-  uintptr_t i;
-
-  descriptor = map->__descriptor;
-
-  key_descriptor = descriptor->__map_descriptor->__key_type;
-  key_offset = descriptor->__key_offset;
-  key_size = key_descriptor->__size;
-  hashfn = key_descriptor->__hashfn;
-
-  old_bucket_count = map->__bucket_count;
-  old_buckets = map->__buckets;
-
-  new_bucket_count = __go_map_next_prime (old_bucket_count * 2);
-  new_buckets = (void **) __go_alloc (new_bucket_count * sizeof (void *));
-  __builtin_memset (new_buckets, 0, new_bucket_count * sizeof (void *));
-
-  for (i = 0; i < old_bucket_count; ++i)
-    {
-      char* entry;
-      char* next;
-
-      for (entry = old_buckets[i]; entry != NULL; entry = next)
-	{
-	  size_t key_hash;
-	  size_t new_bucket_index;
-
-	  /* We could speed up rehashing at the cost of memory space
-	     by caching the hash code.  */
-	  key_hash = __go_call_hashfn (hashfn, entry + key_offset, key_size);
-	  new_bucket_index = key_hash % new_bucket_count;
-
-	  next = *(char **) entry;
-	  *(char **) entry = new_buckets[new_bucket_index];
-	  new_buckets[new_bucket_index] = entry;
-	}
-    }
-
-  if (old_bucket_count * sizeof (void *) >= TinySize)
-    __go_free (old_buckets);
-
-  map->__bucket_count = new_bucket_count;
-  map->__buckets = new_buckets;
-}
-
-/* Find KEY in MAP, return a pointer to the value.  If KEY is not
-   present, then if INSERT is false, return NULL, and if INSERT is
-   true, insert a new value and zero-initialize it before returning a
-   pointer to it.  */
-
-void *
-__go_map_index (struct __go_map *map, const void *key, _Bool insert)
-{
-  const struct __go_map_descriptor *descriptor;
-  const struct __go_type_descriptor *key_descriptor;
-  uintptr_t key_offset;
-  const FuncVal *equalfn;
-  size_t key_hash;
-  size_t key_size;
-  size_t bucket_index;
-  char *entry;
-
-  if (map == NULL)
-    {
-      if (insert)
-	runtime_panicstring ("assignment to entry in nil map");
-      return NULL;
-    }
-
-  descriptor = map->__descriptor;
-
-  key_descriptor = descriptor->__map_descriptor->__key_type;
-  key_offset = descriptor->__key_offset;
-  key_size = key_descriptor->__size;
-  __go_assert (key_size != -1UL);
-  equalfn = key_descriptor->__equalfn;
-
-  key_hash = __go_call_hashfn (key_descriptor->__hashfn, key, key_size);
-  bucket_index = key_hash % map->__bucket_count;
-
-  entry = (char *) map->__buckets[bucket_index];
-  while (entry != NULL)
-    {
-      if (__go_call_equalfn (equalfn, key, entry + key_offset, key_size))
-	return entry + descriptor->__val_offset;
-      entry = *(char **) entry;
-    }
-
-  if (!insert)
-    return NULL;
-
-  if (map->__element_count >= map->__bucket_count)
-    {
-      __go_map_rehash (map);
-      bucket_index = key_hash % map->__bucket_count;
-    }
-
-  entry = (char *) __go_alloc (descriptor->__entry_size);
-  __builtin_memset (entry, 0, descriptor->__entry_size);
-
-  __builtin_memcpy (entry + key_offset, key, key_size);
-
-  *(char **) entry = map->__buckets[bucket_index];
-  map->__buckets[bucket_index] = entry;
-
-  map->__element_count += 1;
-
-  return entry + descriptor->__val_offset;
-}
diff --git a/libgo/runtime/go-map-len.c b/libgo/runtime/go-map-len.c
deleted file mode 100644
index 7da10c2..0000000
--- a/libgo/runtime/go-map-len.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* go-map-len.c -- return the length of a map.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include <stddef.h>
-
-#include "runtime.h"
-#include "go-assert.h"
-#include "map.h"
-
-/* Return the length of a map.  This could be done inline, of course,
-   but I'm doing it as a function for now to make it easy to change
-   the map structure.  */
-
-intgo
-__go_map_len (struct __go_map *map)
-{
-  if (map == NULL)
-    return 0;
-  __go_assert (map->__element_count
-	       == (uintptr_t) (intgo) map->__element_count);
-  return map->__element_count;
-}
diff --git a/libgo/runtime/go-map-range.c b/libgo/runtime/go-map-range.c
deleted file mode 100644
index 5dbb92c..0000000
--- a/libgo/runtime/go-map-range.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* go-map-range.c -- implement a range clause over a map.
-
-   Copyright 2009, 2010 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include "runtime.h"
-#include "go-assert.h"
-#include "map.h"
-
-/* Initialize a range over a map.  */
-
-void
-__go_mapiterinit (const struct __go_map *h, struct __go_hash_iter *it)
-{
-  it->entry = NULL;
-  if (h != NULL)
-    {
-      it->map = h;
-      it->next_entry = NULL;
-      it->bucket = 0;
-      --it->bucket;
-      __go_mapiternext(it);
-    }
-}
-
-/* Move to the next iteration, updating *HITER.  */
-
-void
-__go_mapiternext (struct __go_hash_iter *it)
-{
-  const void *entry;
-
-  entry = it->next_entry;
-  if (entry == NULL)
-    {
-      const struct __go_map *map;
-      uintptr_t bucket;
-
-      map = it->map;
-      bucket = it->bucket;
-      while (1)
-	{
-	  ++bucket;
-	  if (bucket >= map->__bucket_count)
-	    {
-	      /* Map iteration is complete.  */
-	      it->entry = NULL;
-	      return;
-	    }
-	  entry = map->__buckets[bucket];
-	  if (entry != NULL)
-	    break;
-	}
-      it->bucket = bucket;
-    }
-  it->entry = entry;
-  it->next_entry = *(const void * const *) entry;
-}
-
-/* Get the key of the current iteration.  */
-
-void
-__go_mapiter1 (struct __go_hash_iter *it, unsigned char *key)
-{
-  const struct __go_map *map;
-  const struct __go_map_descriptor *descriptor;
-  const struct __go_type_descriptor *key_descriptor;
-  const char *p;
-
-  map = it->map;
-  descriptor = map->__descriptor;
-  key_descriptor = descriptor->__map_descriptor->__key_type;
-  p = it->entry;
-  __go_assert (p != NULL);
-  __builtin_memcpy (key, p + descriptor->__key_offset, key_descriptor->__size);
-}
-
-/* Get the key and value of the current iteration.  */
-
-void
-__go_mapiter2 (struct __go_hash_iter *it, unsigned char *key,
-	       unsigned char *val)
-{
-  const struct __go_map *map;
-  const struct __go_map_descriptor *descriptor;
-  const struct __go_map_type *map_descriptor;
-  const struct __go_type_descriptor *key_descriptor;
-  const struct __go_type_descriptor *val_descriptor;
-  const char *p;
-
-  map = it->map;
-  descriptor = map->__descriptor;
-  map_descriptor = descriptor->__map_descriptor;
-  key_descriptor = map_descriptor->__key_type;
-  val_descriptor = map_descriptor->__val_type;
-  p = it->entry;
-  __go_assert (p != NULL);
-  __builtin_memcpy (key, p + descriptor->__key_offset,
-		    key_descriptor->__size);
-  __builtin_memcpy (val, p + descriptor->__val_offset,
-		    val_descriptor->__size);
-}
diff --git a/libgo/runtime/go-memclr.c b/libgo/runtime/go-memclr.c
new file mode 100644
index 0000000..de6f39a
--- /dev/null
+++ b/libgo/runtime/go-memclr.c
@@ -0,0 +1,16 @@
+/* go-memclr.c -- clear a memory buffer
+
+   Copyright 2016 The Go Authors. All rights reserved.
+   Use of this source code is governed by a BSD-style
+   license that can be found in the LICENSE file.  */
+
+#include "runtime.h"
+
+void memclr(void *, uintptr)
+  __asm__ (GOSYM_PREFIX "runtime.memclr");
+
+void
+memclr (void *p1, uintptr len)
+{
+  __builtin_memset (p1, 0, len);
+}
diff --git a/libgo/runtime/go-memequal.c b/libgo/runtime/go-memequal.c
new file mode 100644
index 0000000..5f514aa
--- /dev/null
+++ b/libgo/runtime/go-memequal.c
@@ -0,0 +1,16 @@
+/* go-memequal.c -- compare memory buffers for equality
+
+   Copyright 2016 The Go Authors. All rights reserved.
+   Use of this source code is governed by a BSD-style
+   license that can be found in the LICENSE file.  */
+
+#include "runtime.h"
+
+_Bool memequal (void *, void *, uintptr)
+  __asm__ (GOSYM_PREFIX "runtime.memequal");
+
+_Bool
+memequal (void *p1, void *p2, uintptr len)
+{
+  return __builtin_memcmp (p1, p2, len) == 0;
+}
diff --git a/libgo/runtime/go-memmove.c b/libgo/runtime/go-memmove.c
new file mode 100644
index 0000000..a6fda08
--- /dev/null
+++ b/libgo/runtime/go-memmove.c
@@ -0,0 +1,16 @@
+/* go-memmove.c -- move one memory buffer to another
+
+   Copyright 2016 The Go Authors. All rights reserved.
+   Use of this source code is governed by a BSD-style
+   license that can be found in the LICENSE file.  */
+
+#include "runtime.h"
+
+void move(void *, void *, uintptr)
+  __asm__ (GOSYM_PREFIX "runtime.memmove");
+
+void
+move (void *p1, void *p2, uintptr len)
+{
+  __builtin_memmove (p1, p2, len);
+}
diff --git a/libgo/runtime/go-new-map.c b/libgo/runtime/go-new-map.c
deleted file mode 100644
index c289bc0..0000000
--- a/libgo/runtime/go-new-map.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/* go-new-map.c -- allocate a new map.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include "runtime.h"
-#include "go-alloc.h"
-#include "map.h"
-
-/* List of prime numbers, copied from libstdc++/src/hashtable.c.  */
-
-static const unsigned long prime_list[] = /* 256 + 1 or 256 + 48 + 1 */
-{
-  2ul, 3ul, 5ul, 7ul, 11ul, 13ul, 17ul, 19ul, 23ul, 29ul, 31ul,
-  37ul, 41ul, 43ul, 47ul, 53ul, 59ul, 61ul, 67ul, 71ul, 73ul, 79ul,
-  83ul, 89ul, 97ul, 103ul, 109ul, 113ul, 127ul, 137ul, 139ul, 149ul,
-  157ul, 167ul, 179ul, 193ul, 199ul, 211ul, 227ul, 241ul, 257ul,
-  277ul, 293ul, 313ul, 337ul, 359ul, 383ul, 409ul, 439ul, 467ul,
-  503ul, 541ul, 577ul, 619ul, 661ul, 709ul, 761ul, 823ul, 887ul,
-  953ul, 1031ul, 1109ul, 1193ul, 1289ul, 1381ul, 1493ul, 1613ul,
-  1741ul, 1879ul, 2029ul, 2179ul, 2357ul, 2549ul, 2753ul, 2971ul,
-  3209ul, 3469ul, 3739ul, 4027ul, 4349ul, 4703ul, 5087ul, 5503ul,
-  5953ul, 6427ul, 6949ul, 7517ul, 8123ul, 8783ul, 9497ul, 10273ul,
-  11113ul, 12011ul, 12983ul, 14033ul, 15173ul, 16411ul, 17749ul,
-  19183ul, 20753ul, 22447ul, 24281ul, 26267ul, 28411ul, 30727ul,
-  33223ul, 35933ul, 38873ul, 42043ul, 45481ul, 49201ul, 53201ul,
-  57557ul, 62233ul, 67307ul, 72817ul, 78779ul, 85229ul, 92203ul,
-  99733ul, 107897ul, 116731ul, 126271ul, 136607ul, 147793ul,
-  159871ul, 172933ul, 187091ul, 202409ul, 218971ul, 236897ul,
-  256279ul, 277261ul, 299951ul, 324503ul, 351061ul, 379787ul,
-  410857ul, 444487ul, 480881ul, 520241ul, 562841ul, 608903ul,
-  658753ul, 712697ul, 771049ul, 834181ul, 902483ul, 976369ul,
-  1056323ul, 1142821ul, 1236397ul, 1337629ul, 1447153ul, 1565659ul,
-  1693859ul, 1832561ul, 1982627ul, 2144977ul, 2320627ul, 2510653ul,
-  2716249ul, 2938679ul, 3179303ul, 3439651ul, 3721303ul, 4026031ul,
-  4355707ul, 4712381ul, 5098259ul, 5515729ul, 5967347ul, 6456007ul,
-  6984629ul, 7556579ul, 8175383ul, 8844859ul, 9569143ul, 10352717ul,
-  11200489ul, 12117689ul, 13109983ul, 14183539ul, 15345007ul,
-  16601593ul, 17961079ul, 19431899ul, 21023161ul, 22744717ul,
-  24607243ul, 26622317ul, 28802401ul, 31160981ul, 33712729ul,
-  36473443ul, 39460231ul, 42691603ul, 46187573ul, 49969847ul,
-  54061849ul, 58488943ul, 63278561ul, 68460391ul, 74066549ul,
-  80131819ul, 86693767ul, 93793069ul, 101473717ul, 109783337ul,
-  118773397ul, 128499677ul, 139022417ul, 150406843ul, 162723577ul,
-  176048909ul, 190465427ul, 206062531ul, 222936881ul, 241193053ul,
-  260944219ul, 282312799ul, 305431229ul, 330442829ul, 357502601ul,
-  386778277ul, 418451333ul, 452718089ul, 489790921ul, 529899637ul,
-  573292817ul, 620239453ul, 671030513ul, 725980837ul, 785430967ul,
-  849749479ul, 919334987ul, 994618837ul, 1076067617ul, 1164186217ul,
-  1259520799ul, 1362662261ul, 1474249943ul, 1594975441ul, 1725587117ul,
-  1866894511ul, 2019773507ul, 2185171673ul, 2364114217ul, 2557710269ul,
-  2767159799ul, 2993761039ul, 3238918481ul, 3504151727ul, 3791104843ul,
-  4101556399ul, 4294967291ul,
-#if __SIZEOF_LONG__ >= 8
-  6442450933ul, 8589934583ul, 12884901857ul, 17179869143ul,
-  25769803693ul, 34359738337ul, 51539607367ul, 68719476731ul,
-  103079215087ul, 137438953447ul, 206158430123ul, 274877906899ul,
-  412316860387ul, 549755813881ul, 824633720731ul, 1099511627689ul,
-  1649267441579ul, 2199023255531ul, 3298534883309ul, 4398046511093ul,
-  6597069766607ul, 8796093022151ul, 13194139533241ul, 17592186044399ul,
-  26388279066581ul, 35184372088777ul, 52776558133177ul, 70368744177643ul,
-  105553116266399ul, 140737488355213ul, 211106232532861ul, 281474976710597ul,
-  562949953421231ul, 1125899906842597ul, 2251799813685119ul,
-  4503599627370449ul, 9007199254740881ul, 18014398509481951ul,
-  36028797018963913ul, 72057594037927931ul, 144115188075855859ul,
-  288230376151711717ul, 576460752303423433ul,
-  1152921504606846883ul, 2305843009213693951ul,
-  4611686018427387847ul, 9223372036854775783ul,
-  18446744073709551557ul
-#endif
-};
-
-/* Return the next number from PRIME_LIST >= N.  */
-
-uintptr_t
-__go_map_next_prime (uintptr_t n)
-{
-  size_t low;
-  size_t high;
-
-  low = 0;
-  high = sizeof prime_list / sizeof prime_list[0];
-  while (low < high)
-    {
-      size_t mid;
-
-      mid = (low + high) / 2;
-
-      /* Here LOW <= MID < HIGH.  */
-
-      if (prime_list[mid] < n)
-	low = mid + 1;
-      else if (prime_list[mid] > n)
-	high = mid;
-      else
-	return n;
-    }
-  if (low >= sizeof prime_list / sizeof prime_list[0])
-    return n;
-  return prime_list[low];
-}
-
-/* Allocate a new map.  */
-
-struct __go_map *
-__go_new_map (const struct __go_map_descriptor *descriptor, uintptr_t entries)
-{
-  int32 ientries;
-  struct __go_map *ret;
-
-  /* The master library limits map entries to int32, so we do too.  */
-  ientries = (int32) entries;
-  if (ientries < 0 || (uintptr_t) ientries != entries)
-    runtime_panicstring ("map size out of range");
-
-  if (entries == 0)
-    entries = 5;
-  else
-    entries = __go_map_next_prime (entries);
-  ret = (struct __go_map *) __go_alloc (sizeof (struct __go_map));
-  ret->__descriptor = descriptor;
-  ret->__element_count = 0;
-  ret->__bucket_count = entries;
-  ret->__buckets = (void **) __go_alloc (entries * sizeof (void *));
-  __builtin_memset (ret->__buckets, 0, entries * sizeof (void *));
-  return ret;
-}
-
-/* Allocate a new map when the argument to make is a large type.  */
-
-struct __go_map *
-__go_new_map_big (const struct __go_map_descriptor *descriptor,
-		  uint64_t entries)
-{
-  uintptr_t sentries;
-
-  sentries = (uintptr_t) entries;
-  if ((uint64_t) sentries != entries)
-    runtime_panicstring ("map size out of range");
-  return __go_new_map (descriptor, sentries);
-}
diff --git a/libgo/runtime/go-reflect-map.c b/libgo/runtime/go-reflect-map.c
deleted file mode 100644
index 36f3102..0000000
--- a/libgo/runtime/go-reflect-map.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/* go-reflect-map.c -- map reflection support for Go.
-
-   Copyright 2009, 2010 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include <stdlib.h>
-#include <stdint.h>
-
-#include "runtime.h"
-#include "go-alloc.h"
-#include "go-assert.h"
-#include "go-type.h"
-#include "map.h"
-
-/* This file implements support for reflection on maps.  These
-   functions are called from reflect/value.go.  */
-
-extern void *mapaccess (struct __go_map_type *, void *, void *)
-  __asm__ (GOSYM_PREFIX "reflect.mapaccess");
-
-void *
-mapaccess (struct __go_map_type *mt, void *m, void *key)
-{
-  struct __go_map *map = (struct __go_map *) m;
-
-  __go_assert ((mt->__common.__code & GO_CODE_MASK) == GO_MAP);
-  if (map == NULL)
-    return NULL;
-  else
-    return __go_map_index (map, key, 0);
-}
-
-extern void mapassign (struct __go_map_type *, void *, void *, void *)
-  __asm__ (GOSYM_PREFIX "reflect.mapassign");
-
-void
-mapassign (struct __go_map_type *mt, void *m, void *key, void *val)
-{
-  struct __go_map *map = (struct __go_map *) m;
-  void *p;
-
-  __go_assert ((mt->__common.__code & GO_CODE_MASK) == GO_MAP);
-  if (map == NULL)
-    runtime_panicstring ("assignment to entry in nil map");
-  p = __go_map_index (map, key, 1);
-  __builtin_memcpy (p, val, mt->__val_type->__size);
-}
-
-extern void mapdelete (struct __go_map_type *, void *, void *)
-  __asm__ (GOSYM_PREFIX "reflect.mapdelete");
-
-void
-mapdelete (struct __go_map_type *mt, void *m, void *key)
-{
-  struct __go_map *map = (struct __go_map *) m;
-
-  __go_assert ((mt->__common.__code & GO_CODE_MASK) == GO_MAP);
-  if (map == NULL)
-    return;
-  __go_map_delete (map, key);
-}
-
-extern int32_t maplen (void *) __asm__ (GOSYM_PREFIX "reflect.maplen");
-
-int32_t
-maplen (void *m)
-{
-  struct __go_map *map = (struct __go_map *) m;
-
-  if (map == NULL)
-    return 0;
-  return (int32_t) map->__element_count;
-}
-
-extern unsigned char *mapiterinit (struct __go_map_type *, void *)
-  __asm__ (GOSYM_PREFIX "reflect.mapiterinit");
-
-unsigned char *
-mapiterinit (struct __go_map_type *mt, void *m)
-{
-  struct __go_hash_iter *it;
-
-  __go_assert ((mt->__common.__code & GO_CODE_MASK) == GO_MAP);
-  it = __go_alloc (sizeof (struct __go_hash_iter));
-  __go_mapiterinit ((struct __go_map *) m, it);
-  return (unsigned char *) it;
-}
-
-extern void mapiternext (void *) __asm__ (GOSYM_PREFIX "reflect.mapiternext");
-
-void
-mapiternext (void *it)
-{
-  __go_mapiternext ((struct __go_hash_iter *) it);
-}
-
-extern void *mapiterkey (void *) __asm__ (GOSYM_PREFIX "reflect.mapiterkey");
-
-void *
-mapiterkey (void *ita)
-{
-  struct __go_hash_iter *it = (struct __go_hash_iter *) ita;
-  const struct __go_type_descriptor *key_descriptor;
-  void *key;
-
-  if (it->entry == NULL)
-    return NULL;
-
-  key_descriptor = it->map->__descriptor->__map_descriptor->__key_type;
-  key = __go_alloc (key_descriptor->__size);
-  __go_mapiter1 (it, key);
-  return key;
-}
-
-/* Make a new map.  We have to build our own map descriptor.  */
-
-extern struct __go_map *makemap (const struct __go_map_type *)
-  __asm__ (GOSYM_PREFIX "reflect.makemap");
-
-struct __go_map *
-makemap (const struct __go_map_type *t)
-{
-  struct __go_map_descriptor *md;
-  unsigned int o;
-  const struct __go_type_descriptor *kt;
-  const struct __go_type_descriptor *vt;
-
-  md = (struct __go_map_descriptor *) __go_alloc (sizeof (*md));
-  md->__map_descriptor = t;
-  o = sizeof (void *);
-  kt = t->__key_type;
-  o = (o + kt->__field_align - 1) & ~ (kt->__field_align - 1);
-  md->__key_offset = o;
-  o += kt->__size;
-  vt = t->__val_type;
-  o = (o + vt->__field_align - 1) & ~ (vt->__field_align - 1);
-  md->__val_offset = o;
-  o += vt->__size;
-  o = (o + sizeof (void *) - 1) & ~ (sizeof (void *) - 1);
-  o = (o + kt->__field_align - 1) & ~ (kt->__field_align - 1);
-  o = (o + vt->__field_align - 1) & ~ (vt->__field_align - 1);
-  md->__entry_size = o;
-
-  return __go_new_map (md, 0);
-}
-
-extern _Bool ismapkey (const struct __go_type_descriptor *)
-  __asm__ (GOSYM_PREFIX "reflect.ismapkey");
-
-_Bool
-ismapkey (const struct __go_type_descriptor *typ)
-{
-  return (typ != NULL
-	  && (void *) typ->__hashfn->fn != (void *) __go_type_hash_error);
-}
diff --git a/libgo/runtime/go-type-complex.c b/libgo/runtime/go-type-complex.c
index 585984e..829572b 100644
--- a/libgo/runtime/go-type-complex.c
+++ b/libgo/runtime/go-type-complex.c
@@ -14,7 +14,7 @@
 /* Hash function for float types.  */
 
 uintptr_t
-__go_type_hash_complex (const void *vkey, uintptr_t key_size)
+__go_type_hash_complex (const void *vkey, uintptr_t seed, uintptr_t key_size)
 {
   if (key_size == 8)
     {
@@ -31,7 +31,7 @@ __go_type_hash_complex (const void *vkey, uintptr_t key_size)
       cfi = cimagf (cf);
 
       if (isinf (cfr) || isinf (cfi))
-	return 0;
+	return seed;
 
       /* NaN != NaN, so the hash code of a NaN is irrelevant.  Make it
 	 random so that not all NaNs wind up in the same place.  */
@@ -40,14 +40,14 @@ __go_type_hash_complex (const void *vkey, uintptr_t key_size)
 
       /* Avoid negative zero.  */
       if (cfr == 0 && cfi == 0)
-	return 0;
+	return seed;
       else if (cfr == 0)
 	cf = cfi * I;
       else if (cfi == 0)
 	cf = cfr;
 
       memcpy (&fi, &cf, 8);
-      return (uintptr_t) cfi;
+      return (uintptr_t) cfi ^ seed;
     }
   else if (key_size == 16)
     {
@@ -64,21 +64,21 @@ __go_type_hash_complex (const void *vkey, uintptr_t key_size)
       cdi = cimag (cd);
 
       if (isinf (cdr) || isinf (cdi))
-	return 0;
+	return seed;
 
       if (isnan (cdr) || isnan (cdi))
 	return runtime_fastrand1 ();
 
       /* Avoid negative zero.  */
       if (cdr == 0 && cdi == 0)
-	return 0;
+	return seed;
       else if (cdr == 0)
 	cd = cdi * I;
       else if (cdi == 0)
 	cd = cdr;
 
       memcpy (&di, &cd, 16);
-      return di[0] ^ di[1];
+      return di[0] ^ di[1] ^ seed;
     }
   else
     runtime_throw ("__go_type_hash_complex: invalid complex size");
diff --git a/libgo/runtime/go-type-eface.c b/libgo/runtime/go-type-eface.c
index 315c30e..a98bcea 100644
--- a/libgo/runtime/go-type-eface.c
+++ b/libgo/runtime/go-type-eface.c
@@ -11,7 +11,7 @@
 /* A hash function for an empty interface.  */
 
 uintptr_t
-__go_type_hash_empty_interface (const void *vval,
+__go_type_hash_empty_interface (const void *vval, uintptr_t seed,
 				uintptr_t key_size __attribute__ ((unused)))
 {
   const struct __go_empty_interface *val;
@@ -22,11 +22,13 @@ __go_type_hash_empty_interface (const void *vval,
   descriptor = val->__type_descriptor;
   if (descriptor == NULL)
     return 0;
+  if (descriptor->__hashfn == NULL)
+    runtime_panicstring ("hash of unhashable type");
   size = descriptor->__size;
   if (__go_is_pointer_type (descriptor))
-    return __go_call_hashfn (descriptor->__hashfn, &val->__object, size);
+    return __go_call_hashfn (descriptor->__hashfn, &val->__object, seed, size);
   else
-    return __go_call_hashfn (descriptor->__hashfn, val->__object, size);
+    return __go_call_hashfn (descriptor->__hashfn, val->__object, seed, size);
 }
 
 const FuncVal __go_type_hash_empty_interface_descriptor =
@@ -51,6 +53,8 @@ __go_type_equal_empty_interface (const void *vv1, const void *vv2,
     return v1_descriptor == v2_descriptor;
   if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
     return 0;
+  if (v1_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (v1_descriptor))
     return v1->__object == v2->__object;
   else
diff --git a/libgo/runtime/go-type-error.c b/libgo/runtime/go-type-error.c
deleted file mode 100644
index 8881a86..0000000
--- a/libgo/runtime/go-type-error.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/* go-type-error.c -- invalid hash and equality functions.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include "runtime.h"
-#include "go-type.h"
-
-/* A hash function used for a type which does not support hash
-   functions.  */
-
-uintptr_t
-__go_type_hash_error (const void *val __attribute__ ((unused)),
-		      uintptr_t key_size __attribute__ ((unused)))
-{
-  runtime_panicstring ("hash of unhashable type");
-}
-
-const FuncVal __go_type_hash_error_descriptor =
-  { (void *) __go_type_hash_error };
-
-/* An equality function for an interface.  */
-
-_Bool
-__go_type_equal_error (const void *v1 __attribute__ ((unused)),
-		       const void *v2 __attribute__ ((unused)),
-		       uintptr_t key_size __attribute__ ((unused)))
-{
-  runtime_panicstring ("comparing uncomparable types");
-}
-
-const FuncVal __go_type_equal_error_descriptor =
-  { (void *) __go_type_equal_error };
diff --git a/libgo/runtime/go-type-float.c b/libgo/runtime/go-type-float.c
index 39f9b29..ae0e336 100644
--- a/libgo/runtime/go-type-float.c
+++ b/libgo/runtime/go-type-float.c
@@ -12,7 +12,7 @@
 /* Hash function for float types.  */
 
 uintptr_t
-__go_type_hash_float (const void *vkey, uintptr_t key_size)
+__go_type_hash_float (const void *vkey, uintptr_t seed, uintptr_t key_size)
 {
   if (key_size == 4)
     {
@@ -24,7 +24,7 @@ __go_type_hash_float (const void *vkey, uintptr_t key_size)
       f = *fp;
 
       if (isinf (f) || f == 0)
-	return 0;
+	return seed;
 
       /* NaN != NaN, so the hash code of a NaN is irrelevant.  Make it
 	 random so that not all NaNs wind up in the same place.  */
@@ -32,7 +32,7 @@ __go_type_hash_float (const void *vkey, uintptr_t key_size)
 	return runtime_fastrand1 ();
 
       memcpy (&si, vkey, 4);
-      return (uintptr_t) si;
+      return (uintptr_t) si ^ seed;
     }
   else if (key_size == 8)
     {
@@ -44,13 +44,13 @@ __go_type_hash_float (const void *vkey, uintptr_t key_size)
       d = *dp;
 
       if (isinf (d) || d == 0)
-	return 0;
+	return seed;
 
       if (isnan (d))
 	return runtime_fastrand1 ();
 
       memcpy (&di, vkey, 8);
-      return (uintptr_t) di;
+      return (uintptr_t) di ^ seed;
     }
   else
     runtime_throw ("__go_type_hash_float: invalid float size");
diff --git a/libgo/runtime/go-type-identity.c b/libgo/runtime/go-type-identity.c
index a334d56..d58aa75 100644
--- a/libgo/runtime/go-type-identity.c
+++ b/libgo/runtime/go-type-identity.c
@@ -14,7 +14,7 @@
    true of, e.g., integers and pointers.  */
 
 uintptr_t
-__go_type_hash_identity (const void *key, uintptr_t key_size)
+__go_type_hash_identity (const void *key, uintptr_t seed, uintptr_t key_size)
 {
   uintptr_t ret;
   uintptr_t i;
@@ -34,12 +34,12 @@ __go_type_hash_identity (const void *key, uintptr_t key_size)
       __builtin_memcpy (&u.a[0], key, key_size);
 #endif
       if (sizeof (uintptr_t) >= 8)
-	return (uintptr_t) u.v;
+	return (uintptr_t) u.v ^ seed;
       else
-	return (uintptr_t) ((u.v >> 32) ^ (u.v & 0xffffffff));
+	return (uintptr_t) ((u.v >> 32) ^ (u.v & 0xffffffff)) ^ seed;
     }
 
-  ret = 5381;
+  ret = seed;
   for (i = 0, p = (const unsigned char *) key; i < key_size; i++, p++)
     ret = ret * 33 + *p;
   return ret;
diff --git a/libgo/runtime/go-type-interface.c b/libgo/runtime/go-type-interface.c
index e9e5779..ffba7b2 100644
--- a/libgo/runtime/go-type-interface.c
+++ b/libgo/runtime/go-type-interface.c
@@ -11,7 +11,7 @@
 /* A hash function for an interface.  */
 
 uintptr_t
-__go_type_hash_interface (const void *vval,
+__go_type_hash_interface (const void *vval, uintptr_t seed,
 			  uintptr_t key_size __attribute__ ((unused)))
 {
   const struct __go_interface *val;
@@ -22,11 +22,13 @@ __go_type_hash_interface (const void *vval,
   if (val->__methods == NULL)
     return 0;
   descriptor = (const struct __go_type_descriptor *) val->__methods[0];
+  if (descriptor->__hashfn == NULL)
+    runtime_panicstring ("hash of unhashable type");
   size = descriptor->__size;
   if (__go_is_pointer_type (descriptor))
-    return __go_call_hashfn (descriptor->__hashfn, &val->__object, size);
+    return __go_call_hashfn (descriptor->__hashfn, &val->__object, seed, size);
   else
-    return __go_call_hashfn (descriptor->__hashfn, val->__object, size);
+    return __go_call_hashfn (descriptor->__hashfn, val->__object, seed, size);
 }
 
 const FuncVal __go_type_hash_interface_descriptor =
@@ -51,6 +53,8 @@ __go_type_equal_interface (const void *vv1, const void *vv2,
   v2_descriptor = (const struct __go_type_descriptor *) v2->__methods[0];
   if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
     return 0;
+  if (v1_descriptor->__equalfn == NULL)
+    runtime_panicstring ("comparing uncomparable types");
   if (__go_is_pointer_type (v1_descriptor))
     return v1->__object == v2->__object;
   else
diff --git a/libgo/runtime/go-type-string.c b/libgo/runtime/go-type-string.c
index 3d33d6e..c7277dd 100644
--- a/libgo/runtime/go-type-string.c
+++ b/libgo/runtime/go-type-string.c
@@ -11,7 +11,7 @@
 /* A string hash function for a map.  */
 
 uintptr_t
-__go_type_hash_string (const void *vkey,
+__go_type_hash_string (const void *vkey, uintptr_t seed,
 		       uintptr_t key_size __attribute__ ((unused)))
 {
   uintptr_t ret;
@@ -20,7 +20,7 @@ __go_type_hash_string (const void *vkey,
   intgo i;
   const byte *p;
 
-  ret = 5381;
+  ret = seed;
   key = (const String *) vkey;
   len = key->len;
   for (i = 0, p = key->str; i < len; i++, p++)
diff --git a/libgo/runtime/go-type.h b/libgo/runtime/go-type.h
index eb063ec..7c3149b 100644
--- a/libgo/runtime/go-type.h
+++ b/libgo/runtime/go-type.h
@@ -257,6 +257,33 @@ struct __go_map_type
 
   /* The map value type.  */
   const struct __go_type_descriptor *__val_type;
+
+  /* The map bucket type.  */
+  const struct __go_type_descriptor *__bucket_type;
+
+  /* The map header type.  */
+  const struct __go_type_descriptor *__hmap_type;
+
+  /* The size of the key slot.  */
+  uint8_t __key_size;
+
+  /* Whether to store a pointer to key rather than the key itself.  */
+  uint8_t __indirect_key;
+
+  /* The size of the value slot.  */
+  uint8_t __value_size;
+
+  /* Whether to store a pointer to value rather than the value itself.  */
+  uint8_t __indirect_value;
+
+  /* The size of a bucket.  */
+  uint16_t __bucket_size;
+
+  /* Whether the key type is reflexive--whether k==k for all keys.  */
+  _Bool __reflexive_key;
+
+  /* Whether we should update the key when overwriting an entry.  */
+  _Bool __need_key_update;
 };
 
 /* A pointer type.  */
@@ -314,10 +341,11 @@ __go_is_pointer_type (const struct __go_type_descriptor *td)
 /* Call a type hash function, given the __hashfn value.  */
 
 static inline uintptr_t
-__go_call_hashfn (const FuncVal *hashfn, const void *p, uintptr_t size)
+__go_call_hashfn (const FuncVal *hashfn, const void *p, uintptr_t seed,
+		  uintptr_t size)
 {
-  uintptr_t (*h) (const void *, uintptr_t) = (void *) hashfn->fn;
-  return __builtin_call_with_static_chain (h (p, size), hashfn);
+  uintptr_t (*h) (const void *, uintptr_t, uintptr_t) = (void *) hashfn->fn;
+  return __builtin_call_with_static_chain (h (p, seed, size), hashfn);
 }
 
 /* Call a type equality function, given the __equalfn value.  */
@@ -334,29 +362,25 @@ extern _Bool
 __go_type_descriptors_equal(const struct __go_type_descriptor*,
 			    const struct __go_type_descriptor*);
 
-extern uintptr_t __go_type_hash_identity (const void *, uintptr_t);
+extern uintptr_t __go_type_hash_identity (const void *, uintptr_t, uintptr_t);
 extern const FuncVal __go_type_hash_identity_descriptor;
 extern _Bool __go_type_equal_identity (const void *, const void *, uintptr_t);
 extern const FuncVal __go_type_equal_identity_descriptor;
-extern uintptr_t __go_type_hash_string (const void *, uintptr_t);
+extern uintptr_t __go_type_hash_string (const void *, uintptr_t, uintptr_t);
 extern const FuncVal __go_type_hash_string_descriptor;
 extern _Bool __go_type_equal_string (const void *, const void *, uintptr_t);
 extern const FuncVal __go_type_equal_string_descriptor;
-extern uintptr_t __go_type_hash_float (const void *, uintptr_t);
+extern uintptr_t __go_type_hash_float (const void *, uintptr_t, uintptr_t);
 extern const FuncVal __go_type_hash_float_descriptor;
 extern _Bool __go_type_equal_float (const void *, const void *, uintptr_t);
 extern const FuncVal __go_type_equal_float_descriptor;
-extern uintptr_t __go_type_hash_complex (const void *, uintptr_t);
+extern uintptr_t __go_type_hash_complex (const void *, uintptr_t, uintptr_t);
 extern const FuncVal __go_type_hash_complex_descriptor;
 extern _Bool __go_type_equal_complex (const void *, const void *, uintptr_t);
 extern const FuncVal __go_type_equal_complex_descriptor;
-extern uintptr_t __go_type_hash_interface (const void *, uintptr_t);
+extern uintptr_t __go_type_hash_interface (const void *, uintptr_t, uintptr_t);
 extern const FuncVal __go_type_hash_interface_descriptor;
 extern _Bool __go_type_equal_interface (const void *, const void *, uintptr_t);
 extern const FuncVal __go_type_equal_interface_descriptor;
-extern uintptr_t __go_type_hash_error (const void *, uintptr_t);
-extern const FuncVal __go_type_hash_error_descriptor;
-extern _Bool __go_type_equal_error (const void *, const void *, uintptr_t);
-extern const FuncVal __go_type_equal_error_descriptor;
 
 #endif /* !defined(LIBGO_GO_TYPE_H) */
diff --git a/libgo/runtime/malloc.goc b/libgo/runtime/malloc.goc
index fbb7b74..591d06a 100644
--- a/libgo/runtime/malloc.goc
+++ b/libgo/runtime/malloc.goc
@@ -23,9 +23,6 @@ package runtime
 // Type aka __go_type_descriptor
 #define kind __code
 #define string __reflection
-#define KindPtr GO_PTR
-#define KindNoPointers GO_NO_POINTERS
-#define kindMask GO_CODE_MASK
 
 // GCCGO SPECIFIC CHANGE
 //
@@ -893,7 +890,7 @@ runtime_mal(uintptr n)
 }
 
 func new(typ *Type) (ret *uint8) {
-	ret = runtime_mallocgc(typ->__size, (uintptr)typ | TypeInfo_SingleObject, typ->kind&KindNoPointers ? FlagNoScan : 0);
+	ret = runtime_mallocgc(typ->__size, (uintptr)typ | TypeInfo_SingleObject, typ->kind&kindNoPointers ? FlagNoScan : 0);
 }
 
 static void*
@@ -903,7 +900,7 @@ cnew(const Type *typ, intgo n, int32 objtyp)
 		runtime_throw("runtime: invalid objtyp");
 	if(n < 0 || (typ->__size > 0 && (uintptr)n > (MaxMem/typ->__size)))
 		runtime_panicstring("runtime: allocation size out of range");
-	return runtime_mallocgc(typ->__size*n, (uintptr)typ | objtyp, typ->kind&KindNoPointers ? FlagNoScan : 0);
+	return runtime_mallocgc(typ->__size*n, (uintptr)typ | objtyp, typ->kind&kindNoPointers ? FlagNoScan : 0);
 }
 
 // same as runtime_new, but callable from C
@@ -955,7 +952,7 @@ func SetFinalizer(obj Eface, finalizer Eface) {
 	if(!runtime_mlookup(obj.__object, &base, &size, nil) || obj.__object != base) {
 		// As an implementation detail we allow to set finalizers for an inner byte
 		// of an object if it could come from tiny alloc (see mallocgc for details).
-		if(ot->__element_type == nil || (ot->__element_type->kind&KindNoPointers) == 0 || ot->__element_type->__size >= TinySize) {
+		if(ot->__element_type == nil || (ot->__element_type->kind&kindNoPointers) == 0 || ot->__element_type->__size >= TinySize) {
 			runtime_printf("runtime.SetFinalizer: pointer not at beginning of allocated block (%p)\n", obj.__object);
 			goto throw;
 		}
diff --git a/libgo/runtime/malloc.h b/libgo/runtime/malloc.h
index acd919f..1efbbbe 100644
--- a/libgo/runtime/malloc.h
+++ b/libgo/runtime/malloc.h
@@ -391,7 +391,7 @@ struct MCentral
 	Lock;
 	int32 sizeclass;
 	MSpan nonempty;	// list of spans with a free object
-	MSpan empty;	// list of spans with no free objects (or cached in an MCache)
+	MSpan mempty;	// list of spans with no free objects (or cached in an MCache)
 	int32 nfree;	// # of objects available in nonempty spans
 };
 
@@ -478,8 +478,10 @@ extern	int32	runtime_checking;
 void	runtime_markspan(void *v, uintptr size, uintptr n, bool leftover);
 void	runtime_unmarkspan(void *v, uintptr size);
 void	runtime_purgecachedstats(MCache*);
-void*	runtime_cnew(const Type*);
-void*	runtime_cnewarray(const Type*, intgo);
+void*	runtime_cnew(const Type*)
+	  __asm__(GOSYM_PREFIX "runtime.newobject");
+void*	runtime_cnewarray(const Type*, intgo)
+	  __asm__(GOSYM_PREFIX "runtime.newarray");
 void	runtime_tracealloc(void*, uintptr, uintptr);
 void	runtime_tracefree(void*, uintptr);
 void	runtime_tracegc(void);
diff --git a/libgo/runtime/map.goc b/libgo/runtime/map.goc
deleted file mode 100644
index e4b8456..0000000
--- a/libgo/runtime/map.goc
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "map.h"
-
-typedef struct __go_map Hmap;
-typedef struct __go_hash_iter hiter;
-
-/* Access a value in a map, returning a value and a presence indicator.  */
-
-func mapaccess2(t *MapType, h *Hmap, key *byte, val *byte) (present bool) {
-	byte *mapval;
-	size_t valsize;
-
-	mapval = __go_map_index(h, key, 0);
-	valsize = t->__val_type->__size;
-	if (mapval == nil) {
-		__builtin_memset(val, 0, valsize);
-		present = 0;
-	} else {
-		__builtin_memcpy(val, mapval, valsize);
-		present = 1;
-	}
-}
-
-/* Optionally assign a value to a map (m[k] = v, p).  */
-
-func mapassign2(h *Hmap, key *byte, val *byte, p bool) {
-	if (!p) {
-		__go_map_delete(h, key);
-	} else {
-		byte *mapval;
-		size_t valsize;
-
-		mapval = __go_map_index(h, key, 1);
-		valsize = h->__descriptor->__map_descriptor->__val_type->__size;
-		__builtin_memcpy(mapval, val, valsize);
-	}
-}
-
-/* Delete a key from a map.  */
-
-func mapdelete(h *Hmap, key *byte) {
-	__go_map_delete(h, key);
-}
-
-/* Initialize a range over a map.  */
-
-func mapiterinit(h *Hmap, it *hiter) {
-	__go_mapiterinit(h, it);
-}
-
-/* Move to the next iteration, updating *HITER.  */
-
-func mapiternext(it *hiter) {
-	__go_mapiternext(it);
-}
-
-/* Get the key of the current iteration.  */
-
-func mapiter1(it *hiter, key *byte) {
-	__go_mapiter1(it, key);
-}
-
-/* Get the key and value of the current iteration.  */
-
-func mapiter2(it *hiter, key *byte, val *byte) {
-	__go_mapiter2(it, key, val);
-}
diff --git a/libgo/runtime/map.h b/libgo/runtime/map.h
deleted file mode 100644
index 0c587bb..0000000
--- a/libgo/runtime/map.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/* map.h -- the map type for Go.
-
-   Copyright 2009 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.  */
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "go-type.h"
-
-/* A map descriptor is what we need to manipulate the map.  This is
-   constant for a given map type.  */
-
-struct __go_map_descriptor
-{
-  /* A pointer to the type descriptor for the type of the map itself.  */
-  const struct __go_map_type *__map_descriptor;
-
-  /* A map entry is a struct with three fields:
-       map_entry_type *next_entry;
-       key_type key;
-       value_type value;
-     This is the size of that struct.  */
-  uintptr_t __entry_size;
-
-  /* The offset of the key field in a map entry struct.  */
-  uintptr_t __key_offset;
-
-  /* The offset of the value field in a map entry struct (the value
-     field immediately follows the key field, but there may be some
-     bytes inserted for alignment).  */
-  uintptr_t __val_offset;
-};
-
-struct __go_map
-{
-  /* The constant descriptor for this map.  */
-  const struct __go_map_descriptor *__descriptor;
-
-  /* The number of elements in the hash table.  */
-  uintptr_t __element_count;
-
-  /* The number of entries in the __buckets array.  */
-  uintptr_t __bucket_count;
-
-  /* Each bucket is a pointer to a linked list of map entries.  */
-  void **__buckets;
-};
-
-/* For a map iteration the compiled code will use a pointer to an
-   iteration structure.  The iteration structure will be allocated on
-   the stack.  The Go code must allocate at least enough space.  */
-
-struct __go_hash_iter
-{
-  /* A pointer to the current entry.  This will be set to NULL when
-     the range has completed.  The Go will test this field, so it must
-     be the first one in the structure.  */
-  const void *entry;
-  /* The map we are iterating over.  */
-  const struct __go_map *map;
-  /* A pointer to the next entry in the current bucket.  This permits
-     deleting the current entry.  This will be NULL when we have seen
-     all the entries in the current bucket.  */
-  const void *next_entry;
-  /* The bucket index of the current and next entry.  */
-  uintptr_t bucket;
-};
-
-extern struct __go_map *__go_new_map (const struct __go_map_descriptor *,
-				      uintptr_t);
-
-extern uintptr_t __go_map_next_prime (uintptr_t);
-
-extern void *__go_map_index (struct __go_map *, const void *, _Bool);
-
-extern void __go_map_delete (struct __go_map *, const void *);
-
-extern void __go_mapiterinit (const struct __go_map *, struct __go_hash_iter *);
-
-extern void __go_mapiternext (struct __go_hash_iter *);
-
-extern void __go_mapiter1 (struct __go_hash_iter *it, unsigned char *key);
-
-extern void __go_mapiter2 (struct __go_hash_iter *it, unsigned char *key,
-			   unsigned char *val);
diff --git a/libgo/runtime/mcentral.c b/libgo/runtime/mcentral.c
index 62e2c2d..491cac53 100644
--- a/libgo/runtime/mcentral.c
+++ b/libgo/runtime/mcentral.c
@@ -8,7 +8,7 @@
 //
 // The MCentral doesn't actually contain the list of free objects; the MSpan does.
 // Each MCentral is two lists of MSpans: those with free objects (c->nonempty)
-// and those that are completely allocated (c->empty).
+// and those that are completely allocated (c->mempty).
 //
 // TODO(rsc): tcmalloc uses a "transfer cache" to split the list
 // into sections of class_to_transfercount[sizeclass] objects
@@ -28,7 +28,7 @@ runtime_MCentral_Init(MCentral *c, int32 sizeclass)
 {
 	c->sizeclass = sizeclass;
 	runtime_MSpanList_Init(&c->nonempty);
-	runtime_MSpanList_Init(&c->empty);
+	runtime_MSpanList_Init(&c->mempty);
 }
 
 // Allocate a span to use in an MCache.
@@ -58,13 +58,13 @@ retry:
 		goto havespan;
 	}
 
-	for(s = c->empty.next; s != &c->empty; s = s->next) {
+	for(s = c->mempty.next; s != &c->mempty; s = s->next) {
 		if(s->sweepgen == sg-2 && runtime_cas(&s->sweepgen, sg-2, sg-1)) {
 			// we have an empty span that requires sweeping,
 			// sweep it and see if we can free some space in it
 			runtime_MSpanList_Remove(s);
 			// swept spans are at the end of the list
-			runtime_MSpanList_InsertBack(&c->empty, s);
+			runtime_MSpanList_InsertBack(&c->mempty, s);
 			runtime_unlock(c);
 			runtime_MSpan_Sweep(s);
 			runtime_lock(c);
@@ -96,7 +96,7 @@ havespan:
 		runtime_throw("freelist empty");
 	c->nfree -= n;
 	runtime_MSpanList_Remove(s);
-	runtime_MSpanList_InsertBack(&c->empty, s);
+	runtime_MSpanList_InsertBack(&c->mempty, s);
 	s->incache = true;
 	runtime_unlock(c);
 	return s;
diff --git a/libgo/runtime/mgc0.c b/libgo/runtime/mgc0.c
index 1f6a40c..341544c 100644
--- a/libgo/runtime/mgc0.c
+++ b/libgo/runtime/mgc0.c
@@ -69,9 +69,6 @@
 typedef struct __go_map Hmap;
 // Type aka __go_type_descriptor
 #define string __reflection
-#define KindPtr GO_PTR
-#define KindNoPointers GO_NO_POINTERS
-#define kindMask GO_CODE_MASK
 // PtrType aka __go_ptr_type
 #define elem __element_type
 
@@ -216,7 +213,7 @@ static void	addstackroots(G *gp, Workbuf **wbufp);
 
 static struct {
 	uint64	full;  // lock-free list of full blocks
-	uint64	empty; // lock-free list of empty blocks
+	uint64	wempty; // lock-free list of empty blocks
 	byte	pad0[CacheLineSize]; // prevents false-sharing between full/empty and nproc/nwait
 	uint32	nproc;
 	int64	tstart;
@@ -943,16 +940,16 @@ scanblock(Workbuf *wbuf, bool keepworking)
 			// eface->__object
 			if((byte*)eface->__object >= arena_start && (byte*)eface->__object < arena_used) {
 				if(__go_is_pointer_type(t)) {
-					if((t->__code & KindNoPointers))
+					if((t->__code & kindNoPointers))
 						continue;
 
 					obj = eface->__object;
-					if((t->__code & kindMask) == KindPtr) {
+					if((t->__code & kindMask) == kindPtr) {
 						// Only use type information if it is a pointer-containing type.
 						// This matches the GC programs written by cmd/gc/reflect.c's
 						// dgcsym1 in case TPTR32/case TPTR64. See rationale there.
 						et = ((const PtrType*)t)->elem;
-						if(!(et->__code & KindNoPointers))
+						if(!(et->__code & kindNoPointers))
 							objti = (uintptr)((const PtrType*)t)->elem->__gc;
 					}
 				} else {
@@ -981,16 +978,16 @@ scanblock(Workbuf *wbuf, bool keepworking)
 			if((byte*)iface->__object >= arena_start && (byte*)iface->__object < arena_used) {
 				t = (const Type*)iface->tab[0];
 				if(__go_is_pointer_type(t)) {
-					if((t->__code & KindNoPointers))
+					if((t->__code & kindNoPointers))
 						continue;
 
 					obj = iface->__object;
-					if((t->__code & kindMask) == KindPtr) {
+					if((t->__code & kindMask) == kindPtr) {
 						// Only use type information if it is a pointer-containing type.
 						// This matches the GC programs written by cmd/gc/reflect.c's
 						// dgcsym1 in case TPTR32/case TPTR64. See rationale there.
 						et = ((const PtrType*)t)->elem;
-						if(!(et->__code & KindNoPointers))
+						if(!(et->__code & kindNoPointers))
 							objti = (uintptr)((const PtrType*)t)->elem->__gc;
 					}
 				} else {
@@ -1101,7 +1098,7 @@ scanblock(Workbuf *wbuf, bool keepworking)
 			}
 			if(markonly(chan)) {
 				chantype = (ChanType*)pc[2];
-				if(!(chantype->elem->__code & KindNoPointers)) {
+				if(!(chantype->elem->__code & kindNoPointers)) {
 					// Start chanProg.
 					chan_ret = pc+3;
 					pc = chanProg+1;
@@ -1114,7 +1111,7 @@ scanblock(Workbuf *wbuf, bool keepworking)
 		case GC_CHAN:
 			// There are no heap pointers in struct Hchan,
 			// so we can ignore the leading sizeof(Hchan) bytes.
-			if(!(chantype->elem->__code & KindNoPointers)) {
+			if(!(chantype->elem->__code & kindNoPointers)) {
 				// Channel's buffer follows Hchan immediately in memory.
 				// Size of buffer (cap(c)) is second int in the chan struct.
 				chancap = ((uintgo*)chan)[1];
@@ -1377,7 +1374,7 @@ getempty(Workbuf *b)
 {
 	if(b != nil)
 		runtime_lfstackpush(&work.full, &b->node);
-	b = (Workbuf*)runtime_lfstackpop(&work.empty);
+	b = (Workbuf*)runtime_lfstackpop(&work.wempty);
 	if(b == nil) {
 		// Need to allocate.
 		runtime_lock(&work);
@@ -1402,7 +1399,7 @@ putempty(Workbuf *b)
 	if(CollectStats)
 		runtime_xadd64(&gcstats.putempty, 1);
 
-	runtime_lfstackpush(&work.empty, &b->node);
+	runtime_lfstackpush(&work.wempty, &b->node);
 }
 
 // Get a full work buffer off the work.full list, or return nil.
@@ -1416,7 +1413,7 @@ getfull(Workbuf *b)
 		runtime_xadd64(&gcstats.getfull, 1);
 
 	if(b != nil)
-		runtime_lfstackpush(&work.empty, &b->node);
+		runtime_lfstackpush(&work.wempty, &b->node);
 	b = (Workbuf*)runtime_lfstackpop(&work.full);
 	if(b != nil || work.nproc == 1)
 		return b;
@@ -2129,7 +2126,7 @@ runtime_gc(int32 force)
 	// The atomic operations are not atomic if the uint64s
 	// are not aligned on uint64 boundaries. This has been
 	// a problem in the past.
-	if((((uintptr)&work.empty) & 7) != 0)
+	if((((uintptr)&work.wempty) & 7) != 0)
 		runtime_throw("runtime: gc work buffer is misaligned");
 	if((((uintptr)&work.full) & 7) != 0)
 		runtime_throw("runtime: gc work buffer is misaligned");
@@ -2522,7 +2519,7 @@ runfinq(void* dummy __attribute__ ((unused)))
 
 				f = &fb->fin[i];
 				fint = ((const Type**)f->ft->__in.array)[0];
-				if((fint->__code & kindMask) == KindPtr) {
+				if((fint->__code & kindMask) == kindPtr) {
 					// direct use of pointer
 					param = &f->arg;
 				} else if(((const InterfaceType*)fint)->__methods.__count == 0) {
diff --git a/libgo/runtime/mheap.c b/libgo/runtime/mheap.c
index 04dc971..04a5b98 100644
--- a/libgo/runtime/mheap.c
+++ b/libgo/runtime/mheap.c
@@ -878,7 +878,7 @@ runtime_MHeap_SplitSpan(MHeap *h, MSpan *s)
 
 	// remove the span from whatever list it is in now
 	if(s->sizeclass > 0) {
-		// must be in h->central[x].empty
+		// must be in h->central[x].mempty
 		c = &h->central[s->sizeclass];
 		runtime_lock(c);
 		runtime_MSpanList_Remove(s);
@@ -937,7 +937,7 @@ runtime_MHeap_SplitSpan(MHeap *h, MSpan *s)
 		c = &h->central[s->sizeclass];
 		runtime_lock(c);
 		// swept spans are at the end of the list
-		runtime_MSpanList_InsertBack(&c->empty, s);
+		runtime_MSpanList_InsertBack(&c->mempty, s);
 		runtime_unlock(c);
 	} else {
 		// Swept spans are at the end of lists.
diff --git a/libgo/runtime/panic.c b/libgo/runtime/panic.c
index 3fb3bde..d493b54 100644
--- a/libgo/runtime/panic.c
+++ b/libgo/runtime/panic.c
@@ -194,6 +194,22 @@ runtime_throw(const char *s)
 	runtime_exit(1);	// even more not reached
 }
 
+void throw(String) __asm__ (GOSYM_PREFIX "runtime.throw");
+void
+throw(String s)
+{
+	M *mp;
+
+	mp = runtime_m();
+	if(mp->throwing == 0)
+		mp->throwing = 1;
+	runtime_startpanic();
+	runtime_printf("fatal error: %S\n", s);
+	runtime_dopanic(0);
+	*(int32*)0 = 0;	// not reached
+	runtime_exit(1);	// even more not reached
+}
+
 void
 runtime_panicstring(const char *s)
 {
diff --git a/libgo/runtime/proc.c b/libgo/runtime/proc.c
index 20db789..32d0fb2 100644
--- a/libgo/runtime/proc.c
+++ b/libgo/runtime/proc.c
@@ -546,9 +546,9 @@ static struct __go_channel_type chan_bool_type_descriptor =
       /* __hash */
       0, /* This value doesn't matter.  */
       /* __hashfn */
-      &__go_type_hash_error_descriptor,
+      NULL,
       /* __equalfn */
-      &__go_type_equal_error_descriptor,
+      NULL,
       /* __gc */
       NULL, /* This value doesn't matter */
       /* __reflection */
@@ -2753,7 +2753,7 @@ static void
 procresize(int32 new)
 {
 	int32 i, old;
-	bool empty;
+	bool pempty;
 	G *gp;
 	P *p;
 
@@ -2781,14 +2781,14 @@ procresize(int32 new)
 	// collect all runnable goroutines in global queue preserving FIFO order
 	// FIFO order is required to ensure fairness even during frequent GCs
 	// see http://golang.org/issue/7126
-	empty = false;
-	while(!empty) {
-		empty = true;
+	pempty = false;
+	while(!pempty) {
+		pempty = true;
 		for(i = 0; i < old; i++) {
 			p = runtime_allp[i];
 			if(p->runqhead == p->runqtail)
 				continue;
-			empty = false;
+			pempty = false;
 			// pop from tail of local queue
 			p->runqtail--;
 			gp = (G*)p->runq[p->runqtail%nelem(p->runq)];
diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h
index 617766b..dc00b42 100644
--- a/libgo/runtime/runtime.h
+++ b/libgo/runtime/runtime.h
@@ -376,7 +376,7 @@ void	runtime_mprofinit(void);
 int32	runtime_mcount(void);
 int32	runtime_gcount(void);
 void	runtime_mcall(void(*)(G*));
-uint32	runtime_fastrand1(void);
+uint32	runtime_fastrand1(void) __asm__ (GOSYM_PREFIX "runtime.fastrand1");
 int32	runtime_timediv(int64, int32, int32*);
 int32	runtime_round2(int32 x); // round x up to a power of 2.