diff --git a/go/expressions.cc b/go/expressions.cc
index 2953b3d..b930ec2 100644
--- a/go/expressions.cc
+++ b/go/expressions.cc
@@ -14572,7 +14572,7 @@
  protected:
   Type*
   do_type()
-  { return Type::lookup_integer_type("uintptr"); }
+  { return Type::make_pointer_type(Type::lookup_integer_type("uint8")); }
 
   bool
   do_is_static_initializer() const
diff --git a/go/types.cc b/go/types.cc
index a48ea30..aa43df3 100644
--- a/go/types.cc
+++ b/go/types.cc
@@ -1482,6 +1482,7 @@
       Location bloc = Linemap::predeclared_location();
 
       Type* uint8_type = Type::lookup_integer_type("uint8");
+      Type* pointer_uint8_type = Type::make_pointer_type(uint8_type);
       Type* uint32_type = Type::lookup_integer_type("uint32");
       Type* uintptr_type = Type::lookup_integer_type("uintptr");
       Type* string_type = Type::lookup_string_type();
@@ -1548,15 +1549,16 @@
       // The type descriptor type.
 
       Struct_type* type_descriptor_type =
-	Type::make_builtin_struct_type(11,
+	Type::make_builtin_struct_type(12,
+				       "size", uintptr_type,
+				       "ptrdata", uintptr_type,
+				       "hash", uint32_type,
 				       "kind", uint8_type,
 				       "align", uint8_type,
 				       "fieldAlign", uint8_type,
-				       "size", uintptr_type,
-				       "hash", uint32_type,
 				       "hashfn", hash_fntype,
 				       "equalfn", equal_fntype,
-				       "gc", uintptr_type,
+				       "gcdata", pointer_uint8_type,
 				       "string", pointer_string_type,
 				       "", pointer_uncommon_type,
 				       "ptrToThis",
@@ -2312,30 +2314,25 @@
   const Struct_field_list* fields = td_type->struct_type()->fields();
 
   Expression_list* vals = new Expression_list();
-  vals->reserve(9);
+  vals->reserve(12);
 
   if (!this->has_pointer())
     runtime_type_kind |= RUNTIME_TYPE_KIND_NO_POINTERS;
   if (this->points_to() != NULL)
     runtime_type_kind |= RUNTIME_TYPE_KIND_DIRECT_IFACE;
+  int64_t ptrsize;
+  int64_t ptrdata;
+  if (this->needs_gcprog(gogo, &ptrsize, &ptrdata))
+    runtime_type_kind |= RUNTIME_TYPE_KIND_GC_PROG;
+
   Struct_field_list::const_iterator p = fields->begin();
-  go_assert(p->is_field_name("kind"));
-  vals->push_back(Expression::make_integer_ul(runtime_type_kind, p->type(),
-					      bloc));
-
-  ++p;
-  go_assert(p->is_field_name("align"));
-  Expression::Type_info type_info = Expression::TYPE_INFO_ALIGNMENT;
-  vals->push_back(Expression::make_type_info(this, type_info));
-
-  ++p;
-  go_assert(p->is_field_name("fieldAlign"));
-  type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
-  vals->push_back(Expression::make_type_info(this, type_info));
-
-  ++p;
   go_assert(p->is_field_name("size"));
-  type_info = Expression::TYPE_INFO_SIZE;
+  Expression::Type_info type_info = Expression::TYPE_INFO_SIZE;
+  vals->push_back(Expression::make_type_info(this, type_info));
+
+  ++p;
+  go_assert(p->is_field_name("ptrdata"));
+  type_info = Expression::TYPE_INFO_DESCRIPTOR_PTRDATA;
   vals->push_back(Expression::make_type_info(this, type_info));
 
   ++p;
@@ -2348,6 +2345,21 @@
   vals->push_back(Expression::make_integer_ul(h, p->type(), bloc));
 
   ++p;
+  go_assert(p->is_field_name("kind"));
+  vals->push_back(Expression::make_integer_ul(runtime_type_kind, p->type(),
+					      bloc));
+
+  ++p;
+  go_assert(p->is_field_name("align"));
+  type_info = Expression::TYPE_INFO_ALIGNMENT;
+  vals->push_back(Expression::make_type_info(this, type_info));
+
+  ++p;
+  go_assert(p->is_field_name("fieldAlign"));
+  type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
+  vals->push_back(Expression::make_type_info(this, type_info));
+
+  ++p;
   go_assert(p->is_field_name("hashfn"));
   Function_type* hash_fntype = p->type()->function_type();
 
@@ -2373,7 +2385,7 @@
     vals->push_back(Expression::make_func_reference(equal_fn, NULL, bloc));
 
   ++p;
-  go_assert(p->is_field_name("gc"));
+  go_assert(p->is_field_name("gcdata"));
   vals->push_back(Expression::make_gc_symbol(this));
 
   ++p;
@@ -2442,7 +2454,10 @@
       gogo->backend()->var_expression(t->gc_symbol_var_, VE_rvalue, bloc);
   Bexpression* addr_expr =
       gogo->backend()->address_expression(var_expr, bloc);
-  Btype* ubtype = Type::lookup_integer_type("uintptr")->get_backend(gogo);
+
+  Type* uint8_type = Type::lookup_integer_type("uint8");
+  Type* pointer_uint8_type = Type::make_pointer_type(uint8_type);
+  Btype* ubtype = pointer_uint8_type->get_backend(gogo);
   return gogo->backend()->convert_expression(ubtype, addr_expr, bloc);
 }
 
@@ -2578,6 +2593,22 @@
   return Expression::make_array_composite_literal(gc_symbol_type, vals, bloc);
 }
 
