/usr/share/go-1.8/test/nilptr.go is in golang-1.8-src 1.8.3-2ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 | // 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 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 [256 << 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)
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 *[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
}
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
}
}
|