[PATCH 4/4] Gccgo port to s390[x] -- part II

[Dominik Vogt <vogt at linux dot vnet dot ibm dot com>]

See commit comment and ChangeLog for details.

Ciao

Dominik ^_^  ^_^

-- 

Dominik Vogt
IBM Germany

Attachment: 0004-ChangeLog
Description: Text document

>From 5b0eaf73d005bd152fff5a1a922f5618da4be939 Mon Sep 17 00:00:00 2001
From: Dominik Vogt <vogt@linux.vnet.ibm.com>
Date: Tue, 4 Nov 2014 10:13:22 +0100
Subject: [PATCH 4/4] go.test: Changes required for s390[x] port.

1) Add Go architectures s390 and s390x.

2) Do not run test nilptr.go on s390 -> platform specific test.

   * Detects word boundaries to distinguish between s390 and s390x.
     (Switch to using regular expressions.)
   * Implement the Prefix '!' to exclude targets from build.

3) Fix go/test/ken/cplx2.go test failures.
---
 gcc/testsuite/go.test/go-test.exp          |   6 +
 gcc/testsuite/go.test/test/ken/cplx2.go    |  20 ++-
 gcc/testsuite/go.test/test/nilptr.go       |   1 +
 gcc/testsuite/go.test/test/nilptr_s390.go  | 190 +++++++++++++++++++++++++++++
 gcc/testsuite/go.test/test/nilptr_s390x.go | 190 +++++++++++++++++++++++++++++
 5 files changed, 405 insertions(+), 2 deletions(-)
 create mode 100644 gcc/testsuite/go.test/test/nilptr_s390.go
 create mode 100644 gcc/testsuite/go.test/test/nilptr_s390x.go

diff --git a/gcc/testsuite/go.test/go-test.exp b/gcc/testsuite/go.test/go-test.exp
index 71272a3..25e405b 100644
--- a/gcc/testsuite/go.test/go-test.exp
+++ b/gcc/testsuite/go.test/go-test.exp
@@ -244,6 +244,12 @@ proc go-set-goarch { } {
 		set goarch "ppc64"
 	    }
 	}
