runtime: Copy runtime_panicstring from master library.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@181830 138bc75d-0d04-0410-961f-82ee72b054a4

31 files changed, 83 insertions, 92 deletions

diff --git a/libgo/runtime/go-append.c b/libgo/runtime/go-append.c
index b1e882cc575..3a0c7781126 100644
--- a/libgo/runtime/go-append.c
+++ b/libgo/runtime/go-append.c
@@ -32,7 +32,7 @@ __go_append (struct __go_open_array a, void *bvalues, uintptr_t bcount,
   ucount = (uintptr_t) a.__count + bcount;
   count = (int) ucount;
   if ((uintptr_t) count != ucount || count <= a.__count)
-    __go_panic_msg ("append: slice overflow");
+    runtime_panicstring ("append: slice overflow");
 
   if (count > a.__capacity)
     {
diff --git a/libgo/runtime/go-close.c b/libgo/runtime/go-close.c
index a6df3833c26..7e32286dae0 100644
--- a/libgo/runtime/go-close.c
+++ b/libgo/runtime/go-close.c
@@ -18,7 +18,7 @@ __go_builtin_close (struct __go_channel *channel)
   int i;
 
   if (channel == NULL)
-    __go_panic_msg ("close of nil channel");
+    runtime_panicstring ("close of nil channel");
 
   i = pthread_mutex_lock (&channel->lock);
   __go_assert (i == 0);
@@ -30,7 +30,7 @@ __go_builtin_close (struct __go_channel *channel)
     {
       i = pthread_mutex_unlock (&channel->lock);
       __go_assert (i == 0);
-      __go_panic_msg ("close of closed channel");
+      runtime_panicstring ("close of closed channel");
     }
 
   channel->is_closed = 1;
diff --git a/libgo/runtime/go-eface-compare.c b/libgo/runtime/go-eface-compare.c
index 673440542f3..d88d50569c2 100644
--- a/libgo/runtime/go-eface-compare.c
+++ b/libgo/runtime/go-eface-compare.c
@@ -4,7 +4,7 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-panic.h"
+#include "runtime.h"
 #include "interface.h"
 
 /* Compare two interface values.  Return 0 for equal, not zero for not
@@ -20,7 +20,7 @@ __go_empty_interface_compare (struct __go_empty_interface left,
 
   if (((uintptr_t) left_descriptor & reflectFlags) != 0
       || ((uintptr_t) right.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   if (left_descriptor == NULL && right.__type_descriptor == NULL)
     return 0;
diff --git a/libgo/runtime/go-eface-val-compare.c b/libgo/runtime/go-eface-val-compare.c
index d754cc5f36e..fed3fdb4432 100644
--- a/libgo/runtime/go-eface-val-compare.c
+++ b/libgo/runtime/go-eface-val-compare.c
@@ -4,7 +4,7 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-panic.h"
+#include "runtime.h"
 #include "go-type.h"
 #include "interface.h"
 
@@ -21,7 +21,7 @@ __go_empty_interface_value_compare (
 
   left_descriptor = left.__type_descriptor;
   if (((uintptr_t) left_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
   if (left_descriptor == NULL)
     return 1;
   if (!__go_type_descriptors_equal (left_descriptor, right_descriptor))
diff --git a/libgo/runtime/go-interface-eface-compare.c b/libgo/runtime/go-interface-eface-compare.c
index ff69a2749d4..db03b914c84 100644
--- a/libgo/runtime/go-interface-eface-compare.c
+++ b/libgo/runtime/go-interface-eface-compare.c
@@ -4,7 +4,7 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-panic.h"
+#include "runtime.h"
 #include "interface.h"
 
 /* Compare a non-empty interface value with an empty interface value.
@@ -18,7 +18,7 @@ __go_interface_empty_compare (struct __go_interface left,
   const struct __go_type_descriptor *left_descriptor;
 
   if (((uintptr_t) right.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
   if (left.__methods == NULL && right.__type_descriptor == NULL)
     return 0;
   if (left.__methods == NULL || right.__type_descriptor == NULL)
diff --git a/libgo/runtime/go-make-slice.c b/libgo/runtime/go-make-slice.c
index a818a7f76d9..765e7c021b7 100644
--- a/libgo/runtime/go-make-slice.c
+++ b/libgo/runtime/go-make-slice.c
@@ -31,14 +31,14 @@ __go_make_slice2 (const struct __go_type_descriptor *td, uintptr_t len,
 
   ilen = (int) len;
   if (ilen < 0 || (uintptr_t) ilen != len)
-    __go_panic_msg ("makeslice: len out of range");
+    runtime_panicstring ("makeslice: len out of range");
 
   icap = (int) cap;
   if (cap < len
       || (uintptr_t) icap != cap
       || (std->__element_type->__size > 0
 	  && cap > (uintptr_t) -1U / std->__element_type->__size))
-    __go_panic_msg ("makeslice: cap out of range");
+    runtime_panicstring ("makeslice: cap out of range");
 
   ret.__count = ilen;
   ret.__capacity = icap;
diff --git a/libgo/runtime/go-map-delete.c b/libgo/runtime/go-map-delete.c
index a8f928f0c9a..cb10d8dcdc0 100644
--- a/libgo/runtime/go-map-delete.c
+++ b/libgo/runtime/go-map-delete.c
@@ -7,9 +7,9 @@
 #include <stddef.h>
 #include <stdlib.h>
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
-#include "go-panic.h"
 #include "map.h"
 
 /* Delete the entry matching KEY from MAP.  */
@@ -27,7 +27,7 @@ __go_map_delete (struct __go_map *map, const void *key)
   void **pentry;
 
   if (map == NULL)
-    __go_panic_msg ("deletion of entry in nil map");
+    runtime_panicstring ("deletion of entry in nil map");
 
   descriptor = map->__descriptor;
 
diff --git a/libgo/runtime/go-map-index.c b/libgo/runtime/go-map-index.c
index 92a806868bc..ffb532bee88 100644
--- a/libgo/runtime/go-map-index.c
+++ b/libgo/runtime/go-map-index.c
@@ -7,9 +7,9 @@
 #include <stddef.h>
 #include <stdlib.h>
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
-#include "go-panic.h"
 #include "map.h"
 
 /* Rehash MAP to a larger size.  */
@@ -89,7 +89,7 @@ __go_map_index (struct __go_map *map, const void *key, _Bool insert)
   if (map == NULL)
     {
       if (insert)
-	__go_panic_msg ("assignment to entry in nil map");
+	runtime_panicstring ("assignment to entry in nil map");
       return NULL;
     }
 
diff --git a/libgo/runtime/go-new-channel.c b/libgo/runtime/go-new-channel.c
index 2f5bf2ea20a..fe13c5efab6 100644
--- a/libgo/runtime/go-new-channel.c
+++ b/libgo/runtime/go-new-channel.c
@@ -7,9 +7,9 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
-#include "go-panic.h"
 #include "channel.h"
 
 struct __go_channel*
@@ -34,7 +34,7 @@ __go_new_channel (const struct __go_type_descriptor *channel_type,
   if (ientries < 0
       || (uintptr_t) ientries != entries
       || (element_size > 0 && entries > (uintptr_t) -1 / element_size))
-    __go_panic_msg ("chan size out of range");
+    runtime_panicstring ("chan size out of range");
 
   alloc_size = (element_size + sizeof (uint64_t) - 1) / sizeof (uint64_t);
 
diff --git a/libgo/runtime/go-new-map.c b/libgo/runtime/go-new-map.c
index 05ac8a1a40c..288e1883f9d 100644
--- a/libgo/runtime/go-new-map.c
+++ b/libgo/runtime/go-new-map.c
@@ -4,8 +4,8 @@
    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 "go-panic.h"
 #include "map.h"
 
 /* List of prime numbers, copied from libstdc++/src/hashtable.c.  */
@@ -111,7 +111,7 @@ __go_new_map (const struct __go_map_descriptor *descriptor, uintptr_t entries)
 
   ientries = (int) entries;
   if (ientries < 0 || (uintptr_t) ientries != entries)
-    __go_panic_msg ("map size out of range");
+    runtime_panicstring ("map size out of range");
 
   if (entries == 0)
     entries = 5;
diff --git a/libgo/runtime/go-panic.c b/libgo/runtime/go-panic.c
index 23df57930b7..2e4a7883c18 100644
--- a/libgo/runtime/go-panic.c
+++ b/libgo/runtime/go-panic.c
@@ -105,22 +105,3 @@ __go_panic (struct __go_empty_interface arg)
   __printpanics (g->panic);
   runtime_dopanic (0);
 }
-
-/* This is used by the runtime library.  */
-
-void
-__go_panic_msg (const char* msg)
-{
-  size_t len;
-  unsigned char *sdata;
-  struct __go_string s;
-  struct __go_empty_interface arg;
-
-  len = __builtin_strlen (msg);
-  sdata = runtime_mallocgc (len, FlagNoPointers, 0, 0);
-  __builtin_memcpy (sdata, msg, len);
-  s.__data = sdata;
-  s.__length = len;
-  newErrorString(s, &arg);
-  __go_panic (arg);
-}
diff --git a/libgo/runtime/go-panic.h b/libgo/runtime/go-panic.h
index bd3e238aef4..41996e43b5f 100644
--- a/libgo/runtime/go-panic.h
+++ b/libgo/runtime/go-panic.h
@@ -34,9 +34,6 @@ struct __go_panic_stack
 extern void __go_panic (struct __go_empty_interface)
   __attribute__ ((noreturn));
 
-extern void __go_panic_msg (const char* msg)
-  __attribute__ ((noreturn));
-
 extern void __go_print_string (struct __go_string);
 
 extern struct __go_empty_interface __go_recover (void);
@@ -55,7 +52,8 @@ extern void newTypeAssertionError(const struct __go_type_descriptor *pt1,
 				  struct __go_empty_interface *ret)
   __asm__ ("libgo_runtime.runtime.NewTypeAssertionError");
 
-extern void newErrorString(struct __go_string, struct __go_empty_interface *)
+extern void runtime_newErrorString(struct __go_string,
+				   struct __go_empty_interface *)
   __asm__ ("libgo_runtime.runtime.NewErrorString");
 
 extern void printany(struct __go_empty_interface)
diff --git a/libgo/runtime/go-reflect-map.c b/libgo/runtime/go-reflect-map.c
index eb0590602e0..c06aef17eed 100644
--- a/libgo/runtime/go-reflect-map.c
+++ b/libgo/runtime/go-reflect-map.c
@@ -7,9 +7,9 @@
 #include <stdlib.h>
 #include <stdint.h>
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
-#include "go-panic.h"
 #include "go-type.h"
 #include "map.h"
 
@@ -90,7 +90,7 @@ mapassign (struct __go_map_type *mt, uintptr_t m, uintptr_t key_i,
   __go_assert (mt->__common.__code == GO_MAP);
 
   if (map == NULL)
-    __go_panic_msg ("assignment to entry in nil map");
+    runtime_panicstring ("assignment to entry in nil map");
 
   key_descriptor = mt->__key_type;
   if (__go_is_pointer_type (key_descriptor))
diff --git a/libgo/runtime/go-reflect.c b/libgo/runtime/go-reflect.c
index af7d5e8968f..d14a5805549 100644
--- a/libgo/runtime/go-reflect.c
+++ b/libgo/runtime/go-reflect.c
@@ -7,9 +7,9 @@
 #include <stdlib.h>
 #include <stdint.h>
 
+#include "runtime.h"
 #include "interface.h"
 #include "go-alloc.h"
-#include "go-panic.h"
 #include "go-string.h"
 #include "go-type.h"
 
@@ -122,7 +122,7 @@ Reflect (struct __go_empty_interface e)
   struct reflect_ret ret;
 
   if (((uintptr_t) e.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   if (e.__type_descriptor == NULL)
     {
@@ -170,7 +170,7 @@ Typeof (const struct __go_empty_interface e)
   struct __go_empty_interface ret;
 
   if (((uintptr_t) e.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   if (e.__type_descriptor == NULL)
     {
diff --git a/libgo/runtime/go-runtime-error.c b/libgo/runtime/go-runtime-error.c
index ceba2d673a9..f732e7f017f 100644
--- a/libgo/runtime/go-runtime-error.c
+++ b/libgo/runtime/go-runtime-error.c
@@ -4,7 +4,7 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-panic.h"
+#include "runtime.h"
 
 /* The compiler generates calls to this function.  This enum values
    are known to the compiler and used by compiled code.  Any change
@@ -59,26 +59,26 @@ __go_runtime_error (int i)
     case SLICE_INDEX_OUT_OF_BOUNDS:
     case ARRAY_INDEX_OUT_OF_BOUNDS:
     case STRING_INDEX_OUT_OF_BOUNDS:
-      __go_panic_msg ("index out of range");
+      runtime_panicstring ("index out of range");
 
     case SLICE_SLICE_OUT_OF_BOUNDS:
     case ARRAY_SLICE_OUT_OF_BOUNDS:
     case STRING_SLICE_OUT_OF_BOUNDS:
-      __go_panic_msg ("slice bounds out of range");
+      runtime_panicstring ("slice bounds out of range");
 
     case NIL_DEREFERENCE:
-      __go_panic_msg ("nil pointer dereference");
+      runtime_panicstring ("nil pointer dereference");
 
     case MAKE_SLICE_OUT_OF_BOUNDS:
-      __go_panic_msg ("make slice len or cap out of range");
+      runtime_panicstring ("make slice len or cap out of range");
 
     case MAKE_MAP_OUT_OF_BOUNDS:
-      __go_panic_msg ("make map len out of range");
+      runtime_panicstring ("make map len out of range");
 
     case MAKE_CHAN_OUT_OF_BOUNDS:
-      __go_panic_msg ("make chan len out of range");
+      runtime_panicstring ("make chan len out of range");
 
     default:
-      __go_panic_msg ("unknown runtime error");
+      runtime_panicstring ("unknown runtime error");
     }
 }
diff --git a/libgo/runtime/go-send-nb-small.c b/libgo/runtime/go-send-nb-small.c
index f3336099bf7..c77ee9183e2 100644
--- a/libgo/runtime/go-send-nb-small.c
+++ b/libgo/runtime/go-send-nb-small.c
@@ -31,7 +31,7 @@ __go_send_nonblocking_acquire (struct __go_channel *channel)
     {
       i = pthread_mutex_unlock (&channel->lock);
       __go_assert (i == 0);
-      __go_panic_msg ("send on closed channel");
+      runtime_panicstring ("send on closed channel");
     }
 
   if (channel->num_entries > 0)
diff --git a/libgo/runtime/go-send-small.c b/libgo/runtime/go-send-small.c
index 89a7032756d..06bcb41b9ad 100644
--- a/libgo/runtime/go-send-small.c
+++ b/libgo/runtime/go-send-small.c
@@ -31,7 +31,7 @@ __go_send_acquire (struct __go_channel *channel, _Bool for_select)
 	    channel->selected_for_send = 0;
 	  i = pthread_mutex_unlock (&channel->lock);
 	  __go_assert (i == 0);
-	  __go_panic_msg ("send on closed channel");
+	  runtime_panicstring ("send on closed channel");
 	}
 
       /* If somebody else has the channel locked for sending, we have
diff --git a/libgo/runtime/go-signal.c b/libgo/runtime/go-signal.c
index 468235ddf4e..958b421c871 100644
--- a/libgo/runtime/go-signal.c
+++ b/libgo/runtime/go-signal.c
@@ -178,7 +178,7 @@ sighandler (int sig)
       i = sigprocmask (SIG_UNBLOCK, &clear, NULL);
       __go_assert (i == 0);
 
-      __go_panic_msg (msg);
+      runtime_panicstring (msg);
     }
 
   for (i = 0; signals[i].sig != -1; ++i)
diff --git a/libgo/runtime/go-strslice.c b/libgo/runtime/go-strslice.c
index 40ccac617a1..8d916c46084 100644
--- a/libgo/runtime/go-strslice.c
+++ b/libgo/runtime/go-strslice.c
@@ -20,7 +20,7 @@ __go_string_slice (struct __go_string s, int start, int end)
   if (end == -1)
     end = len;
   if (start > len || end < start || end > len)
-    __go_panic_msg ("string index out of bounds");
+    runtime_panicstring ("string index out of bounds");
   ret.__data = s.__data + start;
   ret.__length = end - start;
   return ret;
diff --git a/libgo/runtime/go-type-eface.c b/libgo/runtime/go-type-eface.c
index cea9c240a66..5bf932fc8ba 100644
--- a/libgo/runtime/go-type-eface.c
+++ b/libgo/runtime/go-type-eface.c
@@ -4,8 +4,8 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
+#include "runtime.h"
 #include "interface.h"
-#include "go-panic.h"
 #include "go-type.h"
 
 /* A hash function for an empty interface.  */
@@ -46,7 +46,7 @@ __go_type_equal_empty_interface (const void *vv1, const void *vv2,
   v2_descriptor = v2->__type_descriptor;
   if (((uintptr_t) v1_descriptor & reflectFlags) != 0
       || ((uintptr_t) v2_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
   if (v1_descriptor == NULL || v2_descriptor == NULL)
     return v1_descriptor == v2_descriptor;
   if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
diff --git a/libgo/runtime/go-type-error.c b/libgo/runtime/go-type-error.c
index 865850c9ca0..ba3146e3dda 100644
--- a/libgo/runtime/go-type-error.c
+++ b/libgo/runtime/go-type-error.c
@@ -4,8 +4,8 @@
    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"
-#include "go-panic.h"
 
 /* A hash function used for a type which does not support hash
    functions.  */
@@ -14,7 +14,7 @@ size_t
 __go_type_hash_error (const void *val __attribute__ ((unused)),
 		      size_t key_size __attribute__ ((unused)))
 {
-  __go_panic_msg ("hash of unhashable type");
+  runtime_panicstring ("hash of unhashable type");
 }
 
 /* An equality function for an interface.  */
@@ -24,5 +24,5 @@ __go_type_equal_error (const void *v1 __attribute__ ((unused)),
 		       const void *v2 __attribute__ ((unused)),
 		       size_t key_size __attribute__ ((unused)))
 {
-  __go_panic_msg ("comparing uncomparable types");
+  runtime_panicstring ("comparing uncomparable types");
 }
diff --git a/libgo/runtime/go-unreflect.c b/libgo/runtime/go-unreflect.c
index c4da5fdcf05..6f1ea732fa3 100644
--- a/libgo/runtime/go-unreflect.c
+++ b/libgo/runtime/go-unreflect.c
@@ -4,8 +4,8 @@
    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 "go-panic.h"
 #include "go-type.h"
 #include "interface.h"
 
@@ -21,7 +21,7 @@ Unreflect (struct __go_empty_interface type, void *object)
   struct __go_empty_interface ret;
 
   if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   /* FIXME: We should check __type_descriptor to verify that this is
      really a type descriptor.  */
diff --git a/libgo/runtime/go-unsafe-new.c b/libgo/runtime/go-unsafe-new.c
index b0a65c42263..c60e05b3bda 100644
--- a/libgo/runtime/go-unsafe-new.c
+++ b/libgo/runtime/go-unsafe-new.c
@@ -4,8 +4,8 @@
    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 "go-panic.h"
 #include "go-type.h"
 #include "interface.h"
 
@@ -22,7 +22,7 @@ New (struct __go_empty_interface type)
   const struct __go_type_descriptor *descriptor;
 
   if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   /* FIXME: We should check __type_descriptor to verify that this is
      really a type descriptor.  */
diff --git a/libgo/runtime/go-unsafe-newarray.c b/libgo/runtime/go-unsafe-newarray.c
index 5fd81ce2733..470ed2d0c72 100644
--- a/libgo/runtime/go-unsafe-newarray.c
+++ b/libgo/runtime/go-unsafe-newarray.c
@@ -4,8 +4,8 @@
    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 "go-panic.h"
 #include "go-type.h"
 #include "interface.h"
 
@@ -23,7 +23,7 @@ NewArray (struct __go_empty_interface type, int n)
   const struct __go_type_descriptor *descriptor;
 
   if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
-    __go_panic_msg ("invalid interface value");
+    runtime_panicstring ("invalid interface value");
 
   /* FIXME: We should check __type_descriptor to verify that this is
      really a type descriptor.  */
diff --git a/libgo/runtime/iface.goc b/libgo/runtime/iface.goc
index 05e37736b88..7c74e80ac3a 100644
--- a/libgo/runtime/iface.goc
+++ b/libgo/runtime/iface.goc
@@ -3,12 +3,10 @@
 // license that can be found in the LICENSE file.
 
 package runtime
-#include "go-panic.h"
+#include "runtime.h"
 #include "go-type.h"
 #include "interface.h"
-#define nil NULL
 
-typedef _Bool bool;
 typedef struct __go_type_descriptor descriptor;
 typedef const struct __go_type_descriptor const_descriptor;
 typedef struct __go_interface interface;
@@ -35,7 +33,7 @@ func ifacetype(i interface) (d *const_descriptor) {
 // Convert an empty interface to an empty interface.
 func ifaceE2E2(e empty_interface) (ret empty_interface, ok bool) {
 	if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
-		__go_panic_msg("invalid interface value");
+		runtime_panicstring("invalid interface value");
 	ret = e;
 	ok = ret.__type_descriptor != nil;
 }
@@ -56,7 +54,7 @@ func ifaceI2E2(i interface) (ret empty_interface, ok bool) {
 // Convert an empty interface to a non-empty interface.
 func ifaceE2I2(inter *descriptor, e empty_interface) (ret interface, ok bool) {
 	if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
-		__go_panic_msg("invalid interface value");
+		runtime_panicstring("invalid interface value");
 	if (e.__type_descriptor == nil) {
 		ret.__methods = nil;
 		ret.__object = nil;
@@ -87,7 +85,7 @@ func ifaceI2I2(inter *descriptor, i interface) (ret interface, ok bool) {
 // Convert an empty interface to a pointer type.
 func ifaceE2T2P(inter *descriptor, e empty_interface) (ret *void, ok bool) {
 	if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
-		__go_panic_msg("invalid interface value");
+		runtime_panicstring("invalid interface value");
 	if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
 		ret = nil;
 		ok = 0;
@@ -112,7 +110,7 @@ func ifaceI2T2P(inter *descriptor, i interface) (ret *void, ok bool) {
 // Convert an empty interface to a non-pointer type.
 func ifaceE2T2(inter *descriptor, e empty_interface, ret *void) (ok bool) {
 	if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
-		__go_panic_msg("invalid interface value");
+		runtime_panicstring("invalid interface value");
 	if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
 		__builtin_memset(ret, 0, inter->__size);
 		ok = 0;
diff --git a/libgo/runtime/malloc.goc b/libgo/runtime/malloc.goc
index 73446bf8347..f5321856eac 100644
--- a/libgo/runtime/malloc.goc
+++ b/libgo/runtime/malloc.goc
@@ -17,9 +17,6 @@ package runtime
 #include "go-string.h"
 #include "interface.h"
 #include "go-type.h"
-typedef struct __go_empty_interface Eface;
-typedef struct __go_type_descriptor Type;
-typedef struct __go_func_type FuncType;
 
 MHeap runtime_mheap;
 extern MStats mstats;	// defined in extern.go
diff --git a/libgo/runtime/map.goc b/libgo/runtime/map.goc
index da67d49287d..e4b8456dc36 100644
--- a/libgo/runtime/map.goc
+++ b/libgo/runtime/map.goc
@@ -3,13 +3,9 @@
 // license that can be found in the LICENSE file.
 
 package runtime
+#include "runtime.h"
 #include "map.h"
-#define nil NULL
 
-typedef unsigned char byte;
-typedef _Bool bool;
-
-typedef struct __go_map_type MapType;
 typedef struct __go_map Hmap;
 typedef struct __go_hash_iter hiter;
 
diff --git a/libgo/runtime/reflect.goc b/libgo/runtime/reflect.goc
index 4666dd5389c..d3cde7c0e5b 100644
--- a/libgo/runtime/reflect.goc
+++ b/libgo/runtime/reflect.goc
@@ -8,10 +8,6 @@ package reflect
 #include "runtime.h"
 #include "go-panic.h"
 
-typedef struct __go_type_descriptor Type;
-typedef struct __go_interface Iface;
-typedef struct __go_empty_interface Eface;
-
 func ifaceE2I(inter *Type, e Eface, ret *Iface) {
 	const Type *t;
 	Eface err;
diff --git a/libgo/runtime/runtime.c b/libgo/runtime/runtime.c
index de4c982620f..8e4433b0d6c 100644
--- a/libgo/runtime/runtime.c
+++ b/libgo/runtime/runtime.c
@@ -70,6 +70,19 @@ runtime_throw(const char *s)
 	runtime_exit(1);	// even more not reached
 }
 
+void
+runtime_panicstring(const char *s)
+{
+	Eface err;
+	
+	if(runtime_m()->gcing) {
+		runtime_printf("panic: %s\n", s);
+		runtime_throw("panic during gc");
+	}
+	runtime_newErrorString(runtime_gostringnocopy((const byte*)s), &err);
+	runtime_panic(err);
+}
+
 static int32	argc;
 static byte**	argv;
 
@@ -95,7 +108,7 @@ runtime_goargs(void)
 
 	s = runtime_malloc(argc*sizeof s[0]);
 	for(i=0; i<argc; i++)
-		s[i] = runtime_gostringnocopy((byte*)argv[i]);
+		s[i] = runtime_gostringnocopy((const byte*)argv[i]);
 	os_Args.__values = (void*)s;
 	os_Args.__count = argc;
 	os_Args.__capacity = argc;
diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h
index 818465cb897..9455ae88c5a 100644
--- a/libgo/runtime/runtime.h
+++ b/libgo/runtime/runtime.h
@@ -57,10 +57,16 @@ typedef	struct	MCache		MCache;
 typedef struct	FixAlloc	FixAlloc;
 
 typedef	struct	__go_defer_stack	Defer;
+typedef struct	__go_interface		Iface;
+typedef	struct	__go_empty_interface	Eface;
+typedef	struct	__go_type_descriptor	Type;
 typedef	struct	__go_panic_stack	Panic;
 typedef	struct	__go_open_array		Slice;
 typedef	struct	__go_string		String;
 
+typedef struct	__go_func_type		FuncType;
+typedef struct	__go_map_type		MapType;
+
 /*
  * per-cpu declaration.
  */
@@ -211,10 +217,11 @@ void	runtime_osinit();
 void	runtime_goargs(void);
 void	runtime_goenvs(void);
 void	runtime_throw(const char*);
+void	runtime_panicstring(const char*) __attribute__ ((noreturn));
 void*	runtime_mal(uintptr);
 void	runtime_schedinit(void);
 void	runtime_initsig(int32);
-String	runtime_gostringnocopy(byte*);
+String	runtime_gostringnocopy(const byte*);
 void*	runtime_mstart(void*);
 G*	runtime_malg(int32, byte**, size_t*);
 void	runtime_minit(void);
@@ -274,8 +281,13 @@ void	runtime_semawakeup(M*);
 void	runtime_futexsleep(uint32*, uint32, int64);
 void	runtime_futexwakeup(uint32*, uint32);
 
+/*
+ * runtime go-called
+ */
+void	runtime_panic(Eface);
 
 /* Functions.  */
+#define runtime_panic __go_panic
 #define runtime_printf printf
 #define runtime_malloc(s) __go_alloc(s)
 #define runtime_free(p) __go_free(p)
diff --git a/libgo/runtime/string.goc b/libgo/runtime/string.goc
index aa75628730e..fbbe393bbef 100644
--- a/libgo/runtime/string.goc
+++ b/libgo/runtime/string.goc
@@ -15,7 +15,7 @@ runtime_findnull(const byte *s)
 }
 
 String
-runtime_gostringnocopy(byte *str)
+runtime_gostringnocopy(const byte *str)
 {
 	String s;