diff options
Diffstat (limited to 'test/noinit.go')
| -rw-r--r-- | test/noinit.go | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/test/noinit.go b/test/noinit.go new file mode 100644 index 0000000..84aeeaf --- /dev/null +++ b/test/noinit.go @@ -0,0 +1,343 @@ +// run +//go:build !gcflags_noopt + +// Copyright 2010 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 many initializations can be done at link time and +// generate no executable init functions. +// Also test that trivial func init are optimized away. + +package main + +import ( + "errors" + "unsafe" +) + +// All these initializations should be done at link time. + +type S struct{ a, b, c int } +type SS struct{ aa, bb, cc S } +type SA struct{ a, b, c [3]int } +type SC struct{ a, b, c []int } + +var ( + zero = 2 + one = 1 + pi = 3.14 + slice = []byte{1, 2, 3} + sliceInt = []int{1, 2, 3} + hello = "hello, world" + bytes = []byte("hello, world") + four, five = 4, 5 + x, y = 0.1, "hello" + nilslice []byte = nil + nilmap map[string]int = nil + nilfunc func() = nil + nilchan chan int = nil + nilptr *byte = nil +) + +var a = [3]int{1001, 1002, 1003} +var s = S{1101, 1102, 1103} +var c = []int{1201, 1202, 1203} + +var aa = [3][3]int{[3]int{2001, 2002, 2003}, [3]int{2004, 2005, 2006}, [3]int{2007, 2008, 2009}} +var as = [3]S{S{2101, 2102, 2103}, S{2104, 2105, 2106}, S{2107, 2108, 2109}} + +var sa = SA{[3]int{3001, 3002, 3003}, [3]int{3004, 3005, 3006}, [3]int{3007, 3008, 3009}} +var ss = SS{S{3101, 3102, 3103}, S{3104, 3105, 3106}, S{3107, 3108, 3109}} + +var ca = [][3]int{[3]int{4001, 4002, 4003}, [3]int{4004, 4005, 4006}, [3]int{4007, 4008, 4009}} +var cs = []S{S{4101, 4102, 4103}, S{4104, 4105, 4106}, S{4107, 4108, 4109}} + +var answers = [...]int{ + // s + 1101, 1102, 1103, + + // ss + 3101, 3102, 3103, + 3104, 3105, 3106, + 3107, 3108, 3109, + + // [0] + 1001, 1201, 1301, + 2101, 2102, 2103, + 4101, 4102, 4103, + 5101, 5102, 5103, + 3001, 3004, 3007, + 3201, 3204, 3207, + 3301, 3304, 3307, + + // [0][j] + 2001, 2201, 2301, 4001, 4201, 4301, 5001, 5201, 5301, + 2002, 2202, 2302, 4002, 4202, 4302, 5002, 5202, 5302, + 2003, 2203, 2303, 4003, 4203, 4303, 5003, 5203, 5303, + + // [1] + 1002, 1202, 1302, + 2104, 2105, 2106, + 4104, 4105, 4106, + 5104, 5105, 5106, + 3002, 3005, 3008, + 3202, 3205, 3208, + 3302, 3305, 3308, + + // [1][j] + 2004, 2204, 2304, 4004, 4204, 4304, 5004, 5204, 5304, + 2005, 2205, 2305, 4005, 4205, 4305, 5005, 5205, 5305, + 2006, 2206, 2306, 4006, 4206, 4306, 5006, 5206, 5306, + + // [2] + 1003, 1203, 1303, + 2107, 2108, 2109, + 4107, 4108, 4109, + 5107, 5108, 5109, + 3003, 3006, 3009, + 3203, 3206, 3209, + 3303, 3306, 3309, + + // [2][j] + 2007, 2207, 2307, 4007, 4207, 4307, 5007, 5207, 5307, + 2008, 2208, 2308, 4008, 4208, 4308, 5008, 5208, 5308, + 2009, 2209, 2309, 4009, 4209, 4309, 5009, 5209, 5309, +} + +var ( + copy_zero = zero + copy_one = one + copy_pi = pi + copy_slice = slice + copy_sliceInt = sliceInt + // copy_hello = hello // static init of copied strings defeats link -X; see #34675 + + // Could be handled without an initialization function, but + // requires special handling for "a = []byte("..."); b = a" + // which is not a likely case. + // copy_bytes = bytes + // https://codereview.appspot.com/171840043 is one approach to + // make this special case work. + + copy_four, copy_five = four, five + copy_x = x + // copy_y = y // static init of copied strings defeats link -X; see #34675 + copy_nilslice = nilslice + copy_nilmap = nilmap + copy_nilfunc = nilfunc + copy_nilchan = nilchan + copy_nilptr = nilptr +) + +var copy_a = a +var copy_s = s +var copy_c = c + +var copy_aa = aa +var copy_as = as + +var copy_sa = sa +var copy_ss = ss + +var copy_ca = ca +var copy_cs = cs + +var copy_answers = answers + +var bx bool +var b0 = false +var b1 = true + +var fx float32 +var f0 = float32(0) +var f1 = float32(1) + +var gx float64 +var g0 = float64(0) +var g1 = float64(1) + +var ix int +var i0 = 0 +var i1 = 1 + +var jx uint +var j0 = uint(0) +var j1 = uint(1) + +var cx complex64 +var c0 = complex64(0) +var c1 = complex64(1) + +var dx complex128 +var d0 = complex128(0) +var d1 = complex128(1) + +var sx []int +var s0 = []int{0, 0, 0} +var s1 = []int{1, 2, 3} + +func fi() int { return 1 } + +var ax [10]int +var a0 = [10]int{0, 0, 0} +var a1 = [10]int{1, 2, 3, 4} + +type T struct{ X, Y int } + +var tx T +var t0 = T{} +var t0a = T{0, 0} +var t0b = T{X: 0} +var t1 = T{X: 1, Y: 2} +var t1a = T{3, 4} + +var psx *[]int +var ps0 = &[]int{0, 0, 0} +var ps1 = &[]int{1, 2, 3} + +var pax *[10]int +var pa0 = &[10]int{0, 0, 0} +var pa1 = &[10]int{1, 2, 3} + +var ptx *T +var pt0 = &T{} +var pt0a = &T{0, 0} +var pt0b = &T{X: 0} +var pt1 = &T{X: 1, Y: 2} +var pt1a = &T{3, 4} + +// The checks similar to +// var copy_bx = bx +// are commented out. The compiler no longer statically initializes them. +// See issue 7665 and https://codereview.appspot.com/93200044. +// If https://codereview.appspot.com/169040043 is submitted, and this +// test is changed to pass -complete to the compiler, then we can +// uncomment the copy lines again. + +// var copy_bx = bx +var copy_b0 = b0 +var copy_b1 = b1 + +// var copy_fx = fx +var copy_f0 = f0 +var copy_f1 = f1 + +// var copy_gx = gx +var copy_g0 = g0 +var copy_g1 = g1 + +// var copy_ix = ix +var copy_i0 = i0 +var copy_i1 = i1 + +// var copy_jx = jx +var copy_j0 = j0 +var copy_j1 = j1 + +// var copy_cx = cx +var copy_c0 = c0 +var copy_c1 = c1 + +// var copy_dx = dx +var copy_d0 = d0 +var copy_d1 = d1 + +// var copy_sx = sx +var copy_s0 = s0 +var copy_s1 = s1 + +// var copy_ax = ax +var copy_a0 = a0 +var copy_a1 = a1 + +// var copy_tx = tx +var copy_t0 = t0 +var copy_t0a = t0a +var copy_t0b = t0b +var copy_t1 = t1 +var copy_t1a = t1a + +// var copy_psx = psx +var copy_ps0 = ps0 +var copy_ps1 = ps1 + +// var copy_pax = pax +var copy_pa0 = pa0 +var copy_pa1 = pa1 + +// var copy_ptx = ptx +var copy_pt0 = pt0 +var copy_pt0a = pt0a +var copy_pt0b = pt0b +var copy_pt1 = pt1 +var copy_pt1a = pt1a + +var _ interface{} = 1 + +type T1 int + +func (t *T1) M() {} + +type Mer interface { + M() +} + +var _ Mer = (*T1)(nil) + +var Byte byte +var PtrByte unsafe.Pointer = unsafe.Pointer(&Byte) + +var LitSXInit = &S{1, 2, 3} +var LitSAnyXInit any = &S{4, 5, 6} + +func FS(x, y, z int) *S { return &S{x, y, z} } +func FSA(x, y, z int) any { return &S{x, y, z} } +func F3(x int) *S { return &S{x, x, x} } + +var LitSCallXInit = FS(7, 8, 9) +var LitSAnyCallXInit any = FSA(10, 11, 12) + +var LitSRepeat = F3(1 + 2) + +func F0() *S { return &S{1, 2, 3} } + +var LitSNoArgs = F0() + +var myError = errors.New("mine") + +func gopherize(s string) string { return "gopher gopher gopher " + s } + +var animals = gopherize("badger") + +// These init funcs should optimize away. + +func init() { +} + +func init() { + if false { + } +} + +func init() { + for false { + } +} + +// Actual test: check for init funcs in runtime data structures. + +type initTask struct { + state uint32 + nfns uint32 +} + +//go:linkname main_inittask main..inittask +var main_inittask initTask + +func main() { + if nfns := main_inittask.nfns; nfns != 0 { + println(nfns) + panic("unexpected init funcs") + } +} |