Source file test/nilptr.go

     1  // run
     2  
     3  // Copyright 2011 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  // Test that the implementation catches nil ptr indirection
     8  // in a large address space.
     9  
    10  // +build !aix
    11  // +build !darwin !arm64
    12  // +build !windows !arm64
    13  // Address space starts at 1<<32 on AIX and on darwin/arm64 and on windows/arm64, so dummy is too far.
    14  
    15  package main
    16  
    17  import "unsafe"
    18  
    19  // Having a big address space means that indexing
    20  // at a 256 MB offset from a nil pointer might not
    21  // cause a memory access fault. This test checks
    22  // that Go is doing the correct explicit checks to catch
    23  // these nil pointer accesses, not just relying on the hardware.
    24  var dummy [256 << 20]byte // give us a big address space
    25  
    26  func main() {
    27  	// the test only tests what we intend to test
    28  	// if dummy starts in the first 256 MB of memory.
    29  	// otherwise there might not be anything mapped
    30  	// at the address that might be accidentally
    31  	// dereferenced below.
    32  	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
    33  		panic("dummy too far out")
    34  	}
    35  
    36  	shouldPanic(p1)
    37  	shouldPanic(p2)
    38  	shouldPanic(p3)
    39  	shouldPanic(p4)
    40  	shouldPanic(p5)
    41  	shouldPanic(p6)
    42  	shouldPanic(p7)
    43  	shouldPanic(p8)
    44  	shouldPanic(p9)
    45  	shouldPanic(p10)
    46  	shouldPanic(p11)
    47  	shouldPanic(p12)
    48  	shouldPanic(p13)
    49  	shouldPanic(p14)
    50  	shouldPanic(p15)
    51  	shouldPanic(p16)
    52  }
    53  
    54  func shouldPanic(f func()) {
    55  	defer func() {
    56  		if recover() == nil {
    57  			panic("memory reference did not panic")
    58  		}
    59  	}()
    60  	f()
    61  }
    62  
    63  func p1() {
    64  	// Array index.
    65  	var p *[1 << 30]byte = nil
    66  	println(p[256<<20]) // very likely to be inside dummy, but should panic
    67  }
    68  
    69  var xb byte
    70  
    71  func p2() {
    72  	var p *[1 << 30]byte = nil
    73  	xb = 123
    74  
    75  	// Array index.
    76  	println(p[uintptr(unsafe.Pointer(&xb))]) // should panic
    77  }
    78  
    79  func p3() {
    80  	// Array to slice.
    81  	var p *[1 << 30]byte = nil
    82  	var x []byte = p[0:] // should panic
    83  	_ = x
    84  }
    85  
    86  var q *[1 << 30]byte
    87  
    88  func p4() {
    89  	// Array to slice.
    90  	var x []byte
    91  	var y = &x
    92  	*y = q[0:] // should crash (uses arraytoslice runtime routine)
    93  }
    94  
    95  func fb([]byte) {
    96  	panic("unreachable")
    97  }
    98  
    99  func p5() {
   100  	// Array to slice.
   101  	var p *[1 << 30]byte = nil
   102  	fb(p[0:]) // should crash
   103  }
   104  
   105  func p6() {
   106  	// Array to slice.
   107  	var p *[1 << 30]byte = nil
   108  	var _ []byte = p[10 : len(p)-10] // should crash
   109  }
   110  
   111  type T struct {
   112  	x [256 << 20]byte
   113  	i int
   114  }
   115  
   116  func f() *T {
   117  	return nil
   118  }
   119  
   120  var y *T
   121  var x = &y
   122  
   123  func p7() {
   124  	// Struct field access with large offset.
   125  	println(f().i) // should crash
   126  }
   127  
   128  func p8() {
   129  	// Struct field access with large offset.
   130  	println((*x).i) // should crash
   131  }
   132  
   133  func p9() {
   134  	// Struct field access with large offset.
   135  	var t *T
   136  	println(&t.i) // should crash
   137  }
   138  
   139  func p10() {
   140  	// Struct field access with large offset.
   141  	var t *T
   142  	println(t.i) // should crash
   143  }
   144  
   145  type T1 struct {
   146  	T
   147  }
   148  
   149  type T2 struct {
   150  	*T1
   151  }
   152  
   153  func p11() {
   154  	t := &T2{}
   155  	p := &t.i
   156  	println(*p)
   157  }
   158  
   159  // ADDR(DOT(IND(p))) needs a check also
   160  func p12() {
   161  	var p *T = nil
   162  	println(*(&((*p).i)))
   163  }
   164  
   165  // Tests suggested in golang.org/issue/6080.
   166  
   167  func p13() {
   168  	var x *[10]int
   169  	y := x[:]
   170  	_ = y
   171  }
   172  
   173  func p14() {
   174  	println((*[1]int)(nil)[:])
   175  }
   176  
   177  func p15() {
   178  	for i := range (*[1]int)(nil)[:] {
   179  		_ = i
   180  	}
   181  }
   182  
   183  func p16() {
   184  	for i, v := range (*[1]int)(nil)[:] {
   185  		_ = i + v
   186  	}
   187  }
   188  

View as plain text