compiler, runtime: More steps toward separating int and intgo.

From-SVN: r193059

56 files changed, 252 insertions, 259 deletions

diff --git a/libgo/go/bytes/indexbyte.c b/libgo/go/bytes/indexbyte.c
index 8986d10..9c72e61 100644
--- a/libgo/go/bytes/indexbyte.c
+++ b/libgo/go/bytes/indexbyte.c
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include "runtime.h"
 #include "array.h"
 
 /* This is in C so that the compiler can optimize it appropriately.
diff --git a/libgo/go/syscall/signame.c b/libgo/go/syscall/signame.c
index 6342288..5ff0b09 100644
--- a/libgo/go/syscall/signame.c
+++ b/libgo/go/syscall/signame.c
@@ -6,7 +6,6 @@
 
 #include <string.h>
 
-#include "config.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
@@ -19,7 +18,7 @@ Signame (int sig)
   const char* s = NULL;
   char buf[100];
   size_t len;
-  unsigned char *data;
+  byte *data;
   String ret;
 
 #if defined(HAVE_STRSIGNAL)
@@ -34,7 +33,7 @@ Signame (int sig)
   len = __builtin_strlen (s);
   data = runtime_mallocgc (len, FlagNoPointers, 0, 0);
   __builtin_memcpy (data, s, len);
-  ret.__data = data;
-  ret.__length = len;
+  ret.str = data;
+  ret.len = len;
   return ret;
 }
diff --git a/libgo/runtime/array.h b/libgo/runtime/array.h
index f6d0261..14a9bb4 100644
--- a/libgo/runtime/array.h
+++ b/libgo/runtime/array.h
@@ -19,10 +19,10 @@ struct __go_open_array
      enough to hold the size of any allocated object.  Using "int"
      saves 8 bytes per slice header on a 64-bit system with 32-bit
      ints.  */
-  int __count;
+  intgo __count;
   /* The capacity of the array--the number of elements that can fit in
      the __VALUES field.  */
-  int __capacity;
+  intgo __capacity;
 };
 
 #endif /* !defined(LIBGO_ARRAY_H) */
diff --git a/libgo/runtime/go-append.c b/libgo/runtime/go-append.c
index dac4c90..12fe876 100644
--- a/libgo/runtime/go-append.c
+++ b/libgo/runtime/go-append.c
@@ -4,10 +4,10 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-type.h"
+#include "runtime.h"
 #include "go-panic.h"
+#include "go-type.h"
 #include "array.h"
-#include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
diff --git a/libgo/runtime/go-assert-interface.c b/libgo/runtime/go-assert-interface.c
index 94bdaee..2510f9ae 100644
--- a/libgo/runtime/go-assert-interface.c
+++ b/libgo/runtime/go-assert-interface.c
@@ -4,11 +4,12 @@
    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-assert.h"
 #include "go-panic.h"
+#include "go-type.h"
 #include "interface.h"
-#include "runtime.h"
 
 /* This is called by the compiler to implement a type assertion from
    one interface type to another.  This returns the value that should
diff --git a/libgo/runtime/go-byte-array-to-string.c b/libgo/runtime/go-byte-array-to-string.c
index cfe1906..0cd63c7 100644
--- a/libgo/runtime/go-byte-array-to-string.c
+++ b/libgo/runtime/go-byte-array-to-string.c
@@ -4,22 +4,21 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
-struct __go_string
-__go_byte_array_to_string (const void* p, int len)
+String
+__go_byte_array_to_string (const void* p, intgo len)
 {
   const unsigned char *bytes;
   unsigned char *retdata;
-  struct __go_string ret;
+  String ret;
 
   bytes = (const unsigned char *) p;
-  retdata = runtime_mallocgc (len, FlagNoPointers, 1, 0);
+  retdata = runtime_mallocgc ((uintptr) len, FlagNoPointers, 1, 0);
   __builtin_memcpy (retdata, bytes, len);
-  ret.__data = retdata;
-  ret.__length = len;
+  ret.str = retdata;
+  ret.len = len;
   return ret;
 }
diff --git a/libgo/runtime/go-caller.c b/libgo/runtime/go-caller.c
index 8dcf9e4..d73a408 100644
--- a/libgo/runtime/go-caller.c
+++ b/libgo/runtime/go-caller.c
@@ -11,7 +11,6 @@
 #include "backtrace.h"
 
 #include "runtime.h"
-#include "go-string.h"
 
 /* Get the function name, file name, and line number for a PC value.
    We use the backtrace library to get this.  */
@@ -20,9 +19,9 @@
 
 struct caller
 {
-  struct __go_string fn;
-  struct __go_string file;
-  int line;
+  String fn;
+  String file;
+  intgo line;
 };
 
 /* Collect file/line information for a PC value.  If this is called
@@ -37,32 +36,32 @@ callback (void *data, uintptr_t pc __attribute__ ((unused)),
 
   if (function == NULL)
     {
-      c->fn.__data = NULL;
-      c->fn.__length = 0;
+      c->fn.str = NULL;
+      c->fn.len = 0;
     }
   else
     {
-      char *s;
+      byte *s;
 
-      c->fn.__length = __builtin_strlen (function);
-      s = runtime_malloc (c->fn.__length);
-      __builtin_memcpy (s, function, c->fn.__length);
-      c->fn.__data = (unsigned char *) s;
+      c->fn.len = __builtin_strlen (function);
+      s = runtime_malloc (c->fn.len);
+      __builtin_memcpy (s, function, c->fn.len);
+      c->fn.str = s;
     }
 
   if (filename == NULL)
     {
-      c->file.__data = NULL;
-      c->file.__length = 0;
+      c->file.str = NULL;
+      c->file.len = 0;
     }
   else
     {
-      char *s;
+      byte *s;
 
-      c->file.__length = __builtin_strlen (filename);
-      s = runtime_malloc (c->file.__length);
-      __builtin_memcpy (s, filename, c->file.__length);
-      c->file.__data = (unsigned char *) s;
+      c->file.len = __builtin_strlen (filename);
+      s = runtime_malloc (c->file.len);
+      __builtin_memcpy (s, filename, c->file.len);
+      c->file.str = s;
     }
 
   c->line = lineno;
@@ -111,8 +110,7 @@ __go_get_backtrace_state ()
 /* Return function/file/line information for PC.  */
 
 _Bool
