From 67d48daae96c26ae734f6a4245bd40080a5bd934 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 26 Sep 2011 13:59:01 -0400 Subject: [PATCH] test: merge nilptr/* into one test The 512 MB array causes load delays on some systems. Now that we have recover, we can do all the tests in one binary, so that the delay is incurred just once. R=golang-dev, r CC=golang-dev https://golang.org/cl/5142044 --- test/golden.out | 2 - test/nilptr.go | 125 +++++++++++++++++++++++++++++++++ test/nilptr/arrayindex.go | 26 ------- test/nilptr/arrayindex1.go | 31 -------- test/nilptr/arraytoslice.go | 36 ---------- test/nilptr/arraytoslice1.go | 33 --------- test/nilptr/arraytoslice2.go | 34 --------- test/nilptr/slicearray.go | 32 --------- test/nilptr/structfield.go | 34 --------- test/nilptr/structfield1.go | 37 ---------- test/nilptr/structfield2.go | 36 ---------- test/nilptr/structfieldaddr.go | 34 --------- test/run | 2 +- 13 files changed, 126 insertions(+), 336 deletions(-) create mode 100644 test/nilptr.go delete mode 100644 test/nilptr/arrayindex.go delete mode 100644 test/nilptr/arrayindex1.go delete mode 100644 test/nilptr/arraytoslice.go delete mode 100644 test/nilptr/arraytoslice1.go delete mode 100644 test/nilptr/arraytoslice2.go delete mode 100644 test/nilptr/slicearray.go delete mode 100644 test/nilptr/structfield.go delete mode 100644 test/nilptr/structfield1.go delete mode 100644 test/nilptr/structfield2.go delete mode 100644 test/nilptr/structfieldaddr.go diff --git a/test/golden.out b/test/golden.out index fc4b81d3bd3..27c932f65c9 100644 --- a/test/golden.out +++ b/test/golden.out @@ -111,8 +111,6 @@ panic: interface conversion: *main.S is not main.I: missing method Foo =========== interface/returntype.go panic: interface conversion: *main.S is not main.I2: missing method Name -== nilptr/ - == syntax/ == dwarf/ diff --git a/test/nilptr.go b/test/nilptr.go new file mode 100644 index 00000000000..41d8f235281 --- /dev/null +++ b/test/nilptr.go @@ -0,0 +1,125 @@ +// $G $D/$F.go && $L $F.$A && ./$A.out + +package main + +import "unsafe" + +// Having a big address space means that indexing +// at a 256 MB 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. +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") + } + + shouldPanic(p1) + shouldPanic(p2) + shouldPanic(p3) + shouldPanic(p4) + shouldPanic(p5) + shouldPanic(p6) + shouldPanic(p7) + shouldPanic(p8) + shouldPanic(p9) + shouldPanic(p10) +} + +func shouldPanic(f func()) { + defer func() { + if recover() == nil { + panic("memory reference did not panic") + } + }() + f() +} + +func p1() { + // Array index. + var p *[1 << 30]byte = nil + println(p[256<<20]) // very likely to be inside dummy, but should panic +} + +var xb byte + +func p2() { + var p *[1 << 30]byte = nil + xb = 123 + + // Array index. + println(p[uintptr(unsafe.Pointer(&xb))]) // should panic +} + +func p3() { + // Array to slice. + var p *[1 << 30]byte = nil + var x []byte = p[0:] // should panic + _ = x +} + +var q *[1 << 30]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 *[1 << 30]byte = nil + fb(p[0:]) // should crash +} + +func p6() { + // Array to slice. + var p *[1 << 30]byte = nil + var _ []byte = p[10 : len(p)-10] // should crash +} + +type T struct { + x [256 << 20]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 +} diff --git a/test/nilptr/arrayindex.go b/test/nilptr/arrayindex.go deleted file mode 100644 index fa26532c67b..00000000000 --- a/test/nilptr/arrayindex.go +++ /dev/null @@ -1,26 +0,0 @@ -// $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/test/nilptr/arrayindex1.go b/test/nilptr/arrayindex1.go deleted file mode 100644 index 64f46e14d19..00000000000 --- a/test/nilptr/arrayindex1.go +++ /dev/null @@ -1,31 +0,0 @@ -// $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/test/nilptr/arraytoslice.go b/test/nilptr/arraytoslice.go deleted file mode 100644 index 03879fb42f7..00000000000 --- a/test/nilptr/arraytoslice.go +++ /dev/null @@ -1,36 +0,0 @@ -// $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/test/nilptr/arraytoslice1.go b/test/nilptr/arraytoslice1.go deleted file mode 100644 index c86070fa473..00000000000 --- a/test/nilptr/arraytoslice1.go +++ /dev/null @@ -1,33 +0,0 @@ -// $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/test/nilptr/arraytoslice2.go b/test/nilptr/arraytoslice2.go deleted file mode 100644 index 68ea44083cb..00000000000 --- a/test/nilptr/arraytoslice2.go +++ /dev/null @@ -1,34 +0,0 @@ -// $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/test/nilptr/slicearray.go b/test/nilptr/slicearray.go deleted file mode 100644 index 26ca4277328..00000000000 --- a/test/nilptr/slicearray.go +++ /dev/null @@ -1,32 +0,0 @@ -// $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/test/nilptr/structfield.go b/test/nilptr/structfield.go deleted file mode 100644 index 35196bb68dd..00000000000 --- a/test/nilptr/structfield.go +++ /dev/null @@ -1,34 +0,0 @@ -// $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/test/nilptr/structfield1.go b/test/nilptr/structfield1.go deleted file mode 100644 index 7c7abed1aa0..00000000000 --- a/test/nilptr/structfield1.go +++ /dev/null @@ -1,37 +0,0 @@ -// $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/test/nilptr/structfield2.go b/test/nilptr/structfield2.go deleted file mode 100644 index 02a44f17318..00000000000 --- a/test/nilptr/structfield2.go +++ /dev/null @@ -1,36 +0,0 @@ -// $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/test/nilptr/structfieldaddr.go b/test/nilptr/structfieldaddr.go deleted file mode 100644 index f3177bafbaa..00000000000 --- a/test/nilptr/structfieldaddr.go +++ /dev/null @@ -1,34 +0,0 @@ -// $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 -} diff --git a/test/run b/test/run index 844ee5fecad..533b0d824b7 100755 --- a/test/run +++ b/test/run @@ -53,7 +53,7 @@ filterout() { grep '^'"$2"'$' $1 >/dev/null } -for dir in . ken chan interface nilptr syntax dwarf fixedbugs bugs +for dir in . ken chan interface syntax dwarf fixedbugs bugs do echo echo '==' $dir'/'