+// A temporary function to convert a GC_symbol_expression, with type
+// *byte, to type uintptr, so that it can be stored in a GC symbol.
+// This will be discarded when we move to the Go 1.8 garbage
+// collector.
+
+static Expression*
+to_uintptr(Expression* expr)
+{
+  go_assert(expr->type()->points_to() != NULL);
+  Location loc = expr->location();
+  expr = Expression::make_cast(Type::make_pointer_type(Type::make_void_type()),
+			       expr, loc);
+  return Expression::make_cast(Type::lookup_integer_type("uintptr"), expr,
+			       loc);
+}
+
 // Advance the OFFSET of the GC symbol by this type's width.
 
 void
@@ -5555,7 +5586,7 @@
   (*vals)->push_back(*offset);
 
   if (this->to_type_->has_pointer())
-    (*vals)->push_back(Expression::make_gc_symbol(this->to_type_));
+    (*vals)->push_back(to_uintptr(Expression::make_gc_symbol(this->to_type_)));
   this->advance_gc_offset(offset);
 }
 
@@ -8002,7 +8033,7 @@
   (*vals)->push_back(*offset);
 
   if (element_size != 0 && ok)
-    (*vals)->push_back(Expression::make_gc_symbol(element_type));
+    (*vals)->push_back(to_uintptr(Expression::make_gc_symbol(element_type)));
   this->advance_gc_offset(offset);
 }
 
@@ -8075,7 +8106,7 @@
 	  Expression* width =
 	    Expression::make_type_info(this, Expression::TYPE_INFO_SIZE);
   	  (*vals)->push_back(width);
-	  (*vals)->push_back(Expression::make_gc_symbol(this));
+	  (*vals)->push_back(to_uintptr(Expression::make_gc_symbol(this)));
   	}
       this->advance_gc_offset(offset);
     }