-__go_file_line (uintptr pc, struct __go_string *fn, struct __go_string *file,
-		int *line)
+__go_file_line (uintptr pc, String *fn, String *file, intgo *line)
 {
   struct caller c;
 
@@ -122,7 +120,7 @@ __go_file_line (uintptr pc, struct __go_string *fn, struct __go_string *file,
   *fn = c.fn;
   *file = c.file;
   *line = c.line;
-  return c.file.__length > 0;
+  return c.file.len > 0;
 }
 
 /* Collect symbol information.  */
@@ -153,8 +151,8 @@ __go_symbol_value (uintptr_t pc, uintptr_t *val)
 struct caller_ret
 {
   uintptr_t pc;
-  struct __go_string file;
-  int line;
+  String file;
+  intgo line;
   _Bool ok;
 };
 
@@ -170,7 +168,7 @@ Caller (int skip)
   struct caller_ret ret;
   uintptr pc;
   int32 n;
-  struct __go_string fn;
+  String fn;
 
   runtime_memclr (&ret, sizeof ret);
   n = runtime_callers (skip + 1, &pc, 1);
@@ -188,9 +186,9 @@ Func *
 FuncForPC (uintptr_t pc)
 {
   Func *ret;
-  struct __go_string fn;
-  struct __go_string file;
-  int line;
+  String fn;
+  String file;
+  intgo line;
   uintptr_t val;
 
   if (!__go_file_line (pc, &fn, &file, &line))
@@ -212,8 +210,8 @@ FuncForPC (uintptr_t pc)
 
 struct funcline_go_return
 {
-  struct __go_string retfile;
-  int retline;
+  String retfile;
+  intgo retline;
 };
 
 struct funcline_go_return
@@ -224,7 +222,7 @@ struct funcline_go_return
 runtime_funcline_go (Func *f __attribute__((unused)), uintptr targetpc)
 {
   struct funcline_go_return ret;
-  struct __go_string fn;
+  String fn;
 
   if (!__go_file_line (targetpc, &fn, &ret.retfile,  &ret.retline))
     runtime_memclr (&ret, sizeof ret);
diff --git a/libgo/runtime/go-callers.c b/libgo/runtime/go-callers.c
index 71d69f6..1dd3e71 100644
--- a/libgo/runtime/go-callers.c
+++ b/libgo/runtime/go-callers.c
@@ -9,6 +9,7 @@
 #include "backtrace.h"
 
 #include "runtime.h"
+#include "array.h"
 
 /* Argument passed to callback function.  */
 
diff --git a/libgo/runtime/go-can-convert-interface.c b/libgo/runtime/go-can-convert-interface.c
index 83217ab..4de5580 100644
--- a/libgo/runtime/go-can-convert-interface.c
+++ b/libgo/runtime/go-can-convert-interface.c
@@ -4,7 +4,9 @@
    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 "go-string.h"
 #include "go-type.h"
 #include "interface.h"
 
diff --git a/libgo/runtime/go-cgo.c b/libgo/runtime/go-cgo.c
index 173696e..d0c89f2 100644
--- a/libgo/runtime/go-cgo.c
+++ b/libgo/runtime/go-cgo.c
@@ -8,7 +8,6 @@
 #include "go-alloc.h"
 #include "interface.h"
 #include "go-panic.h"
-#include "go-string.h"
 
 /* Go memory allocated by code not written in Go.  We keep a linked
    list of these allocations so that the garbage collector can see
@@ -135,9 +134,9 @@ extern const struct __go_type_descriptor string_type_descriptor
 void
 _cgo_panic (const char *p)
 {
-  int len;
+  intgo len;
   unsigned char *data;
-  struct __go_string *ps;
+  String *ps;
   struct __go_empty_interface e;
 
   runtime_exitsyscall ();
@@ -145,8 +144,8 @@ _cgo_panic (const char *p)
   data = alloc_saved (len);
   __builtin_memcpy (data, p, len);
   ps = alloc_saved (sizeof *ps);
-  ps->__data = data;
-  ps->__length = len;
+  ps->str = data;
+  ps->len = len;
   e.__type_descriptor = &string_type_descriptor;
   e.__object = ps;
 
diff --git a/libgo/runtime/go-check-interface.c b/libgo/runtime/go-check-interface.c
index 963559d..c29971a 100644
--- a/libgo/runtime/go-check-interface.c
+++ b/libgo/runtime/go-check-interface.c
@@ -4,9 +4,10 @@
    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-panic.h"
+#include "go-type.h"
 #include "interface.h"
-#include "runtime.h"
 
 /* Check that an interface type matches for a conversion to a
    non-interface type.  This panics if the types are bad.  The actual
diff --git a/libgo/runtime/go-construct-map.c b/libgo/runtime/go-construct-map.c
index 5e459d0..4bd79d2 100644
--- a/libgo/runtime/go-construct-map.c
+++ b/libgo/runtime/go-construct-map.c
@@ -8,6 +8,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "runtime.h"
 #include "map.h"
 
 struct __go_map *
diff --git a/libgo/runtime/go-convert-interface.c b/libgo/runtime/go-convert-interface.c
index 8ce82ea..3eee6bf4 100644
--- a/libgo/runtime/go-convert-interface.c
+++ b/libgo/runtime/go-convert-interface.c
@@ -4,11 +4,13 @@
    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-assert.h"
 #include "go-panic.h"
+#include "go-string.h"
+#include "go-type.h"
 #include "interface.h"
-#include "runtime.h"
 
 /* This is called when converting one interface type into another
    interface type.  LHS_DESCRIPTOR is the type descriptor of the
diff --git a/libgo/runtime/go-eface-compare.c b/libgo/runtime/go-eface-compare.c
index d88d505..e738efc 100644
--- a/libgo/runtime/go-eface-compare.c
+++ b/libgo/runtime/go-eface-compare.c
@@ -5,12 +5,13 @@
    license that can be found in the LICENSE file.  */
 
 #include "runtime.h"
+#include "go-type.h"
 #include "interface.h"
 
 /* Compare two interface values.  Return 0 for equal, not zero for not
    equal (return value is like strcmp).  */
 
-int
+intgo
 __go_empty_interface_compare (struct __go_empty_interface left,
 			      struct __go_empty_interface right)
 {
diff --git a/libgo/runtime/go-eface-val-compare.c b/libgo/runtime/go-eface-val-compare.c
index fed3fdb..454ea3e 100644
--- a/libgo/runtime/go-eface-val-compare.c
+++ b/libgo/runtime/go-eface-val-compare.c
@@ -11,7 +11,7 @@
 /* Compare an empty interface with a value.  Return 0 for equal, not
    zero for not equal (return value is like strcmp).  */
 
-int
+intgo
 __go_empty_interface_value_compare (
     struct __go_empty_interface left,
     const struct __go_type_descriptor *right_descriptor,
diff --git a/libgo/runtime/go-getgoroot.c b/libgo/runtime/go-getgoroot.c
index 1db4afe..3cb447e 100644
--- a/libgo/runtime/go-getgoroot.c
+++ b/libgo/runtime/go-getgoroot.c
@@ -6,21 +6,21 @@
 
 #include <stdlib.h>
 
-#include "go-string.h"
+#include "runtime.h"
 
-struct __go_string getgoroot (void) asm ("runtime.getgoroot");
+String getgoroot (void) asm ("runtime.getgoroot");
 
-struct __go_string
+String
 getgoroot ()
 {
   const char *p;
-  struct __go_string ret;
+  String ret;
 
   p = getenv ("GOROOT");
-  ret.__data = (const unsigned char *) p;
-  if (ret.__data == NULL)
-    ret.__length = 0;
+  ret.str = (const byte *) p;
+  if (ret.str == NULL)
+    ret.len = 0;
   else
-    ret.__length = __builtin_strlen (p);
+    ret.len = __builtin_strlen (p);
   return ret;
 }
diff --git a/libgo/runtime/go-int-array-to-string.c b/libgo/runtime/go-int-array-to-string.c
index 1a37879..6cae2fd 100644
--- a/libgo/runtime/go-int-array-to-string.c
+++ b/libgo/runtime/go-int-array-to-string.c
@@ -5,31 +5,30 @@
    license that can be found in the LICENSE file.  */
 
 #include "go-assert.h"
-#include "go-string.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
-struct __go_string
-__go_int_array_to_string (const void* p, int len)
+String
+__go_int_array_to_string (const void* p, intgo len)
 {
-  const int *ints;
-  int slen;
-  int i;
+  const int32 *ints;
+  intgo slen;
+  intgo i;
   unsigned char *retdata;
-  struct __go_string ret;
+  String ret;
   unsigned char *s;
 
-  ints = (const int *) p;
+  ints = (const int32 *) p;
 
   slen = 0;
   for (i = 0; i < len; ++i)
     {
-      int v;
+      int32 v;
 
       v = ints[i];
 
-      if (v > 0x10ffff)
+      if (v < 0 || v > 0x10ffff)
 	v = 0xfffd;
 
       if (v <= 0x7f)
@@ -42,20 +41,20 @@ __go_int_array_to_string (const void* p, int len)
 	slen += 4;
     }
 
-  retdata = runtime_mallocgc (slen, FlagNoPointers, 1, 0);
-  ret.__data = retdata;
-  ret.__length = slen;
+  retdata = runtime_mallocgc ((uintptr) slen, FlagNoPointers, 1, 0);
+  ret.str = retdata;
+  ret.len = slen;
 
   s = retdata;
   for (i = 0; i < len; ++i)
     {
-      int v;
+      int32 v;
 
       v = ints[i];
 
       /* If V is out of range for UTF-8, substitute the replacement
 	 character.  */
-      if (v > 0x10ffff)
+      if (v < 0 || v > 0x10ffff)
 	v = 0xfffd;
 
       if (v <= 0x7f)
diff --git a/libgo/runtime/go-int-to-string.c b/libgo/runtime/go-int-to-string.c
index 17a5fcb..eb44167 100644
--- a/libgo/runtime/go-int-to-string.c
+++ b/libgo/runtime/go-int-to-string.c
@@ -4,18 +4,17 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
-struct __go_string
-__go_int_to_string (int v)
+String
+__go_int_to_string (intgo v)
 {
   char buf[4];
   int len;
   unsigned char *retdata;
-  struct __go_string ret;
+  String ret;
 
   /* A negative value is not valid UTF-8; turn it into the replacement
      character.  */
@@ -63,8 +62,8 @@ __go_int_to_string (int v)
 
   retdata = runtime_mallocgc (len, FlagNoPointers, 1, 0);
   __builtin_memcpy (retdata, buf, len);
-  ret.__data = retdata;
-  ret.__length = len;
+  ret.str = retdata;
+  ret.len = len;
 
   return ret;
 }
diff --git a/libgo/runtime/go-interface-compare.c b/libgo/runtime/go-interface-compare.c
index 11c75e8..6374bd2 100644
--- a/libgo/runtime/go-interface-compare.c
+++ b/libgo/runtime/go-interface-compare.c
@@ -4,6 +4,10 @@
    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-type.h"
 #include "interface.h"
 
 /* Compare two interface values.  Return 0 for equal, not zero for not
diff --git a/libgo/runtime/go-interface-eface-compare.c b/libgo/runtime/go-interface-eface-compare.c
index db03b91..bb81ff8 100644
--- a/libgo/runtime/go-interface-eface-compare.c
+++ b/libgo/runtime/go-interface-eface-compare.c
@@ -5,13 +5,14 @@
    license that can be found in the LICENSE file.  */
 
 #include "runtime.h"
+#include "go-type.h"
 #include "interface.h"
 
 /* Compare a non-empty interface value with an empty interface value.
    Return 0 for equal, not zero for not equal (return value is like
    strcmp).  */
 
-int
+intgo
 __go_interface_empty_compare (struct __go_interface left,
 			      struct __go_empty_interface right)
 {
diff --git a/libgo/runtime/go-interface-val-compare.c b/libgo/runtime/go-interface-val-compare.c
index 1589892..e2dae6a 100644
--- a/libgo/runtime/go-interface-val-compare.c
+++ b/libgo/runtime/go-interface-val-compare.c
@@ -4,13 +4,14 @@
    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 "interface.h"
 
 /* Compare two interface values.  Return 0 for equal, not zero for not
    equal (return value is like strcmp).  */
 
-int
+intgo
 __go_interface_value_compare (
     struct __go_interface left,
     const struct __go_type_descriptor *right_descriptor,
diff --git a/libgo/runtime/go-main.c b/libgo/runtime/go-main.c
index 7e8bb9b..97d1405 100644
--- a/libgo/runtime/go-main.c
+++ b/libgo/runtime/go-main.c
@@ -14,11 +14,9 @@
 #include <fpu_control.h>
 #endif
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "array.h"
-#include "go-string.h"
-
-#include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
diff --git a/libgo/runtime/go-make-slice.c b/libgo/runtime/go-make-slice.c
index 822c9b6..242c9bb 100644
--- a/libgo/runtime/go-make-slice.c
+++ b/libgo/runtime/go-make-slice.c
@@ -6,12 +6,12 @@
 
 #include <stdint.h>
 
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
 #include "go-panic.h"
 #include "go-type.h"
 #include "array.h"
-#include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
@@ -20,8 +20,8 @@ __go_make_slice2 (const struct __go_type_descriptor *td, uintptr_t len,
 		  uintptr_t cap)
 {
   const struct __go_slice_type* std;
-  int ilen;
-  int icap;
+  intgo ilen;
+  intgo icap;
   uintptr_t size;
   struct __go_open_array ret;
   unsigned int flag;
@@ -29,11 +29,11 @@ __go_make_slice2 (const struct __go_type_descriptor *td, uintptr_t len,
   __go_assert (td->__code == GO_SLICE);
   std = (const struct __go_slice_type *) td;
 
-  ilen = (int) len;
+  ilen = (intgo) len;
   if (ilen < 0 || (uintptr_t) ilen != len)
     runtime_panicstring ("makeslice: len out of range");
 
-  icap = (int) cap;
+  icap = (intgo) cap;
   if (cap < len
       || (uintptr_t) icap != cap
       || (std->__element_type->__size > 0
diff --git a/libgo/runtime/go-map-len.c b/libgo/runtime/go-map-len.c
index a8922b9..7da10c2 100644
--- a/libgo/runtime/go-map-len.c
+++ b/libgo/runtime/go-map-len.c
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include "runtime.h"
 #include "go-assert.h"
 #include "map.h"
 
@@ -13,11 +14,12 @@
    but I'm doing it as a function for now to make it easy to change
    the map structure.  */
 
-int
+intgo
 __go_map_len (struct __go_map *map)
 {
   if (map == NULL)
     return 0;
-  __go_assert (map->__element_count == (uintptr_t) (int) map->__element_count);
+  __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
index 54444bc..5dbb92c 100644
--- a/libgo/runtime/go-map-range.c
+++ b/libgo/runtime/go-map-range.c
@@ -4,6 +4,7 @@
    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"
 
diff --git a/libgo/runtime/go-new-map.c b/libgo/runtime/go-new-map.c
index 6446618..096856e 100644
--- a/libgo/runtime/go-new-map.c
+++ b/libgo/runtime/go-new-map.c
@@ -106,10 +106,10 @@ __go_map_next_prime (uintptr_t n)
 struct __go_map *
 __go_new_map (const struct __go_map_descriptor *descriptor, uintptr_t entries)
 {
-  int ientries;
+  intgo ientries;
   struct __go_map *ret;
 
-  ientries = (int) entries;
+  ientries = (intgo) entries;
   if (ientries < 0 || (uintptr_t) ientries != entries)
     runtime_panicstring ("map size out of range");
 
diff --git a/libgo/runtime/go-panic.c b/libgo/runtime/go-panic.c
index 05325b1..530629c 100644
--- a/libgo/runtime/go-panic.c
+++ b/libgo/runtime/go-panic.c
@@ -13,7 +13,6 @@
 #include "go-alloc.h"
 #include "go-defer.h"
 #include "go-panic.h"
-#include "go-string.h"
 #include "interface.h"
 
 /* Print the panic stack.  This is used when there is no recover.  */
diff --git a/libgo/runtime/go-panic.h b/libgo/runtime/go-panic.h
index 7641149..e7031d4 100644
--- a/libgo/runtime/go-panic.h
+++ b/libgo/runtime/go-panic.h
@@ -9,7 +9,7 @@
 
 #include "interface.h"
 
-struct __go_string;
+struct String;
 struct __go_type_descriptor;
 struct __go_defer_stack;
 
@@ -34,7 +34,7 @@ struct __go_panic_stack
 extern void __go_panic (struct __go_empty_interface)
   __attribute__ ((noreturn));
 
-extern void __go_print_string (struct __go_string);
+extern void __go_print_string (struct String);
 
 extern struct __go_empty_interface __go_recover (void);
 
diff --git a/libgo/runtime/go-print.c b/libgo/runtime/go-print.c
index 3fe879a..4c520de 100644
--- a/libgo/runtime/go-print.c
+++ b/libgo/runtime/go-print.c
@@ -11,7 +11,6 @@
 #include "runtime.h"
 #include "array.h"
 #include "go-panic.h"
-#include "go-string.h"
 #include "interface.h"
 
 /* This implements the various little functions which are called by
diff --git a/libgo/runtime/go-reflect-call.c b/libgo/runtime/go-reflect-call.c
index 688c68e..6455ff1 100644
--- a/libgo/runtime/go-reflect-call.c
+++ b/libgo/runtime/go-reflect-call.c
@@ -8,12 +8,10 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "config.h"
-
+#include "runtime.h"
 #include "go-alloc.h"
 #include "go-assert.h"
 #include "go-type.h"
-#include "runtime.h"
 
 #ifdef USE_LIBFFI
 
@@ -77,13 +75,15 @@ go_slice_to_ffi (
     const struct __go_slice_type *descriptor __attribute__ ((unused)))
 {
   ffi_type *ret;
+  ffi_type *intgo;
 
   ret = (ffi_type *) __go_alloc (sizeof (ffi_type));
   ret->type = FFI_TYPE_STRUCT;
   ret->elements = (ffi_type **) __go_alloc (4 * sizeof (ffi_type *));
   ret->elements[0] = &ffi_type_pointer;
-  ret->elements[1] = &ffi_type_sint;
-  ret->elements[2] = &ffi_type_sint;
+  intgo = sizeof (intgo) == 4 ? &ffi_type_sint32 : &ffi_type_sint64;
+  ret->elements[1] = intgo;
+  ret->elements[2] = intgo;
   ret->elements[3] = NULL;
   return ret;
 }
@@ -110,19 +110,21 @@ go_struct_to_ffi (const struct __go_struct_type *descriptor)
   return ret;
 }
 
-/* Return an ffi_type for a Go string type.  This describes the
-   __go_string struct.  */
+/* Return an ffi_type for a Go string type.  This describes the String
+   struct.  */
 
 static ffi_type *
 go_string_to_ffi (void)
 {
   ffi_type *ret;
+  ffi_type *intgo;
 
   ret = (ffi_type *) __go_alloc (sizeof (ffi_type));
   ret->type = FFI_TYPE_STRUCT;
   ret->elements = (ffi_type **) __go_alloc (3 * sizeof (ffi_type *));
   ret->elements[0] = &ffi_type_pointer;
-  ret->elements[1] = &ffi_type_sint;
+  intgo = sizeof (intgo) == 4 ? &ffi_type_sint32 : &ffi_type_sint64;
+  ret->elements[1] = intgo;
   ret->elements[2] = NULL;
   return ret;
 }
@@ -199,7 +201,7 @@ go_type_to_ffi (const struct __go_type_descriptor *descriptor)
     case GO_INT8:
       return &ffi_type_sint8;
     case GO_INT:
-      return &ffi_type_sint;
+      return sizeof (intgo) == 4 ? &ffi_type_sint32 : &ffi_type_sint64;
     case GO_UINT16:
       return &ffi_type_uint16;
     case GO_UINT32:
@@ -209,7 +211,7 @@ go_type_to_ffi (const struct __go_type_descriptor *descriptor)
     case GO_UINT8:
       return &ffi_type_uint8;
     case GO_UINT:
-      return &ffi_type_uint;
+      return sizeof (uintgo) == 4 ? &ffi_type_uint32 : &ffi_type_uint64;
     case GO_UINTPTR:
       if (sizeof (void *) == 2)
 	return &ffi_type_uint16;
diff --git a/libgo/runtime/go-rune.c b/libgo/runtime/go-rune.c
index 2caf800..ba6d86c 100644
--- a/libgo/runtime/go-rune.c
+++ b/libgo/runtime/go-rune.c
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include "runtime.h"
 #include "go-string.h"
 
 /* Get a character from the UTF-8 string STR, of length LEN.  Store
diff --git a/libgo/runtime/go-runtime-error.c b/libgo/runtime/go-runtime-error.c
index 68db8ac..f5ab4f9 100644
--- a/libgo/runtime/go-runtime-error.c
+++ b/libgo/runtime/go-runtime-error.c
@@ -55,7 +55,7 @@ enum
 extern void __go_runtime_error () __attribute__ ((noreturn));
 
 void
-__go_runtime_error (int i)
+__go_runtime_error (int32 i)
 {
   switch (i)
     {
diff --git a/libgo/runtime/go-setenv.c b/libgo/runtime/go-setenv.c
index 789ffdf..41f14d4 100644
--- a/libgo/runtime/go-setenv.c
+++ b/libgo/runtime/go-setenv.c
@@ -10,39 +10,38 @@
 #include <stdlib.h>
 
 #include "go-alloc.h"
-#include "go-string.h"
+#include "runtime.h"
 
 /* Set the C environment from Go.  This is called by syscall.Setenv.  */
 
-void setenv_c (struct __go_string, struct __go_string)
-  __asm__ ("syscall.setenv_c");
+void setenv_c (String, String) __asm__ ("syscall.setenv_c");
 
 void
-setenv_c (struct __go_string k, struct __go_string v)
+setenv_c (String k, String v)
 {
-  const unsigned char *ks;
+  const byte *ks;
   unsigned char *kn;
-  const unsigned char *vs;
+  const byte *vs;
   unsigned char *vn;
 
-  ks = k.__data;
+  ks = k.str;
   kn = NULL;
-  vs = v.__data;
+  vs = v.str;
   vn = NULL;
 
 #ifdef HAVE_SETENV
 
-  if (ks[k.__length] != 0)
+  if (ks[k.len] != 0)
     {
-      kn = __go_alloc (k.__length + 1);
-      __builtin_memcpy (kn, ks, k.__length);
+      kn = __go_alloc (k.len + 1);
+      __builtin_memcpy (kn, ks, k.len);
       ks = kn;
     }
 
-  if (vs[v.__length] != 0)
+  if (vs[v.len] != 0)
     {
-      vn = __go_alloc (v.__length + 1);
-      __builtin_memcpy (vn, vs, v.__length);
+      vn = __go_alloc (v.len + 1);
+      __builtin_memcpy (vn, vs, v.len);
       vs = vn;
     }
 
@@ -50,11 +49,11 @@ setenv_c (struct __go_string k, struct __go_string v)
 
 #else /* !defined(HAVE_SETENV) */
 
-  kn = __go_alloc (k.__length + v.__length + 2);
-  __builtin_memcpy (kn, ks, k.__length);
-  kn[k.__length] = '=';
-  __builtin_memcpy (kn + k.__length + 1, vs, v.__length);
-  kn[k.__length + v.__length + 1] = '\0';
+  kn = __go_alloc (k.len + v.len + 2);
+  __builtin_memcpy (kn, ks, k.len);
+  kn[k.len] = '=';
+  __builtin_memcpy (kn + k.len + 1, vs, v.len);
+  kn[k.len + v.len + 1] = '\0';
   putenv ((char *) kn);
 
 #endif /* !defined(HAVE_SETENV) */
diff --git a/libgo/runtime/go-strcmp.c b/libgo/runtime/go-strcmp.c
index 8e6cb18..bcc270b 100644
--- a/libgo/runtime/go-strcmp.c
+++ b/libgo/runtime/go-strcmp.c
@@ -4,23 +4,21 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
+#include "runtime.h"
 
-int
-__go_strcmp(struct __go_string s1, struct __go_string s2)
+intgo
+__go_strcmp(String s1, String s2)
 {
   int i;
 
-  i = __builtin_memcmp(s1.__data, s2.__data,
-		       (s1.__length < s2.__length
-			? s1.__length
-			: s2.__length));
+  i = __builtin_memcmp(s1.str, s2.str,
+		       (s1.len < s2.len ? s1.len : s2.len));
   if (i != 0)
     return i;
 
-  if (s1.__length < s2.__length)
+  if (s1.len < s2.len)
     return -1;
-  else if (s1.__length > s2.__length)
+  else if (s1.len > s2.len)
     return 1;
   else
     return 0;
diff --git a/libgo/runtime/go-string-to-byte-array.c b/libgo/runtime/go-string-to-byte-array.c
index 8bae54b..75fac1d 100644
--- a/libgo/runtime/go-string-to-byte-array.c
+++ b/libgo/runtime/go-string-to-byte-array.c
@@ -4,22 +4,21 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
-#include "array.h"
 #include "runtime.h"
+#include "array.h"
 #include "arch.h"
 #include "malloc.h"
 
 struct __go_open_array
-__go_string_to_byte_array (struct __go_string str)
+__go_string_to_byte_array (String str)
 {
   unsigned char *data;
   struct __go_open_array ret;
 
-  data = (unsigned char *) runtime_mallocgc (str.__length, FlagNoPointers, 1, 0);
-  __builtin_memcpy (data, str.__data, str.__length);
+  data = (unsigned char *) runtime_mallocgc (str.len, FlagNoPointers, 1, 0);
+  __builtin_memcpy (data, str.str, str.len);
   ret.__values = (void *) data;
-  ret.__count = str.__length;
-  ret.__capacity = str.__length;
+  ret.__count = str.len;
+  ret.__capacity = str.len;
   return ret;
 }
diff --git a/libgo/runtime/go-string-to-int-array.c b/libgo/runtime/go-string-to-int-array.c
index aff1468..16970bd 100644
--- a/libgo/runtime/go-string-to-int-array.c
+++ b/libgo/runtime/go-string-to-int-array.c
@@ -4,15 +4,15 @@
    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-string.h"
 #include "array.h"
-#include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
 struct __go_open_array
-__go_string_to_int_array (struct __go_string str)
+__go_string_to_int_array (String str)
 {
   size_t c;
   const unsigned char *p;
@@ -22,8 +22,8 @@ __go_string_to_int_array (struct __go_string str)
   struct __go_open_array ret;
 
   c = 0;
-  p = str.__data;
-  pend = p + str.__length;
+  p = str.str;
+  pend = p + str.len;
   while (p < pend)
     {
       int rune;
@@ -34,7 +34,7 @@ __go_string_to_int_array (struct __go_string str)
 
   data = (uint32_t *) runtime_mallocgc (c * sizeof (uint32_t), FlagNoPointers,
 					1, 0);
-  p = str.__data;
+  p = str.str;
   pd = data;
   while (p < pend)
     {
diff --git a/libgo/runtime/go-string.h b/libgo/runtime/go-string.h
index 2c8e1ac..f4c149b 100644
--- a/libgo/runtime/go-string.h
+++ b/libgo/runtime/go-string.h
@@ -9,26 +9,15 @@
 
 #include <stddef.h>
 
-/* A string is an instance of this structure.  */
-
-struct __go_string
-{
-  /* The bytes.  */
-  const unsigned char *__data;
-  /* The length.  */
-  int __length;
-};
-
 static inline _Bool
-__go_strings_equal (struct __go_string s1, struct __go_string s2)
+__go_strings_equal (String s1, String s2)
 {
-  return (s1.__length == s2.__length
-	  && __builtin_memcmp (s1.__data, s2.__data, s1.__length) == 0);
+  return (s1.len == s2.len
+	  && __builtin_memcmp (s1.str, s2.str, s1.len) == 0);
 }
 
 static inline _Bool
-__go_ptr_strings_equal (const struct __go_string *ps1,
-			const struct __go_string *ps2)
+__go_ptr_strings_equal (const String *ps1, const String *ps2)
 {
   if (ps1 == NULL)
     return ps2 == NULL;
diff --git a/libgo/runtime/go-strplus.c b/libgo/runtime/go-strplus.c
index bfbe341..d6e6df6 100644
--- a/libgo/runtime/go-strplus.c
+++ b/libgo/runtime/go-strplus.c
@@ -4,28 +4,27 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
-struct __go_string
-__go_string_plus (struct __go_string s1, struct __go_string s2)
+String
+__go_string_plus (String s1, String s2)
 {
   int len;
-  unsigned char *retdata;
-  struct __go_string ret;
+  byte *retdata;
+  String ret;
 
-  if (s1.__length == 0)
+  if (s1.len == 0)
     return s2;
-  else if (s2.__length == 0)
+  else if (s2.len == 0)
     return s1;
 
-  len = s1.__length + s2.__length;
+  len = s1.len + s2.len;
   retdata = runtime_mallocgc (len, FlagNoPointers, 1, 0);
-  __builtin_memcpy (retdata, s1.__data, s1.__length);
-  __builtin_memcpy (retdata + s1.__length, s2.__data, s2.__length);
-  ret.__data = retdata;
-  ret.__length = len;
+  __builtin_memcpy (retdata, s1.str, s1.len);
+  __builtin_memcpy (retdata + s1.len, s2.str, s2.len);
+  ret.str = retdata;
+  ret.len = len;
   return ret;
 }
diff --git a/libgo/runtime/go-strslice.c b/libgo/runtime/go-strslice.c
index 8d916c4..21e1bc0 100644
--- a/libgo/runtime/go-strslice.c
+++ b/libgo/runtime/go-strslice.c
@@ -4,24 +4,23 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-string.h"
 #include "go-panic.h"
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
 
-struct __go_string
-__go_string_slice (struct __go_string s, int start, int end)
+String
+__go_string_slice (String s, intgo start, intgo end)
 {
-  int len;
-  struct __go_string ret;
+  intgo len;
+  String ret;
 
-  len = s.__length;
+  len = s.len;
   if (end == -1)
     end = len;
   if (start > len || end < start || end > len)
     runtime_panicstring ("string index out of bounds");
-  ret.__data = s.__data + start;
-  ret.__length = end - start;
+  ret.str = s.str + start;
+  ret.len = end - start;
   return ret;
 }
diff --git a/libgo/runtime/go-traceback.c b/libgo/runtime/go-traceback.c
index c1571a3..4d5b61a 100644
--- a/libgo/runtime/go-traceback.c
+++ b/libgo/runtime/go-traceback.c
@@ -7,7 +7,6 @@
 #include "config.h"
 
 #include "runtime.h"
-#include "go-string.h"
 
 /* Print a stack trace for the current goroutine.  */
 
@@ -28,12 +27,12 @@ runtime_printtrace (uintptr *pcbuf, int32 c)
 
   for (i = 0; i < c; ++i)
     {
-      struct __go_string fn;
-      struct __go_string file;
+      String fn;
+      String file;
       int line;
 
       if (__go_file_line (pcbuf[i], &fn, &file, &line)
-	  && runtime_showframe (fn.__data))
+	  && runtime_showframe (fn.str))
 	{
 	  runtime_printf ("%S\n", fn);
 	  runtime_printf ("\t%S:%d\n", file, line);
diff --git a/libgo/runtime/go-type-identity.c b/libgo/runtime/go-type-identity.c
index a50a8a1..ed510f7 100644
--- a/libgo/runtime/go-type-identity.c
+++ b/libgo/runtime/go-type-identity.c
@@ -6,13 +6,9 @@
 
 #include <stddef.h>
 
-#include "config.h"
+#include "runtime.h"
 #include "go-type.h"
 
-/* The 64-bit type.  */
-
-typedef unsigned int DItype __attribute__ ((mode (DI)));
-
 /* An identity hash function for a type.  This is used for types where
    we can simply use the type value itself as a hash code.  This is
    true of, e.g., integers and pointers.  */
@@ -28,7 +24,7 @@ __go_type_hash_identity (const void *key, uintptr_t key_size)
     {
       union
       {
-	DItype v;
+	uint64 v;
 	unsigned char a[8];
       } u;
       u.v = 0;
diff --git a/libgo/runtime/go-type-interface.c b/libgo/runtime/go-type-interface.c
index bc3b37c..9aad720 100644
--- a/libgo/runtime/go-type-interface.c
+++ b/libgo/runtime/go-type-interface.c
@@ -4,6 +4,7 @@
    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-type.h"
 
diff --git a/libgo/runtime/go-type-string.c b/libgo/runtime/go-type-string.c
index 719ecb0..a96af02 100644
--- a/libgo/runtime/go-type-string.c
+++ b/libgo/runtime/go-type-string.c
@@ -4,10 +4,9 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include <stddef.h>
-
-#include "go-string.h"
+#include "runtime.h"
 #include "go-type.h"
+#include "go-string.h"
 
 /* A string hash function for a map.  */
 
@@ -16,15 +15,15 @@ __go_type_hash_string (const void *vkey,
 		       uintptr_t key_size __attribute__ ((unused)))
 {
   uintptr_t ret;
-  const struct __go_string *key;
-  int len;
-  int i;
-  const unsigned char *p;
+  const String *key;
+  intgo len;
+  intgo i;
+  const byte *p;
 
   ret = 5381;
-  key = (const struct __go_string *) vkey;
-  len = key->__length;
-  for (i = 0, p = key->__data; i < len; i++, p++)
+  key = (const String *) vkey;
+  len = key->len;
+  for (i = 0, p = key->str; i < len; i++, p++)
     ret = ret * 33 + *p;
   return ret;
 }
@@ -35,11 +34,10 @@ _Bool
 __go_type_equal_string (const void *vk1, const void *vk2,
 			uintptr_t key_size __attribute__ ((unused)))
 {
-  const struct __go_string *k1;
-  const struct __go_string *k2;
+  const String *k1;
+  const String *k2;
 
-  k1 = (const struct __go_string *) vk1;
-  k2 = (const struct __go_string *) vk2;
-  return (k1->__length == k2->__length
-	  && __builtin_memcmp (k1->__data, k2->__data, k1->__length) == 0);
+  k1 = (const String *) vk1;
+  k2 = (const String *) vk2;
+  return __go_ptr_strings_equal (k1, k2);
 }
diff --git a/libgo/runtime/go-type.h b/libgo/runtime/go-type.h
index 25f096c..2269ae6 100644
--- a/libgo/runtime/go-type.h
+++ b/libgo/runtime/go-type.h
@@ -10,9 +10,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "go-string.h"
 #include "array.h"
 
+struct String;
+
 /* Many of the types in this file must match the data structures
    generated by the compiler, and must also match the Go types which
    appear in go/runtime/type.go and go/reflect/type.go.  */
@@ -94,7 +95,7 @@ struct __go_type_descriptor
 
   /* A string describing this type.  This is only used for
      debugging.  */
-  const struct __go_string *__reflection;
+  const struct String *__reflection;
 
   /* A pointer to fields which are only used for some types.  */
   const struct __go_uncommon_type *__uncommon;
@@ -109,11 +110,11 @@ struct __go_type_descriptor
 struct __go_method
 {
   /* The name of the method.  */
-  const struct __go_string *__name;
+  const struct String *__name;
 
   /* This is NULL for an exported method, or the name of the package
      where it lives.  */
-  const struct __go_string *__pkg_path;
+  const struct String *__pkg_path;
 
   /* The type of the method, without the receiver.  This will be a
      function type.  */
@@ -134,10 +135,10 @@ struct __go_method
 struct __go_uncommon_type
 {
   /* The name of the type.  */
-  const struct __go_string *__name;
+  const struct String *__name;
 
   /* The type's package.  This is NULL for builtin types.  */
-  const struct __go_string *__pkg_path;
+  const struct String *__pkg_path;
 
   /* The type's methods.  This is an array of struct __go_method.  */
   struct __go_open_array __methods;
@@ -216,11 +217,11 @@ struct __go_func_type
 struct __go_interface_method
 {
   /* The name of the method.  */
-  const struct __go_string *__name;
+  const struct String *__name;
 
   /* This is NULL for an exported method, or the name of the package
      where it lives.  */
-  const struct __go_string *__pkg_path;
+  const struct String *__pkg_path;
 
   /* The real type of the method.  */
   struct __go_type_descriptor *__type;
@@ -269,17 +270,17 @@ struct __go_ptr_type
 struct __go_struct_field
 {
   /* The name of the field--NULL for an anonymous field.  */
-  const struct __go_string *__name;
+  const struct String *__name;
 
   /* This is NULL for an exported method, or the name of the package
      where it lives.  */
-  const struct __go_string *__pkg_path;
+  const struct String *__pkg_path;
 
   /* The type of the field.  */
   const struct __go_type_descriptor *__type;
 
   /* The field tag, or NULL.  */
-  const struct __go_string *__tag;
+  const struct String *__tag;
 
   /* The offset of the field in the struct.  */
   uintptr_t __offset;
diff --git a/libgo/runtime/go-typedesc-equal.c b/libgo/runtime/go-typedesc-equal.c
index 932519a..f8474fc 100644
--- a/libgo/runtime/go-typedesc-equal.c
+++ b/libgo/runtime/go-typedesc-equal.c
@@ -4,6 +4,7 @@
    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-string.h"
 #include "go-type.h"
 
diff --git a/libgo/runtime/go-typestring.c b/libgo/runtime/go-typestring.c
index d40c6ad..712c333 100644
--- a/libgo/runtime/go-typestring.c
+++ b/libgo/runtime/go-typestring.c
@@ -4,14 +4,13 @@
    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-type.h"
-#include "go-string.h"
 
-struct __go_string typestring(struct __go_empty_interface)
-  asm ("runtime.typestring");
+String typestring(struct __go_empty_interface) asm ("runtime.typestring");
 
-struct __go_string
+String
 typestring (struct __go_empty_interface e)
 {
   return *e.__type_descriptor->__reflection;
diff --git a/libgo/runtime/go-unsafe-pointer.c b/libgo/runtime/go-unsafe-pointer.c
index cda5936..e3a55b4 100644
--- a/libgo/runtime/go-unsafe-pointer.c
+++ b/libgo/runtime/go-unsafe-pointer.c
@@ -6,7 +6,7 @@
 
 #include <stddef.h>
 
-#include "go-string.h"
+#include "runtime.h"
 #include "go-type.h"
 
 /* This file provides the type descriptor for the unsafe.Pointer type.
@@ -26,9 +26,9 @@ struct field_align
 
 /* The reflection string.  */
 #define REFLECTION "unsafe.Pointer"
-static const struct __go_string reflection_string =
+static const String reflection_string =
 {
-  (const unsigned char *) REFLECTION,
+  (const byte *) REFLECTION,
   sizeof REFLECTION - 1
 };
 
@@ -65,9 +65,9 @@ extern const struct __go_ptr_type pointer_unsafe_Pointer
 
 /* The reflection string.  */
 #define PREFLECTION "*unsafe.Pointer"
-static const struct __go_string preflection_string =
+static const String preflection_string =
 {
-  (const unsigned char *) PREFLECTION,
+  (const byte *) PREFLECTION,
   sizeof PREFLECTION - 1,
 };
 
diff --git a/libgo/runtime/interface.h b/libgo/runtime/interface.h
index 610f208..f3068a6 100644
--- a/libgo/runtime/interface.h
+++ b/libgo/runtime/interface.h
@@ -7,7 +7,7 @@
 #ifndef LIBGO_INTERFACE_H
 #define LIBGO_INTERFACE_H
 
-#include "go-type.h"
+struct __go_type_descriptor;
 
 /* A variable of interface type is an instance of this struct, if the
    interface has any methods.  */
diff --git a/libgo/runtime/malloc.goc b/libgo/runtime/malloc.goc
index 1b6828fd..1a0afed 100644
--- a/libgo/runtime/malloc.goc
+++ b/libgo/runtime/malloc.goc
@@ -14,7 +14,6 @@ package runtime
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
-#include "go-string.h"
 #include "interface.h"
 #include "go-type.h"
 #include "race.h"
diff --git a/libgo/runtime/panic.c b/libgo/runtime/panic.c
index 98326c6..1af9639 100644
--- a/libgo/runtime/panic.c
+++ b/libgo/runtime/panic.c
@@ -4,6 +4,7 @@
 
 #include "runtime.h"
 #include "go-defer.h"
+#include "go-panic.h"
 
 // Code related to defer, panic and recover.
 
diff --git a/libgo/runtime/print.c b/libgo/runtime/print.c
index 690bcaf..42717bb 100644
--- a/libgo/runtime/print.c
+++ b/libgo/runtime/print.c
@@ -4,6 +4,7 @@
 
 #include <stdarg.h>
 #include "runtime.h"
+#include "array.h"
 
 //static Lock debuglock;
 
@@ -294,8 +295,8 @@ runtime_printstring(String v)
 	//	gwrite("[string too long]", 17);
 	//	return;
 	// }
-	if(v.__length > 0)
-		gwrite(v.__data, v.__length);
+	if(v.len > 0)
+		gwrite(v.str, v.len);
 }
 
 void
diff --git a/libgo/runtime/proc.c b/libgo/runtime/proc.c
index 620cd10..8e82d12 100644
--- a/libgo/runtime/proc.c
+++ b/libgo/runtime/proc.c
@@ -586,13 +586,13 @@ void
 runtime_goroutinetrailer(G *g)
 {
 	if(g != nil && g->gopc != 0 && g->goid != 1) {
-		struct __go_string fn;
-		struct __go_string file;
+		String fn;
+		String file;
 		int line;
 
 		if(__go_file_line(g->gopc - 1, &fn, &file, &line)) {
-			runtime_printf("created by %s\n", fn.__data);
-			runtime_printf("\t%s:%d\n", file.__data, line);
+			runtime_printf("created by %S\n", fn);
+			runtime_printf("\t%S:%d\n", file, line);
 		}
 	}
 }
diff --git a/libgo/runtime/reflect.goc b/libgo/runtime/reflect.goc
index 447b786..c798b26 100644
--- a/libgo/runtime/reflect.goc
+++ b/libgo/runtime/reflect.goc
@@ -3,9 +3,9 @@
 // license that can be found in the LICENSE file.
 
 package reflect
+#include "runtime.h"
 #include "go-type.h"
 #include "interface.h"
-#include "runtime.h"
 #include "go-panic.h"
 
 func ifaceE2I(inter *Type, e Eface, ret *Iface) {
diff --git a/libgo/runtime/runtime.c b/libgo/runtime/runtime.c
index c5716ab..3d4865a 100644
--- a/libgo/runtime/runtime.c
+++ b/libgo/runtime/runtime.c
@@ -9,7 +9,6 @@
 #include "runtime.h"
 #include "array.h"
 #include "go-panic.h"
-#include "go-string.h"
 
 int32
 runtime_gotraceback(void)
@@ -93,9 +92,9 @@ runtime_getenv(const char *s)
 	envv = (String*)syscall_Envs.__values;
 	envc = syscall_Envs.__count;
 	for(i=0; i<envc; i++){
-		if(envv[i].__length <= len)
+		if(envv[i].len <= len)
 			continue;
-		v = (const byte*)envv[i].__data;
+		v = (const byte*)envv[i].str;
 		for(j=0; j<len; j++)
 			if(bs[j] != v[j])
 				goto nomatch;
diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h
index defe792..e6281ea 100644
--- a/libgo/runtime/runtime.h
+++ b/libgo/runtime/runtime.h
@@ -21,10 +21,8 @@
 #include <sys/mman.h>
 #endif
 
-#include "array.h"
+#include "interface.h"
 #include "go-alloc.h"
-#include "go-panic.h"
-#include "go-string.h"
 
 /* This file supports C files copied from the 6g runtime library.
    This is a version of the 6g runtime.h rewritten for gccgo's version
@@ -67,7 +65,7 @@ typedef struct	ParFor		ParFor;
 typedef struct	ParForThread	ParForThread;
 
 typedef	struct	__go_open_array		Slice;
-typedef	struct	__go_string		String;
+typedef	struct	String			String;
 typedef struct	__go_interface		Iface;
 typedef	struct	__go_empty_interface	Eface;
 typedef	struct	__go_type_descriptor	Type;
@@ -129,6 +127,11 @@ union	Note
 	uint32	key;	// futex-based impl
 	M*	waitm;	// waiting M (sema-based impl)
 };
+struct String
+{
+	const byte*	str;
+	intgo		len;
+};
 struct	GCStats
 {
 	// the struct must consist of only uint64's,
diff --git a/libgo/runtime/string.goc b/libgo/runtime/string.goc
index 4e616c7..d3f0c2d 100644
--- a/libgo/runtime/string.goc
+++ b/libgo/runtime/string.goc
@@ -6,10 +6,11 @@ package runtime
 #include "runtime.h"
 #include "arch.h"
 #include "malloc.h"
+#include "go-string.h"
 
 #define charntorune(pv, str, len) __go_get_rune(str, len, pv)
 
-int32
+intgo
 runtime_findnull(const byte *s)
 {
 	if(s == nil)
@@ -22,8 +23,8 @@ runtime_gostringnocopy(const byte *str)
 {
 	String s;
 	
-	s.__data = (const unsigned char *) str;
-	s.__length = runtime_findnull(str);
+	s.str = str;
+	s.len = runtime_findnull(str);
 	return s;
 }
 
@@ -35,40 +36,40 @@ enum
 func stringiter(s String, k int) (retk int) {
 	int32 l;
 
-	if(k >= s.__length) {
+	if(k >= s.len) {
 		// retk=0 is end of iteration
 		retk = 0;
 		goto out;
 	}
 
-	l = s.__data[k];
+	l = s.str[k];
 	if(l < Runeself) {
 		retk = k+1;
 		goto out;
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&l, s.__data+k, s.__length-k);
+	retk = k + charntorune(&l, s.str+k, s.len-k);
 
 out:
 }
 
 func stringiter2(s String, k int) (retk int, retv int) {
-	if(k >= s.__length) {
+	if(k >= s.len) {
 		// retk=0 is end of iteration
 		retk = 0;
 		retv = 0;
 		goto out;
 	}
 
-	retv = s.__data[k];
+	retv = s.str[k];
 	if(retv < Runeself) {
 		retk = k+1;
 		goto out;
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&retv, s.__data+k, s.__length-k);
+	retk = k + charntorune(&retv, s.str+k, s.len-k);
 
 out:
 }