obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

5 files changed, 3608 insertions, 0 deletions

diff --git a/libgo/go/reflect/all_test.go b/libgo/go/reflect/all_test.go
new file mode 100644
index 000000000..320f44203
--- /dev/null
+++ b/libgo/go/reflect/all_test.go
@@ -0,0 +1,1392 @@
+// 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.
+
+package reflect_test
+
+import (
+	"container/vector"
+	"fmt"
+	"io"
+	"os"
+	. "reflect"
+	"testing"
+	"unsafe"
+)
+
+type integer int
+type T struct {
+	a int
+	b float64
+	c string
+	d *int
+}
+
+type pair struct {
+	i interface{}
+	s string
+}
+
+func isDigit(c uint8) bool { return '0' <= c && c <= '9' }
+
+func assert(t *testing.T, s, want string) {
+	if s != want {
+		t.Errorf("have %#q want %#q", s, want)
+	}
+}
+
+func typestring(i interface{}) string { return Typeof(i).String() }
+
+var typeTests = []pair{
+	{struct{ x int }{}, "int"},
+	{struct{ x int8 }{}, "int8"},
+	{struct{ x int16 }{}, "int16"},
+	{struct{ x int32 }{}, "int32"},
+	{struct{ x int64 }{}, "int64"},
+	{struct{ x uint }{}, "uint"},
+	{struct{ x uint8 }{}, "uint8"},
+	{struct{ x uint16 }{}, "uint16"},
+	{struct{ x uint32 }{}, "uint32"},
+	{struct{ x uint64 }{}, "uint64"},
+	{struct{ x float32 }{}, "float32"},
+	{struct{ x float64 }{}, "float64"},
+	{struct{ x int8 }{}, "int8"},
+	{struct{ x (**int8) }{}, "**int8"},
+	{struct{ x (**integer) }{}, "**reflect_test.integer"},
+	{struct{ x ([32]int32) }{}, "[32]int32"},
+	{struct{ x ([]int8) }{}, "[]int8"},
+	{struct{ x (map[string]int32) }{}, "map[string] int32"},
+	{struct{ x (chan<- string) }{}, "chan<- string"},
+	{struct {
+		x struct {
+			c chan *int32
+			d float32
+		}
+	}{},
+		"struct { c chan *int32; d float32 }",
+	},
+	{struct{ x (func(a int8, b int32)) }{}, "func(int8, int32)"},
+	{struct {
+		x struct {
+			c func(chan *integer, *int8)
+		}
+	}{},
+		"struct { c func(chan *reflect_test.integer, *int8) }",
+	},
+	{struct {
+		x struct {
+			a int8
+			b int32
+		}
+	}{},
+		"struct { a int8; b int32 }",
+	},
+	{struct {
+		x struct {
+			a int8
+			b int8
+			c int32
+		}
+	}{},
+		"struct { a int8; b int8; c int32 }",
+	},
+	{struct {
+		x struct {
+			a int8
+			b int8
+			c int8
+			d int32
+		}
+	}{},
+		"struct { a int8; b int8; c int8; d int32 }",
+	},
+	{struct {
+		x struct {
+			a int8
+			b int8
+			c int8
+			d int8
+			e int32
+		}
+	}{},
+		"struct { a int8; b int8; c int8; d int8; e int32 }",
+	},
+	{struct {
+		x struct {
+			a int8
+			b int8
+			c int8
+			d int8
+			e int8
+			f int32
+		}
+	}{},
+		"struct { a int8; b int8; c int8; d int8; e int8; f int32 }",
+	},
+	{struct {
+		x struct {
+			a int8 "hi there"
+		}
+	}{},
+		`struct { a int8 "hi there" }`,
+	},
+	{struct {
+		x struct {
+			a int8 "hi \x00there\t\n\"\\"
+		}
+	}{},
+		`struct { a int8 "hi \x00there\t\n\"\\" }`,
+	},
+	{struct {
+		x struct {
+			f func(args ...int)
+		}
+	}{},
+		"struct { f func(...int) }",
+	},
+	{struct {
+		x (interface {
+			a(func(func(int) int) func(func(int)) int)
+			b()
+		})
+	}{},
+		"interface { a(func(func(int) int) func(func(int)) int); b() }",
+	},
+}
+
+var valueTests = []pair{
+	{(int8)(0), "8"},
+	{(int16)(0), "16"},
+	{(int32)(0), "32"},
+	{(int64)(0), "64"},
+	{(uint8)(0), "8"},
+	{(uint16)(0), "16"},
+	{(uint32)(0), "32"},
+	{(uint64)(0), "64"},
+	{(float32)(0), "256.25"},
+	{(float64)(0), "512.125"},
+	{(string)(""), "stringy cheese"},
+	{(bool)(false), "true"},
+	{(*int8)(nil), "*int8(0)"},
+	{(**int8)(nil), "**int8(0)"},
+	{[5]int32{}, "[5]int32{0, 0, 0, 0, 0}"},
+	{(**integer)(nil), "**reflect_test.integer(0)"},
+	{(map[string]int32)(nil), "map[string] int32{<can't iterate on maps>}"},
+	{(chan<- string)(nil), "chan<- string"},
+	{struct {
+		c chan *int32
+		d float32
+	}{},
+		"struct { c chan *int32; d float32 }{chan *int32, 0}",
+	},
+	{(func(a int8, b int32))(nil), "func(int8, int32)(0)"},
+	{struct{ c func(chan *integer, *int8) }{},
+		"struct { c func(chan *reflect_test.integer, *int8) }{func(chan *reflect_test.integer, *int8)(0)}",
+	},
+	{struct {
+		a int8
+		b int32
+	}{},
+		"struct { a int8; b int32 }{0, 0}",
+	},
+	{struct {
+		a int8
+		b int8
+		c int32
+	}{},
+		"struct { a int8; b int8; c int32 }{0, 0, 0}",
+	},
+}
+
+func testType(t *testing.T, i int, typ Type, want string) {
+	s := typ.String()
+	if s != want {
+		t.Errorf("#%d: have %#q, want %#q", i, s, want)
+	}
+}
+
+func TestTypes(t *testing.T) {
+	for i, tt := range typeTests {
+		testType(t, i, NewValue(tt.i).(*StructValue).Field(0).Type(), tt.s)
+	}
+}
+
+func TestSet(t *testing.T) {
+	for i, tt := range valueTests {
+		v := NewValue(tt.i)
+		switch v := v.(type) {
+		case *IntValue:
+			switch v.Type().Kind() {
+			case Int:
+				v.Set(132)
+			case Int8:
+				v.Set(8)
+			case Int16:
+				v.Set(16)
+			case Int32:
+				v.Set(32)
+			case Int64:
+				v.Set(64)
+			}
+		case *UintValue:
+			switch v.Type().Kind() {
+			case Uint:
+				v.Set(132)
+			case Uint8:
+				v.Set(8)
+			case Uint16:
+				v.Set(16)
+			case Uint32:
+				v.Set(32)
+			case Uint64:
+				v.Set(64)
+			}
+		case *FloatValue:
+			switch v.Type().Kind() {
+			case Float32:
+				v.Set(256.25)
+			case Float64:
+				v.Set(512.125)
+			}
+		case *ComplexValue:
+			switch v.Type().Kind() {
+			case Complex64:
+				v.Set(532.125 + 10i)
+			case Complex128:
+				v.Set(564.25 + 1i)
+			}
+		case *StringValue:
+			v.Set("stringy cheese")
+		case *BoolValue:
+			v.Set(true)
+		}
+		s := valueToString(v)
+		if s != tt.s {
+			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
+		}
+	}
+}
+
+func TestSetValue(t *testing.T) {
+	for i, tt := range valueTests {
+		v := NewValue(tt.i)
+		switch v := v.(type) {
+		case *IntValue:
+			switch v.Type().Kind() {
+			case Int:
+				v.SetValue(NewValue(int(132)))
+			case Int8:
+				v.SetValue(NewValue(int8(8)))
+			case Int16:
+				v.SetValue(NewValue(int16(16)))
+			case Int32:
+				v.SetValue(NewValue(int32(32)))
+			case Int64:
+				v.SetValue(NewValue(int64(64)))
+			}
+		case *UintValue:
+			switch v.Type().Kind() {
+			case Uint:
+				v.SetValue(NewValue(uint(132)))
+			case Uint8:
+				v.SetValue(NewValue(uint8(8)))
+			case Uint16:
+				v.SetValue(NewValue(uint16(16)))
+			case Uint32:
+				v.SetValue(NewValue(uint32(32)))
+			case Uint64:
+				v.SetValue(NewValue(uint64(64)))
+			}
+		case *FloatValue:
+			switch v.Type().Kind() {
+			case Float32:
+				v.SetValue(NewValue(float32(256.25)))
+			case Float64:
+				v.SetValue(NewValue(512.125))
+			}
+		case *ComplexValue:
+			switch v.Type().Kind() {
+			case Complex64:
+				v.SetValue(NewValue(complex64(532.125 + 10i)))
+			case Complex128:
+				v.SetValue(NewValue(complex128(564.25 + 1i)))
+			}
+
+		case *StringValue:
+			v.SetValue(NewValue("stringy cheese"))
+		case *BoolValue:
+			v.SetValue(NewValue(true))
+		}
+		s := valueToString(v)
+		if s != tt.s {
+			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
+		}
+	}
+}
+
+var _i = 7
+
+var valueToStringTests = []pair{
+	{123, "123"},
+	{123.5, "123.5"},
+	{byte(123), "123"},
+	{"abc", "abc"},
+	{T{123, 456.75, "hello", &_i}, "reflect_test.T{123, 456.75, hello, *int(&7)}"},
+	{new(chan *T), "*chan *reflect_test.T(&chan *reflect_test.T)"},
+	{[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
+	{&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[10]int(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
+	{[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
+	{&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[]int(&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
+}
+
+func TestValueToString(t *testing.T) {
+	for i, test := range valueToStringTests {
+		s := valueToString(NewValue(test.i))
+		if s != test.s {
+			t.Errorf("#%d: have %#q, want %#q", i, s, test.s)
+		}
+	}
+}
+
+func TestArrayElemSet(t *testing.T) {
+	v := NewValue([10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
+	v.(*ArrayValue).Elem(4).(*IntValue).Set(123)
+	s := valueToString(v)
+	const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
+	if s != want {
+		t.Errorf("[10]int: have %#q want %#q", s, want)
+	}
+
+	v = NewValue([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
+	v.(*SliceValue).Elem(4).(*IntValue).Set(123)
+	s = valueToString(v)
+	const want1 = "[]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
+	if s != want1 {
+		t.Errorf("[]int: have %#q want %#q", s, want1)
+	}
+}
+
+func TestPtrPointTo(t *testing.T) {
+	var ip *int32
+	var i int32 = 1234
+	vip := NewValue(&ip)
+	vi := NewValue(i)
+	vip.(*PtrValue).Elem().(*PtrValue).PointTo(vi)
+	if *ip != 1234 {
+		t.Errorf("got %d, want 1234", *ip)
+	}
+
+	ip = nil
+	vp := NewValue(ip).(*PtrValue)
+	vp.PointTo(vp.Elem())
+	if ip != nil {
+		t.Errorf("got non-nil (%p), want nil", ip)
+	}
+}
+
+func TestPtrSetNil(t *testing.T) {
+	var i int32 = 1234
+	ip := &i
+	vip := NewValue(&ip)
+	vip.(*PtrValue).Elem().(*PtrValue).Set(nil)
+	if ip != nil {
+		t.Errorf("got non-nil (%d), want nil", *ip)
+	}
+}
+
+func TestMapSetNil(t *testing.T) {
+	m := make(map[string]int)
+	vm := NewValue(&m)
+	vm.(*PtrValue).Elem().(*MapValue).Set(nil)
+	if m != nil {
+		t.Errorf("got non-nil (%p), want nil", m)
+	}
+}
+
+
+func TestAll(t *testing.T) {
+	testType(t, 1, Typeof((int8)(0)), "int8")
+	testType(t, 2, Typeof((*int8)(nil)).(*PtrType).Elem(), "int8")
+
+	typ := Typeof((*struct {
+		c chan *int32
+		d float32
+	})(nil))
+	testType(t, 3, typ, "*struct { c chan *int32; d float32 }")
+	etyp := typ.(*PtrType).Elem()
+	testType(t, 4, etyp, "struct { c chan *int32; d float32 }")
+	styp := etyp.(*StructType)
+	f := styp.Field(0)
+	testType(t, 5, f.Type, "chan *int32")
+
+	f, present := styp.FieldByName("d")
+	if !present {
+		t.Errorf("FieldByName says present field is absent")
+	}
+	testType(t, 6, f.Type, "float32")
+
+	f, present = styp.FieldByName("absent")
+	if present {
+		t.Errorf("FieldByName says absent field is present")
+	}
+
+	typ = Typeof([32]int32{})
+	testType(t, 7, typ, "[32]int32")
+	testType(t, 8, typ.(*ArrayType).Elem(), "int32")
+
+	typ = Typeof((map[string]*int32)(nil))
+	testType(t, 9, typ, "map[string] *int32")
+	mtyp := typ.(*MapType)
+	testType(t, 10, mtyp.Key(), "string")
+	testType(t, 11, mtyp.Elem(), "*int32")
+
+	typ = Typeof((chan<- string)(nil))
+	testType(t, 12, typ, "chan<- string")
+	testType(t, 13, typ.(*ChanType).Elem(), "string")
+
+	// make sure tag strings are not part of element type
+	typ = Typeof(struct {
+		d []uint32 "TAG"
+	}{}).(*StructType).Field(0).Type
+	testType(t, 14, typ, "[]uint32")
+}
+
+func TestInterfaceGet(t *testing.T) {
+	var inter struct {
+		e interface{}
+	}
+	inter.e = 123.456
+	v1 := NewValue(&inter)
+	v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0)
+	assert(t, v2.Type().String(), "interface { }")
+	i2 := v2.(*InterfaceValue).Interface()
+	v3 := NewValue(i2)
+	assert(t, v3.Type().String(), "float64")
+}
+
+func TestInterfaceValue(t *testing.T) {
+	var inter struct {
+		e interface{}
+	}
+	inter.e = 123.456
+	v1 := NewValue(&inter)
+	v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0)
+	assert(t, v2.Type().String(), "interface { }")
+	v3 := v2.(*InterfaceValue).Elem()
+	assert(t, v3.Type().String(), "float64")
+
+	i3 := v2.Interface()
+	if _, ok := i3.(float64); !ok {
+		t.Error("v2.Interface() did not return float64, got ", Typeof(i3))
+	}
+}
+
+func TestFunctionValue(t *testing.T) {
+	v := NewValue(func() {})
+	if v.Interface() != v.Interface() {
+		t.Fatalf("TestFunction != itself")
+	}
+	assert(t, v.Type().String(), "func()")
+}
+
+var appendTests = []struct {
+	orig, extra []int
+}{
+	{make([]int, 2, 4), []int{22}},
+	{make([]int, 2, 4), []int{22, 33, 44}},
+}
+
+func TestAppend(t *testing.T) {
+	for i, test := range appendTests {
+		origLen, extraLen := len(test.orig), len(test.extra)
+		want := append(test.orig, test.extra...)
+		// Convert extra from []int to []Value.
+		e0 := make([]Value, len(test.extra))
+		for j, e := range test.extra {
+			e0[j] = NewValue(e)
+		}
+		// Convert extra from []int to *SliceValue.
+		e1 := NewValue(test.extra).(*SliceValue)
+		// Test Append.
+		a0 := NewValue(test.orig).(*SliceValue)
+		have0 := Append(a0, e0...).Interface().([]int)
+		if !DeepEqual(have0, want) {
+			t.Errorf("Append #%d: have %v, want %v", i, have0, want)
+		}
+		// Check that the orig and extra slices were not modified.
+		if len(test.orig) != origLen {
+			t.Errorf("Append #%d origLen: have %v, want %v", i, len(test.orig), origLen)
+		}
+		if len(test.extra) != extraLen {
+			t.Errorf("Append #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
+		}
+		// Test AppendSlice.
+		a1 := NewValue(test.orig).(*SliceValue)
+		have1 := AppendSlice(a1, e1).Interface().([]int)
+		if !DeepEqual(have1, want) {
+			t.Errorf("AppendSlice #%d: have %v, want %v", i, have1, want)
+		}
+		// Check that the orig and extra slices were not modified.
+		if len(test.orig) != origLen {
+			t.Errorf("AppendSlice #%d origLen: have %v, want %v", i, len(test.orig), origLen)
+		}
+		if len(test.extra) != extraLen {
+			t.Errorf("AppendSlice #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
+		}
+	}
+}
+
+func TestCopy(t *testing.T) {
+	a := []int{1, 2, 3, 4, 10, 9, 8, 7}
+	b := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
+	c := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
+	for i := 0; i < len(b); i++ {
+		if b[i] != c[i] {
+			t.Fatalf("b != c before test")
+		}
+	}
+	aa := NewValue(a).(*SliceValue)
+	ab := NewValue(b).(*SliceValue)
+	for tocopy := 1; tocopy <= 7; tocopy++ {
+		aa.SetLen(tocopy)
+		Copy(ab, aa)
+		aa.SetLen(8)
+		for i := 0; i < tocopy; i++ {
+			if a[i] != b[i] {
+				t.Errorf("(i) tocopy=%d a[%d]=%d, b[%d]=%d",
+					tocopy, i, a[i], i, b[i])
+			}
+		}
+		for i := tocopy; i < len(b); i++ {
+			if b[i] != c[i] {
+				if i < len(a) {
+					t.Errorf("(ii) tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d",
+						tocopy, i, a[i], i, b[i], i, c[i])
+				} else {
+					t.Errorf("(iii) tocopy=%d b[%d]=%d, c[%d]=%d",
+						tocopy, i, b[i], i, c[i])
+				}
+			} else {
+				t.Logf("tocopy=%d elem %d is okay\n", tocopy, i)
+			}
+		}
+	}
+}
+
+func TestBigUnnamedStruct(t *testing.T) {
+	b := struct{ a, b, c, d int64 }{1, 2, 3, 4}
+	v := NewValue(b)
+	b1 := v.Interface().(struct {
+		a, b, c, d int64
+	})
+	if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d {
+		t.Errorf("NewValue(%v).Interface().(*Big) = %v", b, b1)
+	}
+}
+
+type big struct {
+	a, b, c, d, e int64
+}
+
+func TestBigStruct(t *testing.T) {
+	b := big{1, 2, 3, 4, 5}
+	v := NewValue(b)
+	b1 := v.Interface().(big)
+	if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e {
+		t.Errorf("NewValue(%v).Interface().(big) = %v", b, b1)
+	}
+}
+
+type Basic struct {
+	x int
+	y float32
+}
+
+type NotBasic Basic
+
+type DeepEqualTest struct {
+	a, b interface{}
+	eq   bool
+}
+
+var deepEqualTests = []DeepEqualTest{
+	// Equalities
+	{1, 1, true},
+	{int32(1), int32(1), true},
+	{0.5, 0.5, true},
+	{float32(0.5), float32(0.5), true},
+	{"hello", "hello", true},
+	{make([]int, 10), make([]int, 10), true},
+	{&[3]int{1, 2, 3}, &[3]int{1, 2, 3}, true},
+	{Basic{1, 0.5}, Basic{1, 0.5}, true},
+	{os.Error(nil), os.Error(nil), true},
+	{map[int]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, true},
+
+	// Inequalities
+	{1, 2, false},
+	{int32(1), int32(2), false},
+	{0.5, 0.6, false},
+	{float32(0.5), float32(0.6), false},
+	{"hello", "hey", false},
+	{make([]int, 10), make([]int, 11), false},
+	{&[3]int{1, 2, 3}, &[3]int{1, 2, 4}, false},
+	{Basic{1, 0.5}, Basic{1, 0.6}, false},
+	{Basic{1, 0}, Basic{2, 0}, false},
+	{map[int]string{1: "one", 3: "two"}, map[int]string{2: "two", 1: "one"}, false},
+	{map[int]string{1: "one", 2: "txo"}, map[int]string{2: "two", 1: "one"}, false},
+	{map[int]string{1: "one"}, map[int]string{2: "two", 1: "one"}, false},
+	{map[int]string{2: "two", 1: "one"}, map[int]string{1: "one"}, false},
+	{nil, 1, false},
+	{1, nil, false},
+
+	// Mismatched types
+	{1, 1.0, false},
+	{int32(1), int64(1), false},
+	{0.5, "hello", false},
+	{[]int{1, 2, 3}, [3]int{1, 2, 3}, false},
+	{&[3]interface{}{1, 2, 4}, &[3]interface{}{1, 2, "s"}, false},
+	{Basic{1, 0.5}, NotBasic{1, 0.5}, false},
+	{map[uint]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, false},
+}
+
+func TestDeepEqual(t *testing.T) {
+	for _, test := range deepEqualTests {
+		if r := DeepEqual(test.a, test.b); r != test.eq {
+			t.Errorf("DeepEqual(%v, %v) = %v, want %v", test.a, test.b, r, test.eq)
+		}
+	}
+}
+
+func TestTypeof(t *testing.T) {
+	for _, test := range deepEqualTests {
+		v := NewValue(test.a)
+		if v == nil {
+			continue
+		}
+		typ := Typeof(test.a)
+		if typ != v.Type() {
+			t.Errorf("Typeof(%v) = %v, but NewValue(%v).Type() = %v", test.a, typ, test.a, v.Type())
+		}
+	}
+}
+
+type Recursive struct {
+	x int
+	r *Recursive
+}
+
+func TestDeepEqualRecursiveStruct(t *testing.T) {
+	a, b := new(Recursive), new(Recursive)
+	*a = Recursive{12, a}
+	*b = Recursive{12, b}
+	if !DeepEqual(a, b) {
+		t.Error("DeepEqual(recursive same) = false, want true")
+	}
+}
+
+type _Complex struct {
+	a int
+	b [3]*_Complex
+	c *string
+	d map[float64]float64
+}
+
+func TestDeepEqualComplexStruct(t *testing.T) {
+	m := make(map[float64]float64)
+	stra, strb := "hello", "hello"
+	a, b := new(_Complex), new(_Complex)
+	*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
+	*b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
+	if !DeepEqual(a, b) {
+		t.Error("DeepEqual(complex same) = false, want true")
+	}
+}
+
+func TestDeepEqualComplexStructInequality(t *testing.T) {
+	m := make(map[float64]float64)
+	stra, strb := "hello", "helloo" // Difference is here
+	a, b := new(_Complex), new(_Complex)
+	*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
+	*b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
+	if DeepEqual(a, b) {
+		t.Error("DeepEqual(complex different) = true, want false")
+	}
+}
+
+
+func check2ndField(x interface{}, offs uintptr, t *testing.T) {
+	s := NewValue(x).(*StructValue)
+	f := s.Type().(*StructType).Field(1)
+	if f.Offset != offs {
+		t.Error("mismatched offsets in structure alignment:", f.Offset, offs)
+	}
+}
+
+// Check that structure alignment & offsets viewed through reflect agree with those
+// from the compiler itself.
+func TestAlignment(t *testing.T) {
+	type T1inner struct {
+		a int
+	}
+	type T1 struct {
+		T1inner
+		f int
+	}
+	type T2inner struct {
+		a, b int
+	}
+	type T2 struct {
+		T2inner
+		f int
+	}
+
+	x := T1{T1inner{2}, 17}
+	check2ndField(x, uintptr(unsafe.Pointer(&x.f))-uintptr(unsafe.Pointer(&x)), t)
+
+	x1 := T2{T2inner{2, 3}, 17}
+	check2ndField(x1, uintptr(unsafe.Pointer(&x1.f))-uintptr(unsafe.Pointer(&x1)), t)
+}
+
+type IsNiller interface {
+	IsNil() bool
+}
+
+func Nil(a interface{}, t *testing.T) {
+	n := NewValue(a).(*StructValue).Field(0).(IsNiller)
+	if !n.IsNil() {
+		t.Errorf("%v should be nil", a)
+	}
+}
+
+func NotNil(a interface{}, t *testing.T) {
+	n := NewValue(a).(*StructValue).Field(0).(IsNiller)
+	if n.IsNil() {
+		t.Errorf("value of type %v should not be nil", NewValue(a).Type().String())
+	}
+}
+
+func TestIsNil(t *testing.T) {
+	// These do not implement IsNil
+	doNotNil := []interface{}{int(0), float32(0), struct{ a int }{}}
+	for _, ts := range doNotNil {
+		ty := Typeof(ts)
+		v := MakeZero(ty)
+		if _, ok := v.(IsNiller); ok {
+			t.Errorf("%s is nilable; should not be", ts)
+		}
+	}
+
+	// These do implement IsNil.
+	// Wrap in extra struct to hide interface type.
+	doNil := []interface{}{
+		struct{ x *int }{},
+		struct{ x interface{} }{},
+		struct{ x map[string]int }{},
+		struct{ x func() bool }{},
+		struct{ x chan int }{},
+		struct{ x []string }{},
+	}
+	for _, ts := range doNil {
+		ty := Typeof(ts).(*StructType).Field(0).Type
+		v := MakeZero(ty)
+		if _, ok := v.(IsNiller); !ok {
+			t.Errorf("%s %T is not nilable; should be", ts, v)
+		}
+	}
+
+	// Check the implementations
+	var pi struct {
+		x *int
+	}
+	Nil(pi, t)
+	pi.x = new(int)
+	NotNil(pi, t)
+
+	var si struct {
+		x []int
+	}
+	Nil(si, t)
+	si.x = make([]int, 10)
+	NotNil(si, t)
+
+	var ci struct {
+		x chan int
+	}
+	Nil(ci, t)
+	ci.x = make(chan int)
+	NotNil(ci, t)
+
+	var mi struct {
+		x map[int]int
+	}
+	Nil(mi, t)
+	mi.x = make(map[int]int)
+	NotNil(mi, t)
+
+	var ii struct {
+		x interface{}
+	}
+	Nil(ii, t)
+	ii.x = 2
+	NotNil(ii, t)
+
+	var fi struct {
+		x func(t *testing.T)
+	}
+	Nil(fi, t)
+	fi.x = TestIsNil
+	NotNil(fi, t)
+}
+
+func TestInterfaceExtraction(t *testing.T) {
+	var s struct {
+		w io.Writer
+	}
+
+	s.w = os.Stdout
+	v := Indirect(NewValue(&s)).(*StructValue).Field(0).Interface()
+	if v != s.w.(interface{}) {
+		t.Error("Interface() on interface: ", v, s.w)
+	}
+}
+
+func TestInterfaceEditing(t *testing.T) {
+	// strings are bigger than one word,
+	// so the interface conversion allocates
+	// memory to hold a string and puts that
+	// pointer in the interface.
+	var i interface{} = "hello"
+
+	// if i pass the interface value by value
+	// to NewValue, i should get a fresh copy
+	// of the value.
+	v := NewValue(i)
+
+	// and setting that copy to "bye" should
+	// not change the value stored in i.
+	v.(*StringValue).Set("bye")
+	if i.(string) != "hello" {
+		t.Errorf(`Set("bye") changed i to %s`, i.(string))
+	}
+
+	// the same should be true of smaller items.
+	i = 123
+	v = NewValue(i)
+	v.(*IntValue).Set(234)
+	if i.(int) != 123 {
+		t.Errorf("Set(234) changed i to %d", i.(int))
+	}
+}
+
+func TestNilPtrValueSub(t *testing.T) {
+	var pi *int
+	if pv := NewValue(pi).(*PtrValue); pv.Elem() != nil {
+		t.Error("NewValue((*int)(nil)).(*PtrValue).Elem() != nil")
+	}
+}
+
+func TestMap(t *testing.T) {
+	m := map[string]int{"a": 1, "b": 2}
+	mv := NewValue(m).(*MapValue)
+	if n := mv.Len(); n != len(m) {
+		t.Errorf("Len = %d, want %d", n, len(m))
+	}
+	keys := mv.Keys()
+	i := 0
+	newmap := MakeMap(mv.Type().(*MapType))
+	for k, v := range m {
+		// Check that returned Keys match keys in range.
+		// These aren't required to be in the same order,
+		// but they are in this implementation, which makes
+		// the test easier.
+		if i >= len(keys) {
+			t.Errorf("Missing key #%d %q", i, k)
+		} else if kv := keys[i].(*StringValue); kv.Get() != k {
+			t.Errorf("Keys[%d] = %q, want %q", i, kv.Get(), k)
+		}
+		i++
+
+		// Check that value lookup is correct.
+		vv := mv.Elem(NewValue(k))
+		if vi := vv.(*IntValue).Get(); vi != int64(v) {
+			t.Errorf("Key %q: have value %d, want %d", k, vi, v)
+		}
+
+		// Copy into new map.
+		newmap.SetElem(NewValue(k), NewValue(v))
+	}
+	vv := mv.Elem(NewValue("not-present"))
+	if vv != nil {
+		t.Errorf("Invalid key: got non-nil value %s", valueToString(vv))
+	}
+
+	newm := newmap.Interface().(map[string]int)
+	if len(newm) != len(m) {
+		t.Errorf("length after copy: newm=%d, m=%d", newm, m)
+	}
+
+	for k, v := range newm {
+		mv, ok := m[k]
+		if mv != v {
+			t.Errorf("newm[%q] = %d, but m[%q] = %d, %v", k, v, k, mv, ok)
+		}
+	}
+
+	newmap.SetElem(NewValue("a"), nil)
+	v, ok := newm["a"]
+	if ok {
+		t.Errorf("newm[\"a\"] = %d after delete", v)
+	}
+
+	mv = NewValue(&m).(*PtrValue).Elem().(*MapValue)
+	mv.Set(nil)
+	if m != nil {
+		t.Errorf("mv.Set(nil) failed")
+	}
+}
+
+func TestChan(t *testing.T) {
+	for loop := 0; loop < 2; loop++ {
+		var c chan int
+		var cv *ChanValue
+
+		// check both ways to allocate channels
+		switch loop {
+		case 1:
+			c = make(chan int, 1)
+			cv = NewValue(c).(*ChanValue)
+		case 0:
+			cv = MakeChan(Typeof(c).(*ChanType), 1)
+			c = cv.Interface().(chan int)
+		}
+
+		// Send
+		cv.Send(NewValue(2))
+		if i := <-c; i != 2 {
+			t.Errorf("reflect Send 2, native recv %d", i)
+		}
+
+		// Recv
+		c <- 3
+		if i := cv.Recv().(*IntValue).Get(); i != 3 {
+			t.Errorf("native send 3, reflect Recv %d", i)
+		}
+
+		// TryRecv fail
+		val := cv.TryRecv()
+		if val != nil {
+			t.Errorf("TryRecv on empty chan: %s", valueToString(val))
+		}
+
+		// TryRecv success
+		c <- 4
+		val = cv.TryRecv()
+		if val == nil {
+			t.Errorf("TryRecv on ready chan got nil")
+		} else if i := val.(*IntValue).Get(); i != 4 {
+			t.Errorf("native send 4, TryRecv %d", i)
+		}
+
+		// TrySend fail
+		c <- 100
+		ok := cv.TrySend(NewValue(5))
+		i := <-c
+		if ok {
+			t.Errorf("TrySend on full chan succeeded: value %d", i)
+		}
+
+		// TrySend success
+		ok = cv.TrySend(NewValue(6))
+		if !ok {
+			t.Errorf("TrySend on empty chan failed")
+		} else {
+			if i = <-c; i != 6 {
+				t.Errorf("TrySend 6, recv %d", i)
+			}
+		}
+
+		// Close
+		c <- 123
+		cv.Close()
+		if cv.Closed() {
+			t.Errorf("closed too soon - 1")
+		}
+		if i := cv.Recv().(*IntValue).Get(); i != 123 {
+			t.Errorf("send 123 then close; Recv %d", i)
+		}
+		if cv.Closed() {
+			t.Errorf("closed too soon - 2")
+		}
+		if i := cv.Recv().(*IntValue).Get(); i != 0 {
+			t.Errorf("after close Recv %d", i)
+		}
+		if !cv.Closed() {
+			t.Errorf("not closed")
+		}
+	}
+
+	// check creation of unbuffered channel
+	var c chan int
+	cv := MakeChan(Typeof(c).(*ChanType), 0)
+	c = cv.Interface().(chan int)
+	if cv.TrySend(NewValue(7)) {
+		t.Errorf("TrySend on sync chan succeeded")
+	}
+	if cv.TryRecv() != nil {
+		t.Errorf("TryRecv on sync chan succeeded")
+	}
+
+	// len/cap
+	cv = MakeChan(Typeof(c).(*ChanType), 10)
+	c = cv.Interface().(chan int)
+	for i := 0; i < 3; i++ {
+		c <- i
+	}
+	if l, m := cv.Len(), cv.Cap(); l != len(c) || m != cap(c) {
+		t.Errorf("Len/Cap = %d/%d want %d/%d", l, m, len(c), cap(c))
+	}
+
+}
+
+// Difficult test for function call because of
+// implicit padding between arguments.
+func dummy(b byte, c int, d byte) (i byte, j int, k byte) {
+	return b, c, d
+}
+
+func TestFunc(t *testing.T) {
+	ret := NewValue(dummy).(*FuncValue).Call([]Value{NewValue(byte(10)), NewValue(20), NewValue(byte(30))})
+	if len(ret) != 3 {
+		t.Fatalf("Call returned %d values, want 3", len(ret))
+	}
+
+	i := ret[0].(*UintValue).Get()
+	j := ret[1].(*IntValue).Get()
+	k := ret[2].(*UintValue).Get()
+	if i != 10 || j != 20 || k != 30 {
+		t.Errorf("Call returned %d, %d, %d; want 10, 20, 30", i, j, k)
+	}
+}
+
+type Point struct {
+	x, y int
+}
+
+func (p Point) Dist(scale int) int { return p.x*p.x*scale + p.y*p.y*scale }
+
+func TestMethod(t *testing.T) {
+	// Non-curried method of type.
+	p := Point{3, 4}
+	i := Typeof(p).Method(0).Func.Call([]Value{NewValue(p), NewValue(10)})[0].(*IntValue).Get()
+	if i != 250 {
+		t.Errorf("Type Method returned %d; want 250", i)
+	}
+
+	i = Typeof(&p).Method(0).Func.Call([]Value{NewValue(&p), NewValue(10)})[0].(*IntValue).Get()
+	if i != 250 {
+		t.Errorf("Pointer Type Method returned %d; want 250", i)
+	}
+
+	// Curried method of value.
+	i = NewValue(p).Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get()
+	if i != 250 {
+		t.Errorf("Value Method returned %d; want 250", i)
+	}
+
+	// Curried method of interface value.
+	// Have to wrap interface value in a struct to get at it.
+	// Passing it to NewValue directly would
+	// access the underlying Point, not the interface.
+	var s = struct {
+		x interface {
+			Dist(int) int
+		}
+	}{p}
+	pv := NewValue(s).(*StructValue).Field(0)
+	i = pv.Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get()
+	if i != 250 {
+		t.Errorf("Interface Method returned %d; want 250", i)
+	}
+}
+
+func TestInterfaceSet(t *testing.T) {
+	p := &Point{3, 4}
+
+	var s struct {
+		I interface{}
+		P interface {
+			Dist(int) int
+		}
+	}
+	sv := NewValue(&s).(*PtrValue).Elem().(*StructValue)
+	sv.Field(0).(*InterfaceValue).Set(NewValue(p))
+	if q := s.I.(*Point); q != p {
+		t.Errorf("i: have %p want %p", q, p)
+	}
+
+	pv := sv.Field(1).(*InterfaceValue)
+	pv.Set(NewValue(p))
+	if q := s.P.(*Point); q != p {
+		t.Errorf("i: have %p want %p", q, p)
+	}
+
+	i := pv.Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get()
+	if i != 250 {
+		t.Errorf("Interface Method returned %d; want 250", i)
+	}
+}
+
+type T1 struct {
+	a string
+	int
+}
+
+func TestAnonymousFields(t *testing.T) {
+	var field StructField
+	var ok bool
+	var t1 T1
+	type1 := Typeof(t1).(*StructType)
+	if field, ok = type1.FieldByName("int"); !ok {
+		t.Error("no field 'int'")
+	}
+	if field.Index[0] != 1 {
+		t.Error("field index should be 1; is", field.Index)
+	}
+}
+
+type FTest struct {
+	s     interface{}
+	name  string
+	index []int
+	value int
+}
+
+type D1 struct {
+	d int
+}
+type D2 struct {
+	d int
+}
+
+type S0 struct {
+	a, b, c int
+	D1
+	D2
+}
+
+type S1 struct {
+	b int
+	S0
+}
+
+type S2 struct {
+	a int
+	*S1
+}
+
+type S1x struct {
+	S1
+}
+
+type S1y struct {
+	S1
+}
+
+type S3 struct {
+	S1x
+	S2
+	d, e int
+	*S1y
+}
+
+type S4 struct {
+	*S4
+	a int
+}
+
+var fieldTests = []FTest{
+	{struct{}{}, "", nil, 0},
+	{struct{}{}, "foo", nil, 0},
+	{S0{a: 'a'}, "a", []int{0}, 'a'},
+	{S0{}, "d", nil, 0},
+	{S1{S0: S0{a: 'a'}}, "a", []int{1, 0}, 'a'},
+	{S1{b: 'b'}, "b", []int{0}, 'b'},
+	{S1{}, "S0", []int{1}, 0},
+	{S1{S0: S0{c: 'c'}}, "c", []int{1, 2}, 'c'},
+	{S2{a: 'a'}, "a", []int{0}, 'a'},
+	{S2{}, "S1", []int{1}, 0},
+	{S2{S1: &S1{b: 'b'}}, "b", []int{1, 0}, 'b'},
+	{S2{S1: &S1{S0: S0{c: 'c'}}}, "c", []int{1, 1, 2}, 'c'},
+	{S2{}, "d", nil, 0},
+	{S3{}, "S1", nil, 0},
+	{S3{S2: S2{a: 'a'}}, "a", []int{1, 0}, 'a'},
+	{S3{}, "b", nil, 0},
+	{S3{d: 'd'}, "d", []int{2}, 0},
+	{S3{e: 'e'}, "e", []int{3}, 'e'},
+	{S4{a: 'a'}, "a", []int{1}, 'a'},
+	{S4{}, "b", nil, 0},
+}
+
+func TestFieldByIndex(t *testing.T) {
+	for _, test := range fieldTests {
+		s := Typeof(test.s).(*StructType)
+		f := s.FieldByIndex(test.index)
+		if f.Name != "" {
+			if test.index != nil {
+				if f.Name != test.name {
+					t.Errorf("%s.%s found; want %s", s.Name(), f.Name, test.name)
+				}
+			} else {
+				t.Errorf("%s.%s found", s.Name(), f.Name)
+			}
+		} else if len(test.index) > 0 {
+			t.Errorf("%s.%s not found", s.Name(), test.name)
+		}
+
+		if test.value != 0 {
+			v := NewValue(test.s).(*StructValue).FieldByIndex(test.index)
+			if v != nil {
+				if x, ok := v.Interface().(int); ok {
+					if x != test.value {
+						t.Errorf("%s%v is %d; want %d", s.Name(), test.index, x, test.value)
+					}
+				} else {
+					t.Errorf("%s%v value not an int", s.Name(), test.index)
+				}
+			} else {
+				t.Errorf("%s%v value not found", s.Name(), test.index)
+			}
+		}
+	}
+}
+
+func TestFieldByName(t *testing.T) {
+	for _, test := range fieldTests {
+		s := Typeof(test.s).(*StructType)
+		f, found := s.FieldByName(test.name)
+		if found {
+			if test.index != nil {
+				// Verify field depth and index.
+				if len(f.Index) != len(test.index) {
+					t.Errorf("%s.%s depth %d; want %d", s.Name(), test.name, len(f.Index), len(test.index))
+				} else {
+					for i, x := range f.Index {
+						if x != test.index[i] {
+							t.Errorf("%s.%s.Index[%d] is %d; want %d", s.Name(), test.name, i, x, test.index[i])
+						}
+					}
+				}
+			} else {
+				t.Errorf("%s.%s found", s.Name(), f.Name)
+			}
+		} else if len(test.index) > 0 {
+			t.Errorf("%s.%s not found", s.Name(), test.name)
+		}
+
+		if test.value != 0 {
+			v := NewValue(test.s).(*StructValue).FieldByName(test.name)
+			if v != nil {
+				if x, ok := v.Interface().(int); ok {
+					if x != test.value {
+						t.Errorf("%s.%s is %d; want %d", s.Name(), test.name, x, test.value)
+					}
+				} else {
+					t.Errorf("%s.%s value not an int", s.Name(), test.name)
+				}
+			} else {
+				t.Errorf("%s.%s value not found", s.Name(), test.name)
+			}
+		}
+	}
+}
+
+func TestImportPath(t *testing.T) {
+	if path := Typeof(vector.Vector{}).PkgPath(); path != "libgo_container.vector" {
+		t.Errorf("Typeof(vector.Vector{}).PkgPath() = %q, want \"libgo_container.vector\"", path)
+	}
+}
+
+func TestDotDotDot(t *testing.T) {
+	// Test example from FuncType.DotDotDot documentation.
+	var f func(x int, y ...float64)
+	typ := Typeof(f).(*FuncType)
+	if typ.NumIn() == 2 && typ.In(0) == Typeof(int(0)) {
+		sl, ok := typ.In(1).(*SliceType)
+		if ok {
+			if sl.Elem() == Typeof(0.0) {
+				// ok
+				return
+			}
+		}
+	}
+
+	// Failed
+	t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float64")
+	s := fmt.Sprintf("have NumIn() = %d", typ.NumIn())
+	for i := 0; i < typ.NumIn(); i++ {
+		s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i))
+	}
+	t.Error(s)
+}
+
+type inner struct {
+	x int
+}
+
+type outer struct {
+	y int
+	inner
+}
+
+func (*inner) m() {}
+func (*outer) m() {}
+
+func TestNestedMethods(t *testing.T) {
+	typ := Typeof((*outer)(nil))
+	if typ.NumMethod() != 1 || typ.Method(0).Func.Get() != NewValue((*outer).m).(*FuncValue).Get() {
+		t.Errorf("Wrong method table for outer: (m=%p)", (*outer).m)
+		for i := 0; i < typ.NumMethod(); i++ {
+			m := typ.Method(i)
+			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Get())
+		}
+	}
+}
+
+type innerInt struct {
+	x int
+}
+
+type outerInt struct {
+	y int
+	innerInt
+}
+
+func (i *innerInt) m() int {
+	return i.x
+}
+
+func TestEmbeddedMethods(t *testing.T) {
+	typ := Typeof((*outerInt)(nil))
+	if typ.NumMethod() != 1 || typ.Method(0).Func.Get() != NewValue((*outerInt).m).(*FuncValue).Get() {
+		t.Errorf("Wrong method table for outerInt: (m=%p)", (*outerInt).m)
+		for i := 0; i < typ.NumMethod(); i++ {
+			m := typ.Method(i)
+			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Get())
+		}
+	}
+
+	i := &innerInt{3}
+	if v := NewValue(i).Method(0).Call(nil)[0].(*IntValue).Get(); v != 3 {
+		t.Errorf("i.m() = %d, want 3", v)
+	}
+
+	o := &outerInt{1, innerInt{2}}
+	if v := NewValue(o).Method(0).Call(nil)[0].(*IntValue).Get(); v != 2 {
+		t.Errorf("i.m() = %d, want 2", v)
+	}
+
+	f := (*outerInt).m
+	if v := f(o); v != 2 {
+		t.Errorf("f(o) = %d, want 2", v)
+	}
+}
diff --git a/libgo/go/reflect/deepequal.go b/libgo/go/reflect/deepequal.go
new file mode 100644
index 000000000..a50925e51
--- /dev/null
+++ b/libgo/go/reflect/deepequal.go
@@ -0,0 +1,135 @@
+// 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.
+
+// Deep equality test via reflection
+
+package reflect
+
+
+// During deepValueEqual, must keep track of checks that are
+// in progress.  The comparison algorithm assumes that all
+// checks in progress are true when it reencounters them.
+// Visited are stored in a map indexed by 17 * a1 + a2;
+type visit struct {
+	a1   uintptr
+	a2   uintptr
+	typ  Type
+	next *visit
+}
+
+// Tests for deep equality using reflected types. The map argument tracks
+// comparisons that have already been seen, which allows short circuiting on
+// recursive types.
+func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool {
+	if v1 == nil || v2 == nil {
+		return v1 == v2
+	}
+	if v1.Type() != v2.Type() {
+		return false
+	}
+
+	// if depth > 10 { panic("deepValueEqual") }	// for debugging
+
+	addr1 := v1.Addr()
+	addr2 := v2.Addr()
+	if addr1 > addr2 {
+		// Canonicalize order to reduce number of entries in visited.
+		addr1, addr2 = addr2, addr1
+	}
+
+	// Short circuit if references are identical ...
+	if addr1 == addr2 {
+		return true
+	}
+
+	// ... or already seen
+	h := 17*addr1 + addr2
+	seen := visited[h]
+	typ := v1.Type()
+	for p := seen; p != nil; p = p.next {
+		if p.a1 == addr1 && p.a2 == addr2 && p.typ == typ {
+			return true
+		}
+	}
+
+	// Remember for later.
+	visited[h] = &visit{addr1, addr2, typ, seen}
+
+	switch v := v1.(type) {
+	case *ArrayValue:
+		arr1 := v
+		arr2 := v2.(*ArrayValue)
+		if arr1.Len() != arr2.Len() {
+			return false
+		}
+		for i := 0; i < arr1.Len(); i++ {
+			if !deepValueEqual(arr1.Elem(i), arr2.Elem(i), visited, depth+1) {
+				return false
+			}
+		}
+		return true
+	case *SliceValue:
+		arr1 := v
+		arr2 := v2.(*SliceValue)
+		if arr1.Len() != arr2.Len() {
+			return false
+		}
+		for i := 0; i < arr1.Len(); i++ {
+			if !deepValueEqual(arr1.Elem(i), arr2.Elem(i), visited, depth+1) {
+				return false
+			}
+		}
+		return true
+	case *InterfaceValue:
+		i1 := v.Interface()
+		i2 := v2.Interface()
+		if i1 == nil || i2 == nil {
+			return i1 == i2
+		}
+		return deepValueEqual(NewValue(i1), NewValue(i2), visited, depth+1)
+	case *PtrValue:
+		return deepValueEqual(v.Elem(), v2.(*PtrValue).Elem(), visited, depth+1)
+	case *StructValue:
+		struct1 := v
+		struct2 := v2.(*StructValue)
+		for i, n := 0, v.NumField(); i < n; i++ {
+			if !deepValueEqual(struct1.Field(i), struct2.Field(i), visited, depth+1) {
+				return false
+			}
+		}
+		return true
+	case *MapValue:
+		map1 := v
+		map2 := v2.(*MapValue)
+		if map1.Len() != map2.Len() {
+			return false
+		}
+		for _, k := range map1.Keys() {
+			if !deepValueEqual(map1.Elem(k), map2.Elem(k), visited, depth+1) {
+				return false
+			}
+		}
+		return true
+	default:
+		// Normal equality suffices
+		return v1.Interface() == v2.Interface()
+	}
+
+	panic("Not reached")
+}
+
+// DeepEqual tests for deep equality. It uses normal == equality where possible
+// but will scan members of arrays, slices, and fields of structs. It correctly
+// handles recursive types.
+func DeepEqual(a1, a2 interface{}) bool {
+	if a1 == nil || a2 == nil {
+		return a1 == a2
+	}
+	v1 := NewValue(a1)
+	v2 := NewValue(a2)
+	if v1.Type() != v2.Type() {
+		return false
+	}
+	return deepValueEqual(v1, v2, make(map[uintptr]*visit), 0)
+}
diff --git a/libgo/go/reflect/tostring_test.go b/libgo/go/reflect/tostring_test.go
new file mode 100644
index 000000000..a1487fdd2
--- /dev/null
+++ b/libgo/go/reflect/tostring_test.go
@@ -0,0 +1,96 @@
+// 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.
+
+// Formatting of reflection types and values for debugging.
+// Not defined as methods so they do not need to be linked into most binaries;
+// the functions are not used by the library itself, only in tests.
+
+package reflect_test
+
+import (
+	. "reflect"
+	"strconv"
+)
+
+// valueToString returns a textual representation of the reflection value val.
+// For debugging only.
+func valueToString(val Value) string {
+	var str string
+	if val == nil {
+		return "<nil>"
+	}
+	typ := val.Type()
+	switch val := val.(type) {
+	case *IntValue:
+		return strconv.Itoa64(val.Get())
+	case *UintValue:
+		return strconv.Uitoa64(val.Get())
+	case *FloatValue:
+		return strconv.Ftoa64(float64(val.Get()), 'g', -1)
+	case *ComplexValue:
+		c := val.Get()
+		return strconv.Ftoa64(float64(real(c)), 'g', -1) + "+" + strconv.Ftoa64(float64(imag(c)), 'g', -1) + "i"
+	case *StringValue:
+		return val.Get()
+	case *BoolValue:
+		if val.Get() {
+			return "true"
+		} else {
+			return "false"
+		}
+	case *PtrValue:
+		v := val
+		str = typ.String() + "("
+		if v.IsNil() {
+			str += "0"
+		} else {
+			str += "&" + valueToString(v.Elem())
+		}
+		str += ")"
+		return str
+	case ArrayOrSliceValue:
+		v := val
+		str += typ.String()
+		str += "{"
+		for i := 0; i < v.Len(); i++ {
+			if i > 0 {
+				str += ", "
+			}
+			str += valueToString(v.Elem(i))
+		}
+		str += "}"
+		return str
+	case *MapValue:
+		t := typ.(*MapType)
+		str = t.String()
+		str += "{"
+		str += "<can't iterate on maps>"
+		str += "}"
+		return str
+	case *ChanValue:
+		str = typ.String()
+		return str
+	case *StructValue:
+		t := typ.(*StructType)
+		v := val
+		str += t.String()
+		str += "{"
+		for i, n := 0, v.NumField(); i < n; i++ {
+			if i > 0 {
+				str += ", "
+			}
+			str += valueToString(v.Field(i))
+		}
+		str += "}"
+		return str
+	case *InterfaceValue:
+		return typ.String() + "(" + valueToString(val.Elem()) + ")"
+	case *FuncValue:
+		v := val
+		return typ.String() + "(" + strconv.Itoa64(int64(v.Get())) + ")"
+	default:
+		panic("valueToString: can't print type " + typ.String())
+	}
+	return "valueToString: can't happen"
+}
diff --git a/libgo/go/reflect/type.go b/libgo/go/reflect/type.go
new file mode 100644
index 000000000..4ad4c5f2b
--- /dev/null
+++ b/libgo/go/reflect/type.go
@@ -0,0 +1,743 @@
+// 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.
+
+// The reflect package implements run-time reflection, allowing a program to
+// manipulate objects with arbitrary types.  The typical use is to take a
+// value with static type interface{} and extract its dynamic type
+// information by calling Typeof, which returns an object with interface
+// type Type.  That contains a pointer to a struct of type *StructType,
+// *IntType, etc. representing the details of the underlying type.  A type
+// switch or type assertion can reveal which.
+//
+// A call to NewValue creates a Value representing the run-time data; it
+// contains a *StructValue, *IntValue, etc.  MakeZero takes a Type and
+// returns a Value representing a zero value for that type.
+package reflect
+
+import (
+	"runtime"
+	"strconv"
+	"sync"
+	"unsafe"
+)
+
+/*
+ * Copy of data structures from ../runtime/type.go.
+ * For comments, see the ones in that file.
+ *
+ * These data structures are known to the compiler and the runtime.
+ *
+ * Putting these types in runtime instead of reflect means that
+ * reflect doesn't need to be autolinked into every binary, which
+ * simplifies bootstrapping and package dependencies.
+ * Unfortunately, it also means that reflect needs its own
+ * copy in order to access the private fields.
+ */
+
+// commonType is the common implementation of most values.
+// It is embedded in other, public struct types, but always
+// with a unique tag like "uint" or "float" so that the client cannot
+// convert from, say, *UintType to *FloatType.
+
+type commonType struct {
+	kind       uint8
+	align      int8
+	fieldAlign uint8
+	size       uintptr
+	hash	   uint32
+	hashfn     func(unsafe.Pointer, uintptr)
+	equalfn    func(unsafe.Pointer, unsafe.Pointer, uintptr)
+	string     *string
+	*uncommonType
+}
+
+type method struct {
+	name    *string
+	pkgPath *string
+	mtyp    *runtime.Type
+	typ     *runtime.Type
+	tfn     unsafe.Pointer
+}
+
+type uncommonType struct {
+	name    *string
+	pkgPath *string
+	methods []method
+}
+
+// BoolType represents a boolean type.
+type BoolType struct {
+	commonType "bool"
+}
+
+// FloatType represents a float type.
+type FloatType struct {
+	commonType "float"
+}
+
+// ComplexType represents a complex type.
+type ComplexType struct {
+	commonType "complex"
+}
+
+// IntType represents a signed integer type.
+type IntType struct {
+	commonType "int"
+}
+
+// UintType represents a uint type.
+type UintType struct {
+	commonType "uint"
+}
+
+// StringType represents a string type.
+type StringType struct {
+	commonType "string"
+}
+
+// UnsafePointerType represents an unsafe.Pointer type.
+type UnsafePointerType struct {
+	commonType "unsafe.Pointer"
+}
+
+// ArrayType represents a fixed array type.
+type ArrayType struct {
+	commonType "array"
+	elem       *runtime.Type
+	len        uintptr
+}
+
+// ChanDir represents a channel type's direction.
+type ChanDir int
+
+const (
+	RecvDir ChanDir = 1 << iota
+	SendDir
+	BothDir = RecvDir | SendDir
+)
+
+// ChanType represents a channel type.
+type ChanType struct {
+	commonType "chan"
+	elem       *runtime.Type
+	dir        uintptr
+}
+
+// FuncType represents a function type.
+type FuncType struct {
+	commonType "func"
+	dotdotdot  bool
+	in         []*runtime.Type
+	out        []*runtime.Type
+}
+
+// Method on interface type
+type imethod struct {
+	name    *string
+	pkgPath *string
+	typ     *runtime.Type
+}
+
+// InterfaceType represents an interface type.
+type InterfaceType struct {
+	commonType "interface"
+	methods    []imethod
+}
+
+// MapType represents a map type.
+type MapType struct {
+	commonType "map"
+	key        *runtime.Type
+	elem       *runtime.Type
+}
+
+// PtrType represents a pointer type.
+type PtrType struct {
+	commonType "ptr"
+	elem       *runtime.Type
+}
+
+// SliceType represents a slice type.
+type SliceType struct {
+	commonType "slice"
+	elem       *runtime.Type
+}
+
+// Struct field
+type structField struct {
+	name    *string
+	pkgPath *string
+	typ     *runtime.Type
+	tag     *string
+	offset  uintptr
+}
+
+// StructType represents a struct type.
+type StructType struct {
+	commonType "struct"
+	fields     []structField
+}
+
+
+/*
+ * The compiler knows the exact layout of all the data structures above.
+ * The compiler does not know about the data structures and methods below.
+ */
+
+// Method represents a single method.
+type Method struct {
+	PkgPath string // empty for uppercase Name
+	Name    string
+	Type    *FuncType
+	Func    *FuncValue
+}
+
+// Type is the runtime representation of a Go type.
+// Every type implements the methods listed here.
+// Some types implement additional interfaces;
+// use a type switch to find out what kind of type a Type is.
+// Each type in a program has a unique Type, so == on Types
+// corresponds to Go's type equality.
+type Type interface {
+	// PkgPath returns the type's package path.
+	// The package path is a full package import path like "container/vector".
+	// PkgPath returns an empty string for unnamed types.
+	PkgPath() string
+
+	// Name returns the type's name within its package.
+	// Name returns an empty string for unnamed types.
+	Name() string
+
+	// String returns a string representation of the type.
+	// The string representation may use shortened package names
+	// (e.g., vector instead of "container/vector") and is not
+	// guaranteed to be unique among types.  To test for equality,
+	// compare the Types directly.
+	String() string
+
+	// Size returns the number of bytes needed to store
+	// a value of the given type; it is analogous to unsafe.Sizeof.
+	Size() uintptr
+
+	// Bits returns the size of the type in bits.
+	// It is intended for use with numeric types and may overflow
+	// when used for composite types.
+	Bits() int
+
+	// Align returns the alignment of a value of this type
+	// when allocated in memory.
+	Align() int
+
+	// FieldAlign returns the alignment of a value of this type
+	// when used as a field in a struct.
+	FieldAlign() int
+
+	// Kind returns the specific kind of this type.
+	Kind() Kind
+
+	// For non-interface types, Method returns the i'th method with receiver T.
+	// For interface types, Method returns the i'th method in the interface.
+	// NumMethod returns the number of such methods.
+	Method(int) Method
+	NumMethod() int
+	uncommon() *uncommonType
+}
+
+// A Kind represents the specific kind of type that a Type represents.
+// For numeric types, the Kind gives more information than the Type's
+// dynamic type.  For example, the Type of a float32 is FloatType, but
+// the Kind is Float32.
+//
+// The zero Kind is not a valid kind.
+type Kind uint8
+
+const (
+	Bool Kind = 1 + iota
+	Int
+	Int8
+	Int16
+	Int32
+	Int64
+	Uint
+	Uint8
+	Uint16
+	Uint32
+	Uint64
+	Uintptr
+	Float32
+	Float64
+	Complex64
+	Complex128
+	Array
+	Chan
+	Func
+	Interface
+	Map
+	Ptr
+	Slice
+	String
+	Struct
+	UnsafePointer
+)
+
+// High bit says whether type has
+// embedded pointers,to help garbage collector.
+const kindMask = 0x7f
+
+func (k Kind) String() string {
+	if int(k) < len(kindNames) {
+		return kindNames[k]
+	}
+	return "kind" + strconv.Itoa(int(k))
+}
+
+var kindNames = []string{
+	Bool:          "bool",
+	Int:           "int",
+	Int8:          "int8",
+	Int16:         "int16",
+	Int32:         "int32",
+	Int64:         "int64",
+	Uint:          "uint",
+	Uint8:         "uint8",
+	Uint16:        "uint16",
+	Uint32:        "uint32",
+	Uint64:        "uint64",
+	Uintptr:       "uintptr",
+	Float32:       "float32",
+	Float64:       "float64",
+	Complex64:     "complex64",
+	Complex128:    "complex128",
+	Array:         "array",
+	Chan:          "chan",
+	Func:          "func",
+	Interface:     "interface",
+	Map:           "map",
+	Ptr:           "ptr",
+	Slice:         "slice",
+	String:        "string",
+	Struct:        "struct",
+	UnsafePointer: "unsafe.Pointer",
+}
+
+func (t *uncommonType) uncommon() *uncommonType {
+	return t
+}
+
+func (t *uncommonType) PkgPath() string {
+	if t == nil || t.pkgPath == nil {
+		return ""
+	}
+	return *t.pkgPath
+}
+
+func (t *uncommonType) Name() string {
+	if t == nil || t.name == nil {
+		return ""
+	}
+	return *t.name
+}
+
+func (t *commonType) String() string { return *t.string }
+
+func (t *commonType) Size() uintptr { return t.size }
+
+func (t *commonType) Bits() int { return int(t.size * 8) }
+
+func (t *commonType) Align() int { return int(t.align) }
+
+func (t *commonType) FieldAlign() int { return int(t.fieldAlign) }
+
+func (t *commonType) Kind() Kind { return Kind(t.kind & kindMask) }
+
+func (t *uncommonType) Method(i int) (m Method) {
+	if t == nil || i < 0 || i >= len(t.methods) {
+		return
+	}
+	p := &t.methods[i]
+	if p.name != nil {
+		m.Name = *p.name
+	}
+	if p.pkgPath != nil {
+		m.PkgPath = *p.pkgPath
+	}
+	m.Type = runtimeToType(p.typ).(*FuncType)
+	fn := p.tfn
+	m.Func = &FuncValue{value: value{m.Type, addr(&fn), true}}
+	return
+}
+
+func (t *uncommonType) NumMethod() int {
+	if t == nil {
+		return 0
+	}
+	return len(t.methods)
+}
+
+// TODO(rsc): 6g supplies these, but they are not
+// as efficient as they could be: they have commonType
+// as the receiver instead of *commonType.
+func (t *commonType) NumMethod() int { return t.uncommonType.NumMethod() }
+
+func (t *commonType) Method(i int) (m Method) { return t.uncommonType.Method(i) }
+
+func (t *commonType) PkgPath() string { return t.uncommonType.PkgPath() }
+
+func (t *commonType) Name() string { return t.uncommonType.Name() }
+
+// Len returns the number of elements in the array.
+func (t *ArrayType) Len() int { return int(t.len) }
+
+// Elem returns the type of the array's elements.
+func (t *ArrayType) Elem() Type { return runtimeToType(t.elem) }
+
+// Dir returns the channel direction.
+func (t *ChanType) Dir() ChanDir { return ChanDir(t.dir) }
+
+// Elem returns the channel's element type.
+func (t *ChanType) Elem() Type { return runtimeToType(t.elem) }
+
+func (d ChanDir) String() string {
+	switch d {
+	case SendDir:
+		return "chan<-"
+	case RecvDir:
+		return "<-chan"
+	case BothDir:
+		return "chan"
+	}
+	return "ChanDir" + strconv.Itoa(int(d))
+}
+
+// In returns the type of the i'th function input parameter.
+func (t *FuncType) In(i int) Type {
+	if i < 0 || i >= len(t.in) {
+		return nil
+	}
+	return runtimeToType(t.in[i])
+}
+
+// DotDotDot returns true if the final function input parameter
+// is a "..." parameter.  If so, t.In(t.NumIn() - 1) returns the
+// parameter's underlying static type []T.
+//
+// For concreteness, if t is func(x int, y ... float), then
+//
+//	t.NumIn() == 2
+//	t.In(0) is the reflect.Type for "int"
+//	t.In(1) is the reflect.Type for "[]float"
+//	t.DotDotDot() == true
+//
+func (t *FuncType) DotDotDot() bool { return t.dotdotdot }
+
+// NumIn returns the number of input parameters.
+func (t *FuncType) NumIn() int { return len(t.in) }
+
+// Out returns the type of the i'th function output parameter.
+func (t *FuncType) Out(i int) Type {
+	if i < 0 || i >= len(t.out) {
+		return nil
+	}
+	return runtimeToType(t.out[i])
+}
+
+// NumOut returns the number of function output parameters.
+func (t *FuncType) NumOut() int { return len(t.out) }
+
+// Method returns the i'th interface method.
+func (t *InterfaceType) Method(i int) (m Method) {
+	if i < 0 || i >= len(t.methods) {
+		return
+	}
+	p := &t.methods[i]
+	m.Name = *p.name
+	if p.pkgPath != nil {
+		m.PkgPath = *p.pkgPath
+	}
+	m.Type = runtimeToType(p.typ).(*FuncType)
+	return
+}
+
+// NumMethod returns the number of interface methods.
+func (t *InterfaceType) NumMethod() int { return len(t.methods) }
+
+// Key returns the map key type.
+func (t *MapType) Key() Type { return runtimeToType(t.key) }
+
+// Elem returns the map element type.
+func (t *MapType) Elem() Type { return runtimeToType(t.elem) }
+
+// Elem returns the pointer element type.
+func (t *PtrType) Elem() Type { return runtimeToType(t.elem) }
+
+// Elem returns the type of the slice's elements.
+func (t *SliceType) Elem() Type { return runtimeToType(t.elem) }
+
+type StructField struct {
+	PkgPath   string // empty for uppercase Name
+	Name      string
+	Type      Type
+	Tag       string
+	Offset    uintptr
+	Index     []int
+	Anonymous bool
+}
+
+// Field returns the i'th struct field.
+func (t *StructType) Field(i int) (f StructField) {
+	if i < 0 || i >= len(t.fields) {
+		return
+	}
+	p := t.fields[i]
+	f.Type = runtimeToType(p.typ)
+	if p.name != nil {
+		f.Name = *p.name
+	} else {
+		t := f.Type
+		if pt, ok := t.(*PtrType); ok {
+			t = pt.Elem()
+		}
+		f.Name = t.Name()
+		f.Anonymous = true
+	}
+	if p.pkgPath != nil {
+		f.PkgPath = *p.pkgPath
+	}
+	if p.tag != nil {
+		f.Tag = *p.tag
+	}
+	f.Offset = p.offset
+	f.Index = []int{i}
+	return
+}
+
+// TODO(gri): Should there be an error/bool indicator if the index
+//            is wrong for FieldByIndex?
+
+// FieldByIndex returns the nested field corresponding to index.
+func (t *StructType) FieldByIndex(index []int) (f StructField) {
+	for i, x := range index {
+		if i > 0 {
+			ft := f.Type
+			if pt, ok := ft.(*PtrType); ok {
+				ft = pt.Elem()
+			}
+			if st, ok := ft.(*StructType); ok {
+				t = st
+			} else {
+				var f0 StructField
+				f = f0
+				return
+			}
+		}
+		f = t.Field(x)
+	}
+	return
+}
+
+const inf = 1 << 30 // infinity - no struct has that many nesting levels
+
+func (t *StructType) fieldByNameFunc(match func(string) bool, mark map[*StructType]bool, depth int) (ff StructField, fd int) {
+	fd = inf // field depth
+
+	if mark[t] {
+		// Struct already seen.
+		return
+	}
+	mark[t] = true
+
+	var fi int // field index
+	n := 0     // number of matching fields at depth fd
+L:
+	for i := range t.fields {
+		f := t.Field(i)
+		d := inf
+		switch {
+		case match(f.Name):
+			// Matching top-level field.
+			d = depth
+		case f.Anonymous:
+			ft := f.Type
+			if pt, ok := ft.(*PtrType); ok {
+				ft = pt.Elem()
+			}
+			switch {
+			case match(ft.Name()):
+				// Matching anonymous top-level field.
+				d = depth
+			case fd > depth:
+				// No top-level field yet; look inside nested structs.
+				if st, ok := ft.(*StructType); ok {
+					f, d = st.fieldByNameFunc(match, mark, depth+1)
+				}
+			}
+		}
+
+		switch {
+		case d < fd:
+			// Found field at shallower depth.
+			ff, fi, fd = f, i, d
+			n = 1
+		case d == fd:
+			// More than one matching field at the same depth (or d, fd == inf).
+			// Same as no field found at this depth.
+			n++
+			if d == depth {
+				// Impossible to find a field at lower depth.
+				break L
+			}
+		}
+	}
+
+	if n == 1 {
+		// Found matching field.
+		if len(ff.Index) <= depth {
+			ff.Index = make([]int, depth+1)
+		}
+		ff.Index[depth] = fi
+	} else {
+		// None or more than one matching field found.
+		fd = inf
+	}
+
+	mark[t] = false, false
+	return
+}
+
+// FieldByName returns the struct field with the given name
+// and a boolean to indicate if the field was found.
+func (t *StructType) FieldByName(name string) (f StructField, present bool) {
+	return t.FieldByNameFunc(func(s string) bool { return s == name })
+}
+
+// FieldByNameFunc returns the struct field with a name that satisfies the
+// match function and a boolean to indicate if the field was found.
+func (t *StructType) FieldByNameFunc(match func(string) bool) (f StructField, present bool) {
+	if ff, fd := t.fieldByNameFunc(match, make(map[*StructType]bool), 0); fd < inf {
+		ff.Index = ff.Index[0 : fd+1]
+		f, present = ff, true
+	}
+	return
+}
+
+// NumField returns the number of struct fields.
+func (t *StructType) NumField() int { return len(t.fields) }
+
+// Canonicalize a Type.
+var canonicalType = make(map[string]Type)
+
+var canonicalTypeLock sync.Mutex
+
+func canonicalize(t Type) Type {
+	if t == nil {
+		return nil
+	}
+	u := t.uncommon()
+	var s string
+	if u == nil || u.PkgPath() == "" {
+		s = t.String()
+	} else {
+		s = u.PkgPath() + "." + u.Name()
+	}
+	canonicalTypeLock.Lock()
+	if r, ok := canonicalType[s]; ok {
+		canonicalTypeLock.Unlock()
+		return r
+	}
+	canonicalType[s] = t
+	canonicalTypeLock.Unlock()
+	return t
+}
+
+// Convert runtime type to reflect type.
+// Same memory layouts, different method sets.
+func toType(i interface{}) Type {
+	switch v := i.(type) {
+	case nil:
+		return nil
+	case *runtime.BoolType:
+		return (*BoolType)(unsafe.Pointer(v))
+	case *runtime.FloatType:
+		return (*FloatType)(unsafe.Pointer(v))
+	case *runtime.ComplexType:
+		return (*ComplexType)(unsafe.Pointer(v))
+	case *runtime.IntType:
+		return (*IntType)(unsafe.Pointer(v))
+	case *runtime.StringType:
+		return (*StringType)(unsafe.Pointer(v))
+	case *runtime.UintType:
+		return (*UintType)(unsafe.Pointer(v))
+	case *runtime.UnsafePointerType:
+		return (*UnsafePointerType)(unsafe.Pointer(v))
+	case *runtime.ArrayType:
+		return (*ArrayType)(unsafe.Pointer(v))
+	case *runtime.ChanType:
+		return (*ChanType)(unsafe.Pointer(v))
+	case *runtime.FuncType:
+		return (*FuncType)(unsafe.Pointer(v))
+	case *runtime.InterfaceType:
+		return (*InterfaceType)(unsafe.Pointer(v))
+	case *runtime.MapType:
+		return (*MapType)(unsafe.Pointer(v))
+	case *runtime.PtrType:
+		return (*PtrType)(unsafe.Pointer(v))
+	case *runtime.SliceType:
+		return (*SliceType)(unsafe.Pointer(v))
+	case *runtime.StructType:
+		return (*StructType)(unsafe.Pointer(v))
+	}
+	println(i)
+	panic("toType")
+}
+
+// Convert pointer to runtime Type structure to our Type structure.
+func runtimeToType(v *runtime.Type) Type {
+	var r Type
+	switch Kind(v.Kind) {
+	case Bool:
+		r = (*BoolType)(unsafe.Pointer(v))
+	case Int, Int8, Int16, Int32, Int64:
+		r = (*IntType)(unsafe.Pointer(v))
+	case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
+		r = (*UintType)(unsafe.Pointer(v))
+	case Float32, Float64:
+		r = (*FloatType)(unsafe.Pointer(v))
+	case Complex64, Complex128:
+		r = (*ComplexType)(unsafe.Pointer(v))
+	case Array:
+		r = (*ArrayType)(unsafe.Pointer(v))
+	case Chan:
+		r = (*ChanType)(unsafe.Pointer(v))
+	case Func:
+		r = (*FuncType)(unsafe.Pointer(v))
+	case Interface:
+		r = (*InterfaceType)(unsafe.Pointer(v))
+	case Map:
+		r = (*MapType)(unsafe.Pointer(v))
+	case Ptr:
+		r = (*PtrType)(unsafe.Pointer(v))
+	case Slice:
+		r = (*SliceType)(unsafe.Pointer(v))
+	case String:
+		r = (*StringType)(unsafe.Pointer(v))
+	case Struct:
+		r = (*StructType)(unsafe.Pointer(v))
+	case UnsafePointer:
+		r = (*UnsafePointerType)(unsafe.Pointer(v))
+	default:
+		panic("runtimeToType")
+	}
+	return canonicalize(r)
+	panic("runtimeToType")
+}
+
+// ArrayOrSliceType is the common interface implemented
+// by both ArrayType and SliceType.
+type ArrayOrSliceType interface {
+	Type
+	Elem() Type
+}
+
+// Typeof returns the reflection Type of the value in the interface{}.
+func Typeof(i interface{}) Type { return canonicalize(toType(unsafe.Typeof(i))) }
diff --git a/libgo/go/reflect/value.go b/libgo/go/reflect/value.go
new file mode 100644
index 000000000..8ef402bbc
--- /dev/null
+++ b/libgo/go/reflect/value.go
@@ -0,0 +1,1242 @@
+// 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.
+
+package reflect
+
+import (
+	"math"
+	"runtime"
+	"unsafe"
+)
+
+const ptrSize = uintptr(unsafe.Sizeof((*byte)(nil)))
+const cannotSet = "cannot set value obtained via unexported struct field"
+
+type addr unsafe.Pointer
+
+// TODO: This will have to go away when
+// the new gc goes in.
+func memmove(adst, asrc addr, n uintptr) {
+	dst := uintptr(adst)
+	src := uintptr(asrc)
+	switch {
+	case src < dst && src+n > dst:
+		// byte copy backward
+		// careful: i is unsigned
+		for i := n; i > 0; {
+			i--
+			*(*byte)(addr(dst + i)) = *(*byte)(addr(src + i))
+		}
+	case (n|src|dst)&(ptrSize-1) != 0:
+		// byte copy forward
+		for i := uintptr(0); i < n; i++ {
+			*(*byte)(addr(dst + i)) = *(*byte)(addr(src + i))
+		}
+	default:
+		// word copy forward
+		for i := uintptr(0); i < n; i += ptrSize {
+			*(*uintptr)(addr(dst + i)) = *(*uintptr)(addr(src + i))
+		}
+	}
+}
+
+// Value is the common interface to reflection values.
+// The implementations of Value (e.g., ArrayValue, StructValue)
+// have additional type-specific methods.
+type Value interface {
+	// Type returns the value's type.
+	Type() Type
+
+	// Interface returns the value as an interface{}.
+	Interface() interface{}
+
+	// CanSet returns whether the value can be changed.
+	// Values obtained by the use of non-exported struct fields
+	// can be used in Get but not Set.
+	// If CanSet() returns false, calling the type-specific Set
+	// will cause a crash.
+	CanSet() bool
+
+	// SetValue assigns v to the value; v must have the same type as the value.
+	SetValue(v Value)
+
+	// Addr returns a pointer to the underlying data.
+	// It is for advanced clients that also
+	// import the "unsafe" package.
+	Addr() uintptr
+
+	// Method returns a FuncValue corresponding to the value's i'th method.
+	// The arguments to a Call on the returned FuncValue
+	// should not include a receiver; the FuncValue will use
+	// the value as the receiver.
+	Method(i int) *FuncValue
+
+	getAddr() addr
+}
+
+// value is the common implementation of most values.
+// It is embedded in other, public struct types, but always
+// with a unique tag like "uint" or "float" so that the client cannot
+// convert from, say, *UintValue to *FloatValue.
+type value struct {
+	typ    Type
+	addr   addr
+	canSet bool
+}
+
+func (v *value) Type() Type { return v.typ }
+
+func (v *value) Addr() uintptr { return uintptr(v.addr) }
+
+func (v *value) getAddr() addr { return v.addr }
+
+func (v *value) Interface() interface{} {
+	if typ, ok := v.typ.(*InterfaceType); ok {
+		// There are two different representations of interface values,
+		// one if the interface type has methods and one if it doesn't.
+		// These two representations require different expressions
+		// to extract correctly.
+		if typ.NumMethod() == 0 {
+			// Extract as interface value without methods.
+			return *(*interface{})(v.addr)
+		}
+		// Extract from v.addr as interface value with methods.
+		return *(*interface {
+			m()
+		})(v.addr)
+	}
+	return unsafe.Unreflect(v.typ, unsafe.Pointer(v.addr))
+}
+
+func (v *value) CanSet() bool { return v.canSet }
+
+/*
+ * basic types
+ */
+
+// BoolValue represents a bool value.
+type BoolValue struct {
+	value "bool"
+}
+
+// Get returns the underlying bool value.
+func (v *BoolValue) Get() bool { return *(*bool)(v.addr) }
+
+// Set sets v to the value x.
+func (v *BoolValue) Set(x bool) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	*(*bool)(v.addr) = x
+}
+
+// Set sets v to the value x.
+func (v *BoolValue) SetValue(x Value) { v.Set(x.(*BoolValue).Get()) }
+
+// FloatValue represents a float value.
+type FloatValue struct {
+	value "float"
+}
+
+// Get returns the underlying int value.
+func (v *FloatValue) Get() float64 {
+	switch v.typ.Kind() {
+	case Float32:
+		return float64(*(*float32)(v.addr))
+	case Float64:
+		return *(*float64)(v.addr)
+	}
+	panic("reflect: invalid float kind")
+}
+
+// Set sets v to the value x.
+func (v *FloatValue) Set(x float64) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	switch v.typ.Kind() {
+	default:
+		panic("reflect: invalid float kind")
+	case Float32:
+		*(*float32)(v.addr) = float32(x)
+	case Float64:
+		*(*float64)(v.addr) = x
+	}
+}
+
+// Overflow returns true if x cannot be represented by the type of v.
+func (v *FloatValue) Overflow(x float64) bool {
+	if v.typ.Size() == 8 {
+		return false
+	}
+	if x < 0 {
+		x = -x
+	}
+	return math.MaxFloat32 < x && x <= math.MaxFloat64
+}
+
+// Set sets v to the value x.
+func (v *FloatValue) SetValue(x Value) { v.Set(x.(*FloatValue).Get()) }
+
+// ComplexValue represents a complex value.
+type ComplexValue struct {
+	value "complex"
+}
+
+// Get returns the underlying complex value.
+func (v *ComplexValue) Get() complex128 {
+	switch v.typ.Kind() {
+	case Complex64:
+		return complex128(*(*complex64)(v.addr))
+	case Complex128:
+		return *(*complex128)(v.addr)
+	}
+	panic("reflect: invalid complex kind")
+}
+
+// Set sets v to the value x.
+func (v *ComplexValue) Set(x complex128) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	switch v.typ.Kind() {
+	default:
+		panic("reflect: invalid complex kind")
+	case Complex64:
+		*(*complex64)(v.addr) = complex64(x)
+	case Complex128:
+		*(*complex128)(v.addr) = x
+	}
+}
+
+// Set sets v to the value x.
+func (v *ComplexValue) SetValue(x Value) { v.Set(x.(*ComplexValue).Get()) }
+
+// IntValue represents an int value.
+type IntValue struct {
+	value "int"
+}
+
+// Get returns the underlying int value.
+func (v *IntValue) Get() int64 {
+	switch v.typ.Kind() {
+	case Int:
+		return int64(*(*int)(v.addr))
+	case Int8:
+		return int64(*(*int8)(v.addr))
+	case Int16:
+		return int64(*(*int16)(v.addr))
+	case Int32:
+		return int64(*(*int32)(v.addr))
+	case Int64:
+		return *(*int64)(v.addr)
+	}
+	panic("reflect: invalid int kind")
+}
+
+// Set sets v to the value x.
+func (v *IntValue) Set(x int64) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	switch v.typ.Kind() {
+	default:
+		panic("reflect: invalid int kind")
+	case Int:
+		*(*int)(v.addr) = int(x)
+	case Int8:
+		*(*int8)(v.addr) = int8(x)
+	case Int16:
+		*(*int16)(v.addr) = int16(x)
+	case Int32:
+		*(*int32)(v.addr) = int32(x)
+	case Int64:
+		*(*int64)(v.addr) = x
+	}
+}
+
+// Set sets v to the value x.
+func (v *IntValue) SetValue(x Value) { v.Set(x.(*IntValue).Get()) }
+
+// Overflow returns true if x cannot be represented by the type of v.
+func (v *IntValue) Overflow(x int64) bool {
+	bitSize := uint(v.typ.Bits())
+	trunc := (x << (64 - bitSize)) >> (64 - bitSize)
+	return x != trunc
+}
+
+// StringHeader is the runtime representation of a string.
+type StringHeader struct {
+	Data uintptr
+	Len  int
+}
+
+// StringValue represents a string value.
+type StringValue struct {
+	value "string"
+}
+
+// Get returns the underlying string value.
+func (v *StringValue) Get() string { return *(*string)(v.addr) }
+
+// Set sets v to the value x.
+func (v *StringValue) Set(x string) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	*(*string)(v.addr) = x
+}
+
+// Set sets v to the value x.
+func (v *StringValue) SetValue(x Value) { v.Set(x.(*StringValue).Get()) }
+
+// UintValue represents a uint value.
+type UintValue struct {
+	value "uint"
+}
+
+// Get returns the underlying uuint value.
+func (v *UintValue) Get() uint64 {
+	switch v.typ.Kind() {
+	case Uint:
+		return uint64(*(*uint)(v.addr))
+	case Uint8:
+		return uint64(*(*uint8)(v.addr))
+	case Uint16:
+		return uint64(*(*uint16)(v.addr))
+	case Uint32:
+		return uint64(*(*uint32)(v.addr))
+	case Uint64:
+		return *(*uint64)(v.addr)
+	case Uintptr:
+		return uint64(*(*uintptr)(v.addr))
+	}
+	panic("reflect: invalid uint kind")
+}
+
+// Set sets v to the value x.
+func (v *UintValue) Set(x uint64) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	switch v.typ.Kind() {
+	default:
+		panic("reflect: invalid uint kind")
+	case Uint:
+		*(*uint)(v.addr) = uint(x)
+	case Uint8:
+		*(*uint8)(v.addr) = uint8(x)
+	case Uint16:
+		*(*uint16)(v.addr) = uint16(x)
+	case Uint32:
+		*(*uint32)(v.addr) = uint32(x)
+	case Uint64:
+		*(*uint64)(v.addr) = x
+	case Uintptr:
+		*(*uintptr)(v.addr) = uintptr(x)
+	}
+}
+
+// Overflow returns true if x cannot be represented by the type of v.
+func (v *UintValue) Overflow(x uint64) bool {
+	bitSize := uint(v.typ.Bits())
+	trunc := (x << (64 - bitSize)) >> (64 - bitSize)
+	return x != trunc
+}
+
+// Set sets v to the value x.
+func (v *UintValue) SetValue(x Value) { v.Set(x.(*UintValue).Get()) }
+
+// UnsafePointerValue represents an unsafe.Pointer value.
+type UnsafePointerValue struct {
+	value "unsafe.Pointer"
+}
+
+// Get returns the underlying uintptr value.
+// Get returns uintptr, not unsafe.Pointer, so that
+// programs that do not import "unsafe" cannot
+// obtain a value of unsafe.Pointer type from "reflect".
+func (v *UnsafePointerValue) Get() uintptr { return uintptr(*(*unsafe.Pointer)(v.addr)) }
+
+// Set sets v to the value x.
+func (v *UnsafePointerValue) Set(x unsafe.Pointer) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	*(*unsafe.Pointer)(v.addr) = x
+}
+
+// Set sets v to the value x.
+func (v *UnsafePointerValue) SetValue(x Value) {
+	v.Set(unsafe.Pointer(x.(*UnsafePointerValue).Get()))
+}
+
+func typesMustMatch(t1, t2 Type) {
+	if t1 != t2 {
+		panic("type mismatch: " + t1.String() + " != " + t2.String())
+	}
+}
+
+/*
+ * array
+ */
+
+// ArrayOrSliceValue is the common interface
+// implemented by both ArrayValue and SliceValue.
+type ArrayOrSliceValue interface {
+	Value
+	Len() int
+	Cap() int
+	Elem(i int) Value
+	addr() addr
+}
+
+// grow grows the slice s so that it can hold extra more values, allocating
+// more capacity if needed. It also returns the old and new slice lengths.
+func grow(s *SliceValue, extra int) (*SliceValue, int, int) {
+	i0 := s.Len()
+	i1 := i0 + extra
+	if i1 < i0 {
+		panic("append: slice overflow")
+	}
+	m := s.Cap()
+	if i1 <= m {
+		return s.Slice(0, i1), i0, i1
+	}
+	if m == 0 {
+		m = extra
+	} else {
+		for m < i1 {
+			if i0 < 1024 {
+				m += m
+			} else {
+				m += m / 4
+			}
+		}
+	}
+	t := MakeSlice(s.Type().(*SliceType), i1, m)
+	Copy(t, s)
+	return t, i0, i1
+}
+
+// Append appends the values x to a slice s and returns the resulting slice.
+// Each x must have the same type as s' element type.
+func Append(s *SliceValue, x ...Value) *SliceValue {
+	s, i0, i1 := grow(s, len(x))
+	for i, j := i0, 0; i < i1; i, j = i+1, j+1 {
+		s.Elem(i).SetValue(x[j])
+	}
+	return s
+}
+
+// AppendSlice appends a slice t to a slice s and returns the resulting slice.
+// The slices s and t must have the same element type.
+func AppendSlice(s, t *SliceValue) *SliceValue {
+	s, i0, i1 := grow(s, t.Len())
+	Copy(s.Slice(i0, i1), t)
+	return s
+}
+
+// Copy copies the contents of src into dst until either
+// dst has been filled or src has been exhausted.
+// It returns the number of elements copied.
+// The arrays dst and src must have the same element type.
+func Copy(dst, src ArrayOrSliceValue) int {
+	// TODO: This will have to move into the runtime
+	// once the real gc goes in.
+	de := dst.Type().(ArrayOrSliceType).Elem()
+	se := src.Type().(ArrayOrSliceType).Elem()
+	typesMustMatch(de, se)
+	n := dst.Len()
+	if xn := src.Len(); n > xn {
+		n = xn
+	}
+	memmove(dst.addr(), src.addr(), uintptr(n)*de.Size())
+	return n
+}
+
+// An ArrayValue represents an array.
+type ArrayValue struct {
+	value "array"
+}
+
+// Len returns the length of the array.
+func (v *ArrayValue) Len() int { return v.typ.(*ArrayType).Len() }
+
+// Cap returns the capacity of the array (equal to Len()).
+func (v *ArrayValue) Cap() int { return v.typ.(*ArrayType).Len() }
+
+// addr returns the base address of the data in the array.
+func (v *ArrayValue) addr() addr { return v.value.addr }
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *ArrayValue) Set(x *ArrayValue) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	Copy(v, x)
+}
+
+// Set sets v to the value x.
+func (v *ArrayValue) SetValue(x Value) { v.Set(x.(*ArrayValue)) }
+
+// Elem returns the i'th element of v.
+func (v *ArrayValue) Elem(i int) Value {
+	typ := v.typ.(*ArrayType).Elem()
+	n := v.Len()
+	if i < 0 || i >= n {
+		panic("array index out of bounds")
+	}
+	p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size())
+	return newValue(typ, p, v.canSet)
+}
+
+/*
+ * slice
+ */
+
+// runtime representation of slice
+type SliceHeader struct {
+	Data uintptr
+	Len  int
+	Cap  int
+}
+
+// A SliceValue represents a slice.
+type SliceValue struct {
+	value "slice"
+}
+
+func (v *SliceValue) slice() *SliceHeader { return (*SliceHeader)(v.value.addr) }
+
+// IsNil returns whether v is a nil slice.
+func (v *SliceValue) IsNil() bool { return v.slice().Data == 0 }
+
+// Len returns the length of the slice.
+func (v *SliceValue) Len() int { return int(v.slice().Len) }
+
+// Cap returns the capacity of the slice.
+func (v *SliceValue) Cap() int { return int(v.slice().Cap) }
+
+// addr returns the base address of the data in the slice.
+func (v *SliceValue) addr() addr { return addr(v.slice().Data) }
+
+// SetLen changes the length of v.
+// The new length n must be between 0 and the capacity, inclusive.
+func (v *SliceValue) SetLen(n int) {
+	s := v.slice()
+	if n < 0 || n > int(s.Cap) {
+		panic("reflect: slice length out of range in SetLen")
+	}
+	s.Len = n
+}
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *SliceValue) Set(x *SliceValue) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	*v.slice() = *x.slice()
+}
+
+// Set sets v to the value x.
+func (v *SliceValue) SetValue(x Value) { v.Set(x.(*SliceValue)) }
+
+// Get returns the uintptr address of the v.Cap()'th element.  This gives
+// the same result for all slices of the same array.
+// It is mainly useful for printing.
+func (v *SliceValue) Get() uintptr {
+	typ := v.typ.(*SliceType)
+	return uintptr(v.addr()) + uintptr(v.Cap())*typ.Elem().Size()
+}
+
+// Slice returns a sub-slice of the slice v.
+func (v *SliceValue) Slice(beg, end int) *SliceValue {
+	cap := v.Cap()
+	if beg < 0 || end < beg || end > cap {
+		panic("slice index out of bounds")
+	}
+	typ := v.typ.(*SliceType)
+	s := new(SliceHeader)
+	s.Data = uintptr(v.addr()) + uintptr(beg)*typ.Elem().Size()
+	s.Len = end - beg
+	s.Cap = cap - beg
+	return newValue(typ, addr(s), v.canSet).(*SliceValue)
+}
+
+// Elem returns the i'th element of v.
+func (v *SliceValue) Elem(i int) Value {
+	typ := v.typ.(*SliceType).Elem()
+	n := v.Len()
+	if i < 0 || i >= n {
+		panic("reflect: slice index out of range")
+	}
+	p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size())
+	return newValue(typ, p, v.canSet)
+}
+
+// MakeSlice creates a new zero-initialized slice value
+// for the specified slice type, length, and capacity.
+func MakeSlice(typ *SliceType, len, cap int) *SliceValue {
+	s := &SliceHeader{
+		Data: uintptr(unsafe.NewArray(typ.Elem(), cap)),
+		Len:  len,
+		Cap:  cap,
+	}
+	return newValue(typ, addr(s), true).(*SliceValue)
+}
+
+/*
+ * chan
+ */
+
+// A ChanValue represents a chan.
+type ChanValue struct {
+	value "chan"
+}
+
+// IsNil returns whether v is a nil channel.
+func (v *ChanValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *ChanValue) Set(x *ChanValue) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	*(*uintptr)(v.addr) = *(*uintptr)(x.addr)
+}
+
+// Set sets v to the value x.
+func (v *ChanValue) SetValue(x Value) { v.Set(x.(*ChanValue)) }
+
+// Get returns the uintptr value of v.
+// It is mainly useful for printing.
+func (v *ChanValue) Get() uintptr { return *(*uintptr)(v.addr) }
+
+// implemented in ../pkg/runtime/reflect.cgo
+func makechan(typ *runtime.ChanType, size uint32) (ch *byte)
+func chansend(ch, val *byte, pres *bool)
+func chanrecv(ch, val *byte, pres *bool)
+func chanclosed(ch *byte) bool
+func chanclose(ch *byte)
+func chanlen(ch *byte) int32
+func chancap(ch *byte) int32
+
+// Closed returns the result of closed(c) on the underlying channel.
+func (v *ChanValue) Closed() bool {
+	ch := *(**byte)(v.addr)
+	return chanclosed(ch)
+}
+
+// Close closes the channel.
+func (v *ChanValue) Close() {
+	ch := *(**byte)(v.addr)
+	chanclose(ch)
+}
+
+func (v *ChanValue) Len() int {
+	ch := *(**byte)(v.addr)
+	return int(chanlen(ch))
+}
+
+func (v *ChanValue) Cap() int {
+	ch := *(**byte)(v.addr)
+	return int(chancap(ch))
+}
+
+// internal send; non-blocking if b != nil
+func (v *ChanValue) send(x Value, b *bool) {
+	t := v.Type().(*ChanType)
+	if t.Dir()&SendDir == 0 {
+		panic("send on recv-only channel")
+	}
+	typesMustMatch(t.Elem(), x.Type())
+	ch := *(**byte)(v.addr)
+	chansend(ch, (*byte)(x.getAddr()), b)
+}
+
+// internal recv; non-blocking if b != nil
+func (v *ChanValue) recv(b *bool) Value {
+	t := v.Type().(*ChanType)
+	if t.Dir()&RecvDir == 0 {
+		panic("recv on send-only channel")
+	}
+	ch := *(**byte)(v.addr)
+	x := MakeZero(t.Elem())
+	chanrecv(ch, (*byte)(x.getAddr()), b)
+	return x
+}
+
+// Send sends x on the channel v.
+func (v *ChanValue) Send(x Value) { v.send(x, nil) }
+
+// Recv receives and returns a value from the channel v.
+func (v *ChanValue) Recv() Value { return v.recv(nil) }
+
+// TrySend attempts to sends x on the channel v but will not block.
+// It returns true if the value was sent, false otherwise.
+func (v *ChanValue) TrySend(x Value) bool {
+	var ok bool
+	v.send(x, &ok)
+	return ok
+}
+
+// TryRecv attempts to receive a value from the channel v but will not block.
+// It returns the value if one is received, nil otherwise.
+func (v *ChanValue) TryRecv() Value {
+	var ok bool
+	x := v.recv(&ok)
+	if !ok {
+		return nil
+	}
+	return x
+}
+
+// MakeChan creates a new channel with the specified type and buffer size.
+func MakeChan(typ *ChanType, buffer int) *ChanValue {
+	if buffer < 0 {
+		panic("MakeChan: negative buffer size")
+	}
+	if typ.Dir() != BothDir {
+		panic("MakeChan: unidirectional channel type")
+	}
+	v := MakeZero(typ).(*ChanValue)
+	*(**byte)(v.addr) = makechan((*runtime.ChanType)(unsafe.Pointer(typ)), uint32(buffer))
+	return v
+}
+
+/*
+ * func
+ */
+
+// A FuncValue represents a function value.
+type FuncValue struct {
+	value       "func"
+	first       *value
+	isInterface bool
+}
+
+// IsNil returns whether v is a nil function.
+func (v *FuncValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+
+// Get returns the uintptr value of v.
+// It is mainly useful for printing.
+func (v *FuncValue) Get() uintptr { return *(*uintptr)(v.addr) }
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *FuncValue) Set(x *FuncValue) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	*(*uintptr)(v.addr) = *(*uintptr)(x.addr)
+}
+
+// Set sets v to the value x.
+func (v *FuncValue) SetValue(x Value) { v.Set(x.(*FuncValue)) }
+
+// Method returns a FuncValue corresponding to v's i'th method.
+// The arguments to a Call on the returned FuncValue
+// should not include a receiver; the FuncValue will use v
+// as the receiver.
+func (v *value) Method(i int) *FuncValue {
+	t := v.Type().uncommon()
+	if t == nil || i < 0 || i >= len(t.methods) {
+		return nil
+	}
+	p := &t.methods[i]
+	fn := p.tfn
+	fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), true}, first: v, isInterface: false}
+	return fv
+}
+
+// implemented in ../pkg/runtime/*/asm.s
+func call(typ *FuncType, fnaddr *byte, isInterface bool, params *addr, results *addr)
+
+// Call calls the function fv with input parameters in.
+// It returns the function's output parameters as Values.
+func (fv *FuncValue) Call(in []Value) []Value {
+	t := fv.Type().(*FuncType)
+	nin := len(in)
+	if fv.first != nil && !fv.isInterface {
+		nin++
+	}
+	if nin != t.NumIn() {
+		panic("FuncValue: wrong argument count")
+	}
+	if fv.first != nil && fv.isInterface {
+		nin++
+	}
+	nout := t.NumOut()
+
+	params := make([]addr, nin)
+	delta := 0
+	off := 0
+	if v := fv.first; v != nil {
+		// Hard-wired first argument.
+		if fv.isInterface {
+			// v is a single uninterpreted word
+			params[0] = v.getAddr()
+		} else {
+			// v is a real value
+			tv := v.Type()
+
+			// This is a method, so we need to always pass
+			// a pointer.
+			vAddr := v.getAddr()
+			if ptv, ok := tv.(*PtrType); ok {
+				typesMustMatch(t.In(0), tv)
+			} else {
+				p := addr(new(addr))
+				*(*addr)(p) = vAddr
+				vAddr = p
+				typesMustMatch(t.In(0).(*PtrType).Elem(), tv)
+			}
+
+			params[0] = vAddr
+			delta = 1
+		}
+		off = 1
+	}
+	for i, v := range in {
+		tv := v.Type()
+		tf := t.In(i + delta)
+
+		// If this is really a method, and we are explicitly
+		// passing the object, then we need to pass the address
+		// of the object instead.  Unfortunately, we don't
+		// have any way to know that this is a method, so we just
+		// check the type.  FIXME: This is ugly.
+		vAddr := v.getAddr()
+		if i == 0 && tf != tv {
+			if ptf, ok := tf.(*PtrType); ok {
+				p := addr(new(addr))
+				*(*addr)(p) = vAddr
+				vAddr = p
+				tf = ptf.Elem()
+			}
+		}
+
+		typesMustMatch(tf, tv)
+		params[i+off] = vAddr
+	}
+
+	ret := make([]Value, nout)
+	results := make([]addr, nout)
+	for i := 0; i < nout; i++ {
+		tv := t.Out(i)
+		v := MakeZero(tv)
+		results[i] = v.getAddr()
+		ret[i] = v
+	}
+
+	call(t, *(**byte)(fv.addr), fv.isInterface, &params[0], &results[0])
+
+	return ret
+}
+
+/*
+ * interface
+ */
+
+// An InterfaceValue represents an interface value.
+type InterfaceValue struct {
+	value "interface"
+}
+
+// IsNil returns whether v is a nil interface value.
+func (v *InterfaceValue) IsNil() bool { return v.Interface() == nil }
+
+// No single uinptr Get because v.Interface() is available.
+
+// Get returns the two words that represent an interface in the runtime.
+// Those words are useful only when playing unsafe games.
+func (v *InterfaceValue) Get() [2]uintptr {
+	return *(*[2]uintptr)(v.addr)
+}
+
+// Elem returns the concrete value stored in the interface value v.
+func (v *InterfaceValue) Elem() Value { return NewValue(v.Interface()) }
+
+// ../runtime/reflect.cgo
+func setiface(typ *InterfaceType, x *interface{}, addr addr)
+
+// Set assigns x to v.
+func (v *InterfaceValue) Set(x Value) {
+	var i interface{}
+	if x != nil {
+		i = x.Interface()
+	}
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	// Two different representations; see comment in Get.
+	// Empty interface is easy.
+	t := v.typ.(*InterfaceType)
+	if t.NumMethod() == 0 {
+		*(*interface{})(v.addr) = i
+		return
+	}
+
+	// Non-empty interface requires a runtime check.
+	setiface(t, &i, v.addr)
+}
+
+// Set sets v to the value x.
+func (v *InterfaceValue) SetValue(x Value) { v.Set(x) }
+
+// Method returns a FuncValue corresponding to v's i'th method.
+// The arguments to a Call on the returned FuncValue
+// should not include a receiver; the FuncValue will use v
+// as the receiver.
+func (v *InterfaceValue) Method(i int) *FuncValue {
+	t := v.Type().(*InterfaceType)
+	if t == nil || i < 0 || i >= len(t.methods) {
+		return nil
+	}
+	p := &t.methods[i]
+
+	// Interface is two words: itable, data.
+	tab := *(**[10000]addr)(v.addr)
+	data := &value{Typeof((*byte)(nil)), addr(uintptr(v.addr) + ptrSize), true}
+
+	fn := tab[i+1]
+	fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), true}, first: data, isInterface: true}
+	return fv
+}
+
+/*
+ * map
+ */
+
+// A MapValue represents a map value.
+type MapValue struct {
+	value "map"
+}
+
+// IsNil returns whether v is a nil map value.
+func (v *MapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *MapValue) Set(x *MapValue) {
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	if x == nil {
+		*(**uintptr)(v.addr) = nil
+		return
+	}
+	typesMustMatch(v.typ, x.typ)
+	*(*uintptr)(v.addr) = *(*uintptr)(x.addr)
+}
+
+// Set sets v to the value x.
+func (v *MapValue) SetValue(x Value) {
+	if x == nil {
+		v.Set(nil)
+		return
+	}
+	v.Set(x.(*MapValue))
+}
+
+// Get returns the uintptr value of v.
+// It is mainly useful for printing.
+func (v *MapValue) Get() uintptr { return *(*uintptr)(v.addr) }
+
+// implemented in ../pkg/runtime/reflect.cgo
+func mapaccess(m, key, val *byte) bool
+func mapassign(m, key, val *byte)
+func maplen(m *byte) int32
+func mapiterinit(m *byte) *byte
+func mapiternext(it *byte)
+func mapiterkey(it *byte, key *byte) bool
+func makemap(t *runtime.MapType) *byte
+
+// Elem returns the value associated with key in the map v.
+// It returns nil if key is not found in the map.
+func (v *MapValue) Elem(key Value) Value {
+	t := v.Type().(*MapType)
+	typesMustMatch(t.Key(), key.Type())
+	m := *(**byte)(v.addr)
+	if m == nil {
+		return nil
+	}
+	newval := MakeZero(t.Elem())
+	if !mapaccess(m, (*byte)(key.getAddr()), (*byte)(newval.getAddr())) {
+		return nil
+	}
+	return newval
+}
+
+// SetElem sets the value associated with key in the map v to val.
+// If val is nil, Put deletes the key from map.
+func (v *MapValue) SetElem(key, val Value) {
+	t := v.Type().(*MapType)
+	typesMustMatch(t.Key(), key.Type())
+	var vaddr *byte
+	if val != nil {
+		typesMustMatch(t.Elem(), val.Type())
+		vaddr = (*byte)(val.getAddr())
+	}
+	m := *(**byte)(v.addr)
+	mapassign(m, (*byte)(key.getAddr()), vaddr)
+}
+
+// Len returns the number of keys in the map v.
+func (v *MapValue) Len() int {
+	m := *(**byte)(v.addr)
+	if m == nil {
+		return 0
+	}
+	return int(maplen(m))
+}
+
+// Keys returns a slice containing all the keys present in the map,
+// in unspecified order.
+func (v *MapValue) Keys() []Value {
+	tk := v.Type().(*MapType).Key()
+	m := *(**byte)(v.addr)
+	mlen := int32(0)
+	if m != nil {
+		mlen = maplen(m)
+	}
+	it := mapiterinit(m)
+	a := make([]Value, mlen)
+	var i int
+	for i = 0; i < len(a); i++ {
+		k := MakeZero(tk)
+		if !mapiterkey(it, (*byte)(k.getAddr())) {
+			break
+		}
+		a[i] = k
+		mapiternext(it)
+	}
+	return a[0:i]
+}
+
+// MakeMap creates a new map of the specified type.
+func MakeMap(typ *MapType) *MapValue {
+	v := MakeZero(typ).(*MapValue)
+	*(**byte)(v.addr) = makemap((*runtime.MapType)(unsafe.Pointer(typ)))
+	return v
+}
+
+/*
+ * ptr
+ */
+
+// A PtrValue represents a pointer.
+type PtrValue struct {
+	value "ptr"
+}
+
+// IsNil returns whether v is a nil pointer.
+func (v *PtrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
+
+// Get returns the uintptr value of v.
+// It is mainly useful for printing.
+func (v *PtrValue) Get() uintptr { return *(*uintptr)(v.addr) }
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *PtrValue) Set(x *PtrValue) {
+	if x == nil {
+		*(**uintptr)(v.addr) = nil
+		return
+	}
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	// TODO: This will have to move into the runtime
+	// once the new gc goes in
+	*(*uintptr)(v.addr) = *(*uintptr)(x.addr)
+}
+
+// Set sets v to the value x.
+func (v *PtrValue) SetValue(x Value) {
+	if x == nil {
+		v.Set(nil)
+		return
+	}
+	v.Set(x.(*PtrValue))
+}
+
+// PointTo changes v to point to x.
+// If x is a nil Value, PointTo sets v to nil.
+func (v *PtrValue) PointTo(x Value) {
+	if x == nil {
+		*(**uintptr)(v.addr) = nil
+		return
+	}
+	if !x.CanSet() {
+		panic("cannot set x; cannot point to x")
+	}
+	typesMustMatch(v.typ.(*PtrType).Elem(), x.Type())
+	// TODO: This will have to move into the runtime
+	// once the new gc goes in.
+	*(*uintptr)(v.addr) = x.Addr()
+}
+
+// Elem returns the value that v points to.
+// If v is a nil pointer, Elem returns a nil Value.
+func (v *PtrValue) Elem() Value {
+	if v.IsNil() {
+		return nil
+	}
+	return newValue(v.typ.(*PtrType).Elem(), *(*addr)(v.addr), v.canSet)
+}
+
+// Indirect returns the value that v points to.
+// If v is a nil pointer, Indirect returns a nil Value.
+// If v is not a pointer, Indirect returns v.
+func Indirect(v Value) Value {
+	if pv, ok := v.(*PtrValue); ok {
+		return pv.Elem()
+	}
+	return v
+}
+
+/*
+ * struct
+ */
+
+// A StructValue represents a struct value.
+type StructValue struct {
+	value "struct"
+}
+
+// Set assigns x to v.
+// The new value x must have the same type as v.
+func (v *StructValue) Set(x *StructValue) {
+	// TODO: This will have to move into the runtime
+	// once the gc goes in.
+	if !v.canSet {
+		panic(cannotSet)
+	}
+	typesMustMatch(v.typ, x.typ)
+	memmove(v.addr, x.addr, v.typ.Size())
+}
+
+// Set sets v to the value x.
+func (v *StructValue) SetValue(x Value) { v.Set(x.(*StructValue)) }
+
+// Field returns the i'th field of the struct.
+func (v *StructValue) Field(i int) Value {
+	t := v.typ.(*StructType)
+	if i < 0 || i >= t.NumField() {
+		return nil
+	}
+	f := t.Field(i)
+	return newValue(f.Type, addr(uintptr(v.addr)+f.Offset), v.canSet && f.PkgPath == "")
+}
+
+// FieldByIndex returns the nested field corresponding to index.
+func (t *StructValue) FieldByIndex(index []int) (v Value) {
+	v = t
+	for i, x := range index {
+		if i > 0 {
+			if p, ok := v.(*PtrValue); ok {
+				v = p.Elem()
+			}
+			if s, ok := v.(*StructValue); ok {
+				t = s
+			} else {
+				v = nil
+				return
+			}
+		}
+		v = t.Field(x)
+	}
+	return
+}
+
+// FieldByName returns the struct field with the given name.
+// The result is nil if no field was found.
+func (t *StructValue) FieldByName(name string) Value {
+	if f, ok := t.Type().(*StructType).FieldByName(name); ok {
+		return t.FieldByIndex(f.Index)
+	}
+	return nil
+}
+
+// FieldByNameFunc returns the struct field with a name that satisfies the
+// match function.
+// The result is nil if no field was found.
+func (t *StructValue) FieldByNameFunc(match func(string) bool) Value {
+	if f, ok := t.Type().(*StructType).FieldByNameFunc(match); ok {
+		return t.FieldByIndex(f.Index)
+	}
+	return nil
+}
+
+// NumField returns the number of fields in the struct.
+func (v *StructValue) NumField() int { return v.typ.(*StructType).NumField() }
+
+/*
+ * constructors
+ */
+
+// NewValue returns a new Value initialized to the concrete value
+// stored in the interface i.  NewValue(nil) returns nil.
+func NewValue(i interface{}) Value {
+	if i == nil {
+		return nil
+	}
+	t, a := unsafe.Reflect(i)
+	return newValue(canonicalize(toType(t)), addr(a), true)
+}
+
+func newValue(typ Type, addr addr, canSet bool) Value {
+	v := value{typ, addr, canSet}
+	switch typ.(type) {
+	case *ArrayType:
+		return &ArrayValue{v}
+	case *BoolType:
+		return &BoolValue{v}
+	case *ChanType:
+		return &ChanValue{v}
+	case *FloatType:
+		return &FloatValue{v}
+	case *FuncType:
+		return &FuncValue{value: v}
+	case *ComplexType:
+		return &ComplexValue{v}
+	case *IntType:
+		return &IntValue{v}
+	case *InterfaceType:
+		return &InterfaceValue{v}
+	case *MapType:
+		return &MapValue{v}
+	case *PtrType:
+		return &PtrValue{v}
+	case *SliceType:
+		return &SliceValue{v}
+	case *StringType:
+		return &StringValue{v}
+	case *StructType:
+		return &StructValue{v}
+	case *UintType:
+		return &UintValue{v}
+	case *UnsafePointerType:
+		return &UnsafePointerValue{v}
+	}
+	panic("newValue" + typ.String())
+}
+
+// MakeZero returns a zero Value for the specified Type.
+func MakeZero(typ Type) Value {
+	if typ == nil {
+		return nil
+	}
+	return newValue(typ, addr(unsafe.New(typ)), true)
+}