diff --git a/libgo/go/reflect/type.go b/libgo/go/reflect/type.go
index 0325260..00349ba 100644
--- a/libgo/go/reflect/type.go
+++ b/libgo/go/reflect/type.go
@@ -259,20 +259,21 @@
 // with a unique tag like `reflect:"array"` or `reflect:"ptr"`
 // so that code cannot convert from, say, *arrayType to *ptrType.
 type rtype struct {
-	kind       uint8 // enumeration for C
-	align      int8  // alignment of variable with this type
-	fieldAlign uint8 // alignment of struct field with this type
-	_          uint8 // unused/padding
 	size       uintptr
-	hash       uint32 // hash of type; avoids computation in hash tables
+	ptrdata    uintptr // size of memory prefix holding all pointers
+	hash       uint32  // hash of type; avoids computation in hash tables
+	kind       uint8   // enumeration for C
+	align      int8    // alignment of variable with this type
+	fieldAlign uint8   // alignment of struct field with this type
+	_          uint8   // unused/padding
 
 	hashfn  func(unsafe.Pointer, uintptr) uintptr     // hash function
 	equalfn func(unsafe.Pointer, unsafe.Pointer) bool // equality function
 
-	gc            unsafe.Pointer // garbage collection data
-	string        *string        // string form; unnecessary  but undeniably useful
-	*uncommonType                // (relatively) uncommon fields
-	ptrToThis     *rtype         // type for pointer to this type, if used in binary or has methods
+	gcdata        *byte   // garbage collection data
+	string        *string // string form; unnecessary  but undeniably useful
+	*uncommonType         // (relatively) uncommon fields
+	ptrToThis     *rtype  // type for pointer to this type, if used in binary or has methods
 }
 
 // Method on non-interface type
@@ -1190,15 +1191,15 @@
 	pp.elem = t
 
 	if t.kind&kindNoPointers != 0 {
-		pp.gc = unsafe.Pointer(&ptrDataGCProg)
+		pp.gcdata = (*byte)(unsafe.Pointer(&ptrDataGCProg))
 	} else {
-		pp.gc = unsafe.Pointer(&ptrGC{
+		pp.gcdata = (*byte)(unsafe.Pointer(&ptrGC{
 			width:  pp.size,
 			op:     _GC_PTR,
 			off:    0,
-			elemgc: t.gc,
+			elemgc: unsafe.Pointer(t.gcdata),
 			end:    _GC_END,
-		})
+		}))
 	}
 
 	q := canonicalize(&pp.rtype)
@@ -1584,16 +1585,16 @@
 	ch.uncommonType = nil
 	ch.ptrToThis = nil
 
-	ch.gc = unsafe.Pointer(&chanGC{
+	ch.gcdata = (*byte)(unsafe.Pointer(&chanGC{
 		width: ch.size,
 		op:    _GC_CHAN_PTR,
 		off:   0,
 		typ:   &ch.rtype,
 		end:   _GC_END,
-	})
+	}))
 
-	// INCORRECT. Uncomment to check that TestChanOfGC fails when ch.gc is wrong.
-	// ch.gc = unsafe.Pointer(&badGC{width: ch.size, end: _GC_END})
+	// INCORRECT. Uncomment to check that TestChanOfGC fails when ch.gcdata is wrong.
+	// ch.gcdata = unsafe.Pointer(&badGC{width: ch.size, end: _GC_END})
 
 	return cachePut(ckey, &ch.rtype)
 }
@@ -1734,7 +1735,7 @@
 	ft.ptrToThis = nil
 
 	// TODO(cmang): Generate GC data for funcs.
-	ft.gc = unsafe.Pointer(&ptrDataGCProg)
+	ft.gcdata = (*byte)(unsafe.Pointer(&ptrDataGCProg))
 
 	funcLookupCache.m[hash] = append(funcLookupCache.m[hash], &ft.rtype)
 
@@ -1913,7 +1914,7 @@
 		fieldAlign: uint8(maxAlign),
 		size:       size,
 		kind:       kind,
-		gc:         gcPtr,
+		gcdata:     (*byte)(gcPtr),
 	}
 	s := "bucket(" + *ktyp.string + "," + *etyp.string + ")"
 	b.string = &s
