summaryrefslogtreecommitdiff
path: root/gcc/testsuite/go.test/test/nilptr
diff options
context:
space:
mode:
authorupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
committerupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
commit554fd8c5195424bdbcabf5de30fdc183aba391bd (patch)
tree976dc5ab7fddf506dadce60ae936f43f58787092 /gcc/testsuite/go.test/test/nilptr
downloadcbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.bz2
cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.xz
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.
Diffstat (limited to 'gcc/testsuite/go.test/test/nilptr')
-rw-r--r--gcc/testsuite/go.test/test/nilptr/arrayindex.go27
-rw-r--r--gcc/testsuite/go.test/test/nilptr/arrayindex1.go32
-rw-r--r--gcc/testsuite/go.test/test/nilptr/arraytoslice.go37
-rw-r--r--gcc/testsuite/go.test/test/nilptr/arraytoslice1.go34
-rw-r--r--gcc/testsuite/go.test/test/nilptr/arraytoslice2.go35
-rw-r--r--gcc/testsuite/go.test/test/nilptr/slicearray.go33
-rw-r--r--gcc/testsuite/go.test/test/nilptr/structfield.go35
-rw-r--r--gcc/testsuite/go.test/test/nilptr/structfield1.go38
-rw-r--r--gcc/testsuite/go.test/test/nilptr/structfield2.go37
-rw-r--r--gcc/testsuite/go.test/test/nilptr/structfieldaddr.go35
10 files changed, 343 insertions, 0 deletions
diff --git a/gcc/testsuite/go.test/test/nilptr/arrayindex.go b/gcc/testsuite/go.test/test/nilptr/arrayindex.go
new file mode 100644
index 000000000..c564bce34
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/arrayindex.go
@@ -0,0 +1,27 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var x byte
+
+func main() {
+ var p *[1<<30]byte = nil
+ x = 123
+
+ // The problem here is not the use of unsafe:
+ // it is that indexing into p[] with a large
+ // enough index jumps out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // Pointer offsets and array indices, if they are
+ // very large, need to dereference the base pointer
+ // to trigger a trap.
+ println(p[uintptr(unsafe.Pointer(&x))]) // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/arrayindex1.go b/gcc/testsuite/go.test/test/nilptr/arrayindex1.go
new file mode 100644
index 000000000..701630ed1
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/arrayindex1.go
@@ -0,0 +1,32 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into p[] with a large
+ // enough index jumps out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // Pointer offsets and array indices, if they are
+ // very large, need to dereference the base pointer
+ // to trigger a trap.
+ var p *[1<<30]byte = nil
+ println(p[256<<20]) // very likely to be inside dummy, but should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/arraytoslice.go b/gcc/testsuite/go.test/test/nilptr/arraytoslice.go
new file mode 100644
index 000000000..38206d50b
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/arraytoslice.go
@@ -0,0 +1,37 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+func f([]byte) {
+ panic("unreachable")
+}
+
+var dummy [512<<20]byte // give us a big address space
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into p[] with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ //
+ // To avoid needing a check on every slice beyond the
+ // usual len and cap, we require the *array -> slice
+ // conversion to do the check.
+ var p *[1<<30]byte = nil
+ f(p[0:]) // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/arraytoslice1.go b/gcc/testsuite/go.test/test/nilptr/arraytoslice1.go
new file mode 100644
index 000000000..8c9531e17
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/arraytoslice1.go
@@ -0,0 +1,34 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into p[] with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ //
+ // To avoid needing a check on every slice beyond the
+ // usual len and cap, we require the *array -> slice
+ // conversion to do the check.
+ var p *[1<<30]byte = nil
+ var x []byte = p[0:] // should crash
+ _ = x
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/arraytoslice2.go b/gcc/testsuite/go.test/test/nilptr/arraytoslice2.go
new file mode 100644
index 000000000..1b2651381
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/arraytoslice2.go
@@ -0,0 +1,35 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+var q *[1<<30]byte
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into p[] with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ //
+ // To avoid needing a check on every slice beyond the
+ // usual len and cap, we require the *array -> slice
+ // conversion to do the check.
+ var x []byte
+ var y = &x
+ *y = q[0:] // should crash (uses arraytoslice runtime routine)
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/slicearray.go b/gcc/testsuite/go.test/test/nilptr/slicearray.go
new file mode 100644
index 000000000..544536cc7
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/slicearray.go
@@ -0,0 +1,33 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into p[] with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ //
+ // To avoid needing a check on every slice beyond the
+ // usual len and cap, we require the slice operation
+ // to do the check.
+ var p *[1<<30]byte = nil
+ var _ []byte = p[10:len(p)-10] // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/structfield.go b/gcc/testsuite/go.test/test/nilptr/structfield.go
new file mode 100644
index 000000000..e081f7a17
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/structfield.go
@@ -0,0 +1,35 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+type T struct {
+ x [256<<20] byte
+ i int
+}
+
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into t with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // We require the pointer dereference to check.
+ var t *T
+ println(t.i) // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/structfield1.go b/gcc/testsuite/go.test/test/nilptr/structfield1.go
new file mode 100644
index 000000000..02d33a42c
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/structfield1.go
@@ -0,0 +1,38 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+type T struct {
+ x [256<<20] byte
+ i int
+}
+
+func f() *T {
+ return nil
+}
+
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into t with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // We require the pointer dereference to check.
+ println(f().i) // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/structfield2.go b/gcc/testsuite/go.test/test/nilptr/structfield2.go
new file mode 100644
index 000000000..4323b42b4
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/structfield2.go
@@ -0,0 +1,37 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+type T struct {
+ x [256<<20] byte
+ i int
+}
+
+var y *T
+var x = &y
+
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into t with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // We require the pointer dereference to check.
+ println((*x).i) // should crash
+}
diff --git a/gcc/testsuite/go.test/test/nilptr/structfieldaddr.go b/gcc/testsuite/go.test/test/nilptr/structfieldaddr.go
new file mode 100644
index 000000000..81551aa3b
--- /dev/null
+++ b/gcc/testsuite/go.test/test/nilptr/structfieldaddr.go
@@ -0,0 +1,35 @@
+// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
+// $G $D/$F.go && $L $F.$A &&
+// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
+
+// 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 main
+
+import "unsafe"
+
+var dummy [512<<20]byte // give us a big address space
+type T struct {
+ x [256<<20] byte
+ i int
+}
+
+func main() {
+ // the test only tests what we intend to test
+ // if dummy starts in the first 256 MB of memory.
+ // otherwise there might not be anything mapped
+ // at the address that might be accidentally
+ // dereferenced below.
+ if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+ panic("dummy too far out")
+ }
+
+ // The problem here is that indexing into t with a large
+ // enough index can jump out of the unmapped section
+ // at the beginning of memory and into valid memory.
+ // We require the address calculation to check.
+ var t *T
+ println(&t.i) // should crash
+}