+	"s390-*-*" {
+	    set goarch "s390"
+	}
+	"s390x-*-*" {
+	    set goarch "s390x"
+	}
 	"sparc*-*-*" {
 	    if [check_effective_target_ilp32] {
 		set goarch "sparc"
diff --git a/gcc/testsuite/go.test/test/ken/cplx2.go b/gcc/testsuite/go.test/test/ken/cplx2.go
index eb1da7b..d11e33c 100644
--- a/gcc/testsuite/go.test/test/ken/cplx2.go
+++ b/gcc/testsuite/go.test/test/ken/cplx2.go
@@ -97,13 +97,29 @@ func main() {
 	}
 
 	cd := c5 / c6
-	if cd != Cd {
+	dr := real(Cd) - real(cd)
+	if dr < 0 {
+		dr = -dr
+	}
+	di := imag(Cd) - imag(cd)
+	if di < 0 {
+		di = -di
+	}
+	if dr > .000000059604644775390625 || di > 0 {
 		println("opcode x", cd, Cd)
 		panic("fail")
 	}
 
 	ce := cd * c6
-	if ce != Ce {
+	dr = real(Ce) - real(ce)
+	if dr < 0 {
+		dr = -dr
+	}
+	di = imag(Ce) - imag(ce)
+	if di < 0 {
+		di = -di
+	}
+	if dr > 0 || di > 0.00000095367431640625 {
 		println("opcode x", ce, Ce)
 		panic("fail")
 	}
diff --git a/gcc/testsuite/go.test/test/nilptr.go b/gcc/testsuite/go.test/test/nilptr.go
index 9631d16..574d662 100644
--- a/gcc/testsuite/go.test/test/nilptr.go
+++ b/gcc/testsuite/go.test/test/nilptr.go
@@ -1,3 +1,4 @@
+// +build !s390 !s390x
 // run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
diff --git a/gcc/testsuite/go.test/test/nilptr_s390.go b/gcc/testsuite/go.test/test/nilptr_s390.go
new file mode 100644
index 0000000..d79916d
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr_s390.go
@@ -0,0 +1,190 @@
+// +build s390
+// run
+
+// Copyright 2011 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.
+
+// Test that the implementation catches nil ptr indirection in a
+// large address space.
+
+package main
+
+import "unsafe"
+
+// Having a big address space means that indexing at a large
+// offset from a nil pointer might not cause a memory access
+// fault.  This test checks that Go is doing the correct explicit
+// checks to catch these nil pointer accesses, not just relying on
+// the hardware.
+//
+// Give us a big address space somewhere near min_bss_offset.
+const in_mem_size uintptr = 256 << 20 // 256 MiB
+const min_bss_offset uintptr = 1 << 22 // 0x00400000
+const maxlen uintptr = (1 << 31) - 2 // 0x7ffffffe
+var dummy [in_mem_size]byte
+
+func main() {
+	// The test only tests what we intend to test if dummy
+	// starts near 0x0040000.  Otherwise there might not be
+	// anything mapped at the address that might be
+	// accidentally dereferenced below.
+	if uintptr(unsafe.Pointer(&dummy)) > in_mem_size + min_bss_offset {
+		panic("dummy too far out")
+	} else if uintptr(unsafe.Pointer(&dummy)) < min_bss_offset {
+		panic("dummy too close")
+	}
+
+	shouldPanic(p1)
+	shouldPanic(p2)
+	shouldPanic(p3)
+	shouldPanic(p4)
+	shouldPanic(p5)
+	shouldPanic(p6)
+	shouldPanic(p7)
+	shouldPanic(p8)
+	shouldPanic(p9)
+	shouldPanic(p10)
+	shouldPanic(p11)
+	shouldPanic(p12)
+	shouldPanic(p13)
+	shouldPanic(p14)
+	shouldPanic(p15)
+	shouldPanic(p16)
+}
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("memory reference did not panic")
+		}
+	}()
+	f()
+}
+
+func p1() {
+	// Array index.
+	var p *[maxlen]byte = nil
+	// very likely to be inside dummy, but should panic
+	println(p[min_bss_offset + in_mem_size / 2])
+}
+
+var xb byte
+
+func p2() {
+	var p *[maxlen]byte = nil
+	xb = 123
+
+	// Array index.
+	println(p[uintptr(unsafe.Pointer(&xb))]) // should panic
+}
+
+func p3() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	var x []byte = p[0:] // should panic
+	_ = x
+}
+
+var q *[maxlen]byte
+
+func p4() {
+	// Array to slice.
+	var x []byte
+	var y = &x
+	*y = q[0:] // should crash (uses arraytoslice runtime routine)
+}
+
+func fb([]byte) {
+	panic("unreachable")
+}
+
+func p5() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	fb(p[0:]) // should crash
+}
+
+func p6() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	var _ []byte = p[10 : len(p)-10] // should crash
+}
+
+type T struct {
+	x [in_mem_size]byte
+	i int
+}
+
+func f() *T {
+	return nil
+}
+
+var y *T
+var x = &y
+
+func p7() {
+	// Struct field access with large offset.
+	println(f().i) // should crash
+}
+
+func p8() {
+	// Struct field access with large offset.
+	println((*x).i) // should crash
+}
+
+func p9() {
+	// Struct field access with large offset.
+	var t *T
+	println(&t.i) // should crash
+}
+
+func p10() {
+	// Struct field access with large offset.
+	var t *T
+	println(t.i) // should crash
+}
+
+type T1 struct {
+	T
+}
+
+type T2 struct {
+	*T1
+}
+
+func p11() {
+	t := &T2{}
+	p := &t.i
+	println(*p)
+}
+
+// ADDR(DOT(IND(p))) needs a check also
+func p12() {
+	var p *T = nil
+	println(*(&((*p).i)))
+}
+
+// Tests suggested in golang.org/issue/6080.
+
+func p13() {
+	var x *[10]int
+	y := x[:]
+	_ = y
+}
+
+func p14() {
+	println((*[1]int)(nil)[:])
+}
+
+func p15() {
+	for i := range (*[1]int)(nil)[:] {
+		_ = i
+	}
+}
+
+func p16() {
+	for i, v := range (*[1]int)(nil)[:] {
+		_ = i + v
+	}
+}
diff --git a/gcc/testsuite/go.test/test/nilptr_s390x.go b/gcc/testsuite/go.test/test/nilptr_s390x.go
new file mode 100644
index 0000000..e5f6d56
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr_s390x.go
@@ -0,0 +1,190 @@
+// +build s390x
+// run
+
+// Copyright 2011 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.
+
+// Test that the implementation catches nil ptr indirection in a
+// large address space.
+
+package main
+
+import "unsafe"
+
+// Having a big address space means that indexing at a large
+// offset from a nil pointer might not cause a memory access
+// fault.  This test checks that Go is doing the correct explicit
+// checks to catch these nil pointer accesses, not just relying on
+// the hardware.
+//
+// Give us a big address space somewhere near min_bss_offset.
+const in_mem_size uintptr = 256 << 20 // 256 MiB
+const min_bss_offset uintptr = 1 << 31 // 0x80000000
+const maxlen uintptr = (1 << 32) - 1 // 0xffffffff
+var dummy [in_mem_size]byte
+
+func main() {
+	// The test only tests what we intend to test if dummy
+	// starts near 0x8000000.  Otherwise there might not be
+	// anything mapped at the address that might be
+	// accidentally dereferenced below.
+	if uintptr(unsafe.Pointer(&dummy)) > in_mem_size + min_bss_offset {
+		panic("dummy too far out")
+	} else if uintptr(unsafe.Pointer(&dummy)) < min_bss_offset {
+		panic("dummy too close")
+	}
+
+	shouldPanic(p1)
+	shouldPanic(p2)
+	shouldPanic(p3)
+	shouldPanic(p4)
+	shouldPanic(p5)
+	shouldPanic(p6)
+	shouldPanic(p7)
+	shouldPanic(p8)
+	shouldPanic(p9)
+	shouldPanic(p10)
+	shouldPanic(p11)
+	shouldPanic(p12)
+	shouldPanic(p13)
+	shouldPanic(p14)
+	shouldPanic(p15)
+	shouldPanic(p16)
+}
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("memory reference did not panic")
+		}
+	}()
+	f()
+}
+
+func p1() {
+	// Array index.
+	var p *[maxlen]byte = nil
+	// very likely to be inside dummy, but should panic
+	println(p[min_bss_offset + in_mem_size / 2])
+}
+
+var xb byte
+
+func p2() {
+	var p *[maxlen]byte = nil
+	xb = 123
+
+	// Array index.
+	println(p[uintptr(unsafe.Pointer(&xb))]) // should panic
+}
+
+func p3() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	var x []byte = p[0:] // should panic
+	_ = x
+}
+
+var q *[maxlen]byte
+
+func p4() {
+	// Array to slice.
+	var x []byte
+	var y = &x
+	*y = q[0:] // should crash (uses arraytoslice runtime routine)
+}
+
+func fb([]byte) {
+	panic("unreachable")
+}
+
+func p5() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	fb(p[0:]) // should crash
+}
+
+func p6() {
+	// Array to slice.
+	var p *[maxlen]byte = nil
+	var _ []byte = p[10 : len(p)-10] // should crash
+}
+
+type T struct {
+	x [in_mem_size]byte
+	i int
+}
+
+func f() *T {
+	return nil
+}
+
+var y *T
+var x = &y
+
+func p7() {
+	// Struct field access with large offset.
+	println(f().i) // should crash
+}
+
+func p8() {
+	// Struct field access with large offset.
+	println((*x).i) // should crash
+}
+
+func p9() {
+	// Struct field access with large offset.
+	var t *T
+	println(&t.i) // should crash
+}
+
+func p10() {
+	// Struct field access with large offset.
+	var t *T
+	println(t.i) // should crash
+}
+
+type T1 struct {
+	T
+}
+
+type T2 struct {
+	*T1
+}
+
+func p11() {
+	t := &T2{}
+	p := &t.i
+	println(*p)
+}
+
+// ADDR(DOT(IND(p))) needs a check also
+func p12() {
+	var p *T = nil
+	println(*(&((*p).i)))
+}
+
+// Tests suggested in golang.org/issue/6080.
+
+func p13() {
+	var x *[10]int
+	y := x[:]
+	_ = y
+}
+
+func p14() {
+	println((*[1]int)(nil)[:])
+}
+
+func p15() {
+	for i := range (*[1]int)(nil)[:] {
+		_ = i
+	}
+}
+
+func p16() {
+	for i, v := range (*[1]int)(nil)[:] {
+		_ = i + v
+	}
+}
-- 
1.8.4.2