@@ -1922,7 +1923,7 @@
 
 // Take the GC program for "t" and append it to the GC program "gc".
 func appendGCProgram(gc []uintptr, t *rtype, offset uintptr) []uintptr {
-	p := t.gc
+	p := unsafe.Pointer(t.gcdata)
 	p = unsafe.Pointer(uintptr(p) + unsafe.Sizeof(uintptr(0))) // skip size
 loop:
 	for {
@@ -1967,9 +1968,9 @@
 	offset = (offset + 1) / 2 * 2
 	offset += unsafe.Sizeof(uint16(0)) // bucketsize
 	offset = (offset + ptrsize - 1) / ptrsize * ptrsize
-	// gc = append(gc, _GC_PTR, offset, uintptr(bucket.gc)) // buckets
+	// gc = append(gc, _GC_PTR, offset, uintptr(bucket.gcdata)) // buckets
 	offset += ptrsize
-	// gc = append(gc, _GC_PTR, offset, uintptr(bucket.gc)) // oldbuckets
+	// gc = append(gc, _GC_PTR, offset, uintptr(bucket.gcdata)) // oldbuckets
 	offset += ptrsize
 	offset += ptrsize // nevacuate
 	gc = append(gc, _GC_END)
@@ -1977,7 +1978,7 @@
 
 	h := new(rtype)
 	h.size = offset
-	// h.gc = unsafe.Pointer(&gc[0])
+	// h.gcdata = unsafe.Pointer(&gc[0])
 	s := "hmap(" + *bucket.string + ")"
 	h.string = &s
 	return h
@@ -2038,19 +2039,19 @@
 	slice.ptrToThis = nil
 
 	if typ.size == 0 {
-		slice.gc = unsafe.Pointer(&sliceEmptyGCProg)
+		slice.gcdata = (*byte)(unsafe.Pointer(&sliceEmptyGCProg))
 	} else {
-		slice.gc = unsafe.Pointer(&sliceGC{
+		slice.gcdata = (*byte)(unsafe.Pointer(&sliceGC{
 			width:  slice.size,
 			op:     _GC_SLICE,
 			off:    0,
-			elemgc: typ.gc,
+			elemgc: unsafe.Pointer(typ.gcdata),
 			end:    _GC_END,
-		})
+		}))
 	}
 
-	// INCORRECT. Uncomment to check that TestSliceOfOfGC fails when slice.gc is wrong.
-	// slice.gc = unsafe.Pointer(&badGC{width: slice.size, end: _GC_END})
+	// INCORRECT. Uncomment to check that TestSliceOfOfGC fails when slice.gcdata is wrong.
+	// slice.gcdata = unsafe.Pointer(&badGC{width: slice.size, end: _GC_END})
 
 	return cachePut(ckey, &slice.rtype)
 }
@@ -2229,7 +2230,7 @@
 	if !hasPtr {
 		typ.kind |= kindNoPointers
 		gc := [...]uintptr{size, _GC_END}
-		typ.gc = unsafe.Pointer(&gc[0])
+		typ.gcdata = (*byte)(unsafe.Pointer(&gc[0]))
 	} else {
 		typ.kind &^= kindNoPointers
 		gc := []uintptr{size}
@@ -2237,7 +2238,7 @@
 			gc = appendGCProgram(gc, ft.typ, ft.offset)
 		}
 		gc = append(gc, _GC_END)
-		typ.gc = unsafe.Pointer(&gc[0])
+		typ.gcdata = (*byte)(unsafe.Pointer(&gc[0]))
 	}
 
 	typ.hashfn = func(p unsafe.Pointer, seed uintptr) uintptr {
@@ -2365,18 +2366,18 @@
 		// No pointers.
 		array.kind |= kindNoPointers
 		gc := [...]uintptr{array.size, _GC_END}
-		array.gc = unsafe.Pointer(&gc[0])
+		array.gcdata = (*byte)(unsafe.Pointer(&gc[0]))
 
 	case count == 1:
 		// In memory, 1-element array looks just like the element.
 		array.kind |= typ.kind & kindGCProg
-		array.gc = typ.gc
+		array.gcdata = typ.gcdata
 
 	default:
 		gc := []uintptr{array.size, _GC_ARRAY_START, 0, uintptr(count), typ.size}
 		gc = appendGCProgram(gc, typ, 0)
 		gc = append(gc, _GC_ARRAY_NEXT, _GC_END)
-		array.gc = unsafe.Pointer(&gc[0])
+		array.gcdata = (*byte)(unsafe.Pointer(&gc[0]))
 	}
 
 	array.kind &^= kindDirectIface
