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

View as plain text