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.

4 files changed, 188 insertions, 0 deletions

diff --git a/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug0.go b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug0.go
new file mode 100644
index 000000000..7fc7401c5
--- /dev/null
+++ b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug0.go
@@ -0,0 +1,9 @@
+package p
+
+type T struct {
+	X, Y int
+}
+
+type I interface {
+	M(T)
+}
diff --git a/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug1.go b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug1.go
new file mode 100644
index 000000000..7fc7401c5
--- /dev/null
+++ b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug1.go
@@ -0,0 +1,9 @@
+package p
+
+type T struct {
+	X, Y int
+}
+
+type I interface {
+	M(T)
+}
diff --git a/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug2.go b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug2.go
new file mode 100644
index 000000000..4ea187a4b
--- /dev/null
+++ b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug2.go
@@ -0,0 +1,101 @@
+package main
+
+import (
+	p0 "./bug0"
+	p1 "./bug1"
+
+	"reflect"
+	"strings"
+)
+
+var v0 p0.T
+var v1 p1.T
+
+type I0 interface {
+	M(p0.T)
+}
+
+type I1 interface {
+	M(p1.T)
+}
+
+type t0 int
+
+func (t0) M(p0.T) {}
+
+type t1 float64
+
+func (t1) M(p1.T) {}
+
+var i0 I0 = t0(0) // ok
+var i1 I1 = t1(0) // ok
+
+var p0i p0.I = t0(0) // ok
+var p1i p1.I = t1(0) // ok
+
+func main() {
+	// check that reflect paths are correct,
+	// meaning that reflect data for v0, v1 didn't get confused.
+
+	// path is full (rooted) path name.  check suffix for gc, prefix for gccgo
+	if s := reflect.Typeof(v0).PkgPath(); !strings.HasSuffix(s, "/bug0") && !strings.HasPrefix(s, "bug0") {
+		println("bad v0 path", len(s), s)
+		panic("fail")
+	}
+	if s := reflect.Typeof(v1).PkgPath(); !strings.HasSuffix(s, "/bug1") && !strings.HasPrefix(s, "bug1") {
+		println("bad v1 path", s)
+		panic("fail")
+	}
+
+	// check that dynamic interface check doesn't get confused
+	var i interface{} = t0(0)
+	if _, ok := i.(I1); ok {
+		println("used t0 as i1")
+		panic("fail")
+	}
+	if _, ok := i.(p1.I); ok {
+		println("used t0 as p1.I")
+		panic("fail")
+	}
+
+	i = t1(1)
+	if _, ok := i.(I0); ok {
+		println("used t1 as i0")
+		panic("fail")
+	}
+	if _, ok := i.(p0.I); ok {
+		println("used t1 as p0.I")
+		panic("fail")
+	}
+
+	// check that type switch works.
+	// the worry is that if p0.T and p1.T have the same hash,
+	// the binary search will handle one of them incorrectly.
+	for j := 0; j < 3; j++ {
+		switch j {
+		case 0:
+			i = p0.T{}
+		case 1:
+			i = p1.T{}
+		case 2:
+			i = 3.14
+		}
+		switch k := i.(type) {
+		case p0.T:
+			if j != 0 {
+				println("type switch p0.T")
+				panic("fail")
+			}
+		case p1.T:
+			if j != 1 {
+				println("type switch p1.T")
+				panic("fail")
+			}
+		default:
+			if j != 2 {
+				println("type switch default", j)
+				panic("fail")
+			}
+		}
+	}
+}
diff --git a/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug3.go b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug3.go
new file mode 100644
index 000000000..e5a244955
--- /dev/null
+++ b/gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug3.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+	p0 "./bug0"
+	p1 "./bug1"
+)
+
+// both p0.T and p1.T are struct { X, Y int }.
+
+var v0 p0.T
+var v1 p1.T
+
+// interfaces involving the two
+
+type I0 interface {
+	M(p0.T)
+}
+
+type I1 interface {
+	M(p1.T)
+}
+
+// t0 satisfies I0 and p0.I
+type t0 int
+
+func (t0) M(p0.T) {}
+
+// t1 satisfies I1 and p1.I
+type t1 float64
+
+func (t1) M(p1.T) {}
+
+// check static interface assignments
+var i0 I0 = t0(0) // ok
+var i1 I1 = t1(0) // ok
+
+var i2 I0 = t1(0) // ERROR "does not implement|incompatible"
+var i3 I1 = t0(0) // ERROR "does not implement|incompatible"
+
+var p0i p0.I = t0(0) // ok
+var p1i p1.I = t1(0) // ok
+
+var p0i1 p0.I = t1(0) // ERROR "does not implement|incompatible"
+var p0i2 p1.I = t0(0) // ERROR "does not implement|incompatible"
+
+func main() {
+	// check that cannot assign one to the other,
+	// but can convert.
+	v0 = v1 // ERROR "assign"
+	v1 = v0 // ERROR "assign"
+
+	v0 = p0.T(v1)
+	v1 = p1.T(v0)
+
+	i0 = i1   // ERROR "cannot use|incompatible"
+	i1 = i0   // ERROR "cannot use|incompatible"
+	p0i = i1  // ERROR "cannot use|incompatible"
+	p1i = i0  // ERROR "cannot use|incompatible"
+	i0 = p1i  // ERROR "cannot use|incompatible"
+	i1 = p0i  // ERROR "cannot use|incompatible"
+	p0i = p1i // ERROR "cannot use|incompatible"
+	p1i = p0i // ERROR "cannot use|incompatible"
+
+	i0 = p0i
+	p0i = i0
+
+	i1 = p1i
+	p1i = i1
+}