diff --git a/libgo/go/runtime/type.go b/libgo/go/runtime/type.go
index cfee35a..6788f24 100644
--- a/libgo/go/runtime/type.go
+++ b/libgo/go/runtime/type.go
@@ -9,17 +9,18 @@
 import "unsafe"
 
 type _type struct {
+	size       uintptr
+	ptrdata    uintptr
+	hash       uint32
 	kind       uint8
 	align      int8
 	fieldAlign uint8
 	_          uint8
-	size       uintptr
-	hash       uint32
 
 	hashfn  func(unsafe.Pointer, uintptr) uintptr
 	equalfn func(unsafe.Pointer, unsafe.Pointer) bool
 
-	gc     unsafe.Pointer
+	gcdata *byte
 	string *string
 	*uncommontype
 	ptrToThis *_type
diff --git a/libgo/runtime/go-type.h b/libgo/runtime/go-type.h
index e155254..03806f6 100644
--- a/libgo/runtime/go-type.h
+++ b/libgo/runtime/go-type.h
@@ -66,6 +66,17 @@
 
 struct __go_type_descriptor
 {
+  /* The size in bytes of a value of this type.  Note that all types
+     in Go have a fixed size.  */
+  uintptr_t __size;
+
+  /* The size of the memory prefix of a value of this type that holds
+     all pointers.  */
+  uintptr_t __ptrdata;
+
+  /* The type's hash code.  */
+  uint32_t __hash;
+
   /* The type code for this type, one of the type kind values above.
      This is used by unsafe.Reflect and unsafe.Typeof to determine the
      type descriptor to return for this type itself.  It is also used
@@ -78,13 +89,6 @@
   /* The alignment in bytes of a struct field with this type.  */
   unsigned char __field_align;
 
-  /* The size in bytes of a value of this type.  Note that all types
-     in Go have a fixed size.  */
-  uintptr_t __size;
-
-  /* The type's hash code.  */
-  uint32_t __hash;
-
   /* This function takes a pointer to a value of this type, and the
      size of this type, and returns a hash code.  We pass the size
      explicitly becaues it means that we can share a single instance
@@ -96,7 +100,7 @@
   const FuncVal *__equalfn;
 
   /* The garbage collection data. */
-  const uintptr *__gc;
+  const byte *__gcdata;
 
   /* A string describing this type.  This is only used for
      debugging.  */
diff --git a/libgo/runtime/go-unsafe-pointer.c b/libgo/runtime/go-unsafe-pointer.c
index 3a97ee1..483f6ab 100644
--- a/libgo/runtime/go-unsafe-pointer.c
+++ b/libgo/runtime/go-unsafe-pointer.c
@@ -46,22 +46,24 @@
 
 const struct __go_type_descriptor unsafe_Pointer =
 {
+  /* __size */
+  sizeof (void *),
+  /* __ptrdata */
+  sizeof (void *),
+  /* __hash */
+  78501163U,
   /* __code */
   GO_UNSAFE_POINTER | GO_DIRECT_IFACE,
   /* __align */
   __alignof (void *),
   /* __field_align */
   offsetof (struct field_align, p) - 1,
-  /* __size */
-  sizeof (void *),
-  /* __hash */
-  78501163U,
   /* __hashfn */
   &runtime_pointerhash_descriptor,
   /* __equalfn */
   &runtime_pointerequal_descriptor,
-  /* __gc */
-  unsafe_Pointer_gc,
+  /* __gcdata */
+  (const byte*)(unsafe_Pointer_gc),
   /* __reflection */
   &reflection_string,
   /* __uncommon */
@@ -95,22 +97,24 @@
 {
   /* __common */
   {
+    /* __size */
+    sizeof (void *),
+    /* __ptrdata */
+    sizeof (void *),
+    /* __hash */
+    1256018616U,
     /* __code */
     GO_PTR | GO_DIRECT_IFACE,
     /* __align */
     __alignof (void *),
     /* __field_align */
     offsetof (struct field_align, p) - 1,
-    /* __size */
-    sizeof (void *),
-    /* __hash */
-    1256018616U,
     /* __hashfn */
     &runtime_pointerhash_descriptor,
     /* __equalfn */
     &runtime_pointerequal_descriptor,
-    /* __gc */
-    pointer_unsafe_Pointer_gc,
+    /* __gcdata */
+    (const byte*)(pointer_unsafe_Pointer_gc),
     /* __reflection */
     &preflection_string,
     /* __uncommon */
diff --git a/libgo/runtime/mgc0.c b/libgo/runtime/mgc0.c
index 357641d..8e7d7ef 100644
--- a/libgo/runtime/mgc0.c
+++ b/libgo/runtime/mgc0.c
@@ -674,7 +674,7 @@
 		// Runtime and gc think differently about closures.
 		 runtime_strstr((const char *)t->string->str, (const char*)"struct { F uintptr") != (const char *)t->string->str)) {
 		pc1 = (uintptr*)objti;
-		pc2 = (const uintptr*)t->__gc;
+		pc2 = (const uintptr*)t->__gcdata;
 		// A simple best-effort check until first GC_END.
 		for(j = 1; pc1[j] != GC_END && pc2[j] != GC_END; j++) {
 			if(pc1[j] != pc2[j]) {
@@ -801,13 +801,13 @@
 				t = (Type*)(type & ~(uintptr)(PtrSize-1));
 				switch(type & (PtrSize-1)) {
 				case TypeInfo_SingleObject:
-					pc = (const uintptr*)t->__gc;
+					pc = (const uintptr*)t->__gcdata;
 					precise_type = true;  // type information about 'b' is precise
 					stack_top.count = 1;
 					stack_top.elemsize = pc[0];
 					break;
 				case TypeInfo_Array:
-					pc = (const uintptr*)t->__gc;
+					pc = (const uintptr*)t->__gcdata;
 					if(pc[0] == 0)
 						goto next_block;
 					precise_type = true;  // type information about 'b' is precise
@@ -926,11 +926,11 @@
 						// dgcsym1 in case TPTR32/case TPTR64. See rationale there.
 						et = ((const PtrType*)t)->elem;
 						if(!(et->__code & kindNoPointers))
-							objti = (uintptr)((const PtrType*)t)->elem->__gc;
+							objti = (uintptr)((const PtrType*)t)->elem->__gcdata;
 					}
 				} else {
 					obj = eface->data;
-					objti = (uintptr)t->__gc;
+					objti = (uintptr)t->__gcdata;
 				}
 			}
 			break;
@@ -964,11 +964,11 @@
 						// dgcsym1 in case TPTR32/case TPTR64. See rationale there.
 						et = ((const PtrType*)t)->elem;
 						if(!(et->__code & kindNoPointers))
-							objti = (uintptr)((const PtrType*)t)->elem->__gc;
+							objti = (uintptr)((const PtrType*)t)->elem->__gcdata;
 					}
 				} else {
 					obj = iface->data;
-					objti = (uintptr)t->__gc;
+					objti = (uintptr)t->__gcdata;
 				}
 			}
 			break;
@@ -1095,7 +1095,7 @@
 					// (Channel routines zero the unused part, so the current
 					// code does not lead to leaks, it's just a little inefficient.)
 					*sbuf.obj.pos++ = (Obj){chan->buf, chancap*chantype->elem->__size,
-						(uintptr)chantype->elem->__gc | PRECISE | LOOP};
+						(uintptr)chantype->elem->__gcdata | PRECISE | LOOP};
 					if(sbuf.obj.pos == sbuf.obj.end)
 						flushobjbuf(&sbuf);
 				}