1// Copyright 2011 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package runtime_test
6
7import (
8	"runtime"
9	"testing"
10	"time"
11	"unsafe"
12)
13
14type Tintptr *int // assignable to *int
15type Tint int     // *Tint implements Tinter, interface{}
16
17func (t *Tint) m() {}
18
19type Tinter interface {
20	m()
21}
22
23func TestFinalizerType(t *testing.T) {
24	ch := make(chan bool, 10)
25	finalize := func(x *int) {
26		if *x != 97531 {
27			t.Errorf("finalizer %d, want %d", *x, 97531)
28		}
29		ch <- true
30	}
31
32	var finalizerTests = []struct {
33		convert   func(*int) any
34		finalizer any
35	}{
36		{func(x *int) any { return x }, func(v *int) { finalize(v) }},
37		{func(x *int) any { return Tintptr(x) }, func(v Tintptr) { finalize(v) }},
38		{func(x *int) any { return Tintptr(x) }, func(v *int) { finalize(v) }},
39		{func(x *int) any { return (*Tint)(x) }, func(v *Tint) { finalize((*int)(v)) }},
40		{func(x *int) any { return (*Tint)(x) }, func(v Tinter) { finalize((*int)(v.(*Tint))) }},
41		// Test case for argument spill slot.
42		// If the spill slot was not counted for the frame size, it will (incorrectly) choose
43		// call32 as the result has (exactly) 32 bytes. When the argument actually spills,
44		// it clobbers the caller's frame (likely the return PC).
45		{func(x *int) any { return x }, func(v any) [4]int64 {
46			print() // force spill
47			finalize(v.(*int))
48			return [4]int64{}
49		}},
50	}
51
52	for _, tt := range finalizerTests {
53		done := make(chan bool, 1)
54		go func() {
55			// allocate struct with pointer to avoid hitting tinyalloc.
56			// Otherwise we can't be sure when the allocation will
57			// be freed.
58			type T struct {
59				v int
60				p unsafe.Pointer
61			}
62			v := &new(T).v
63			*v = 97531
64			runtime.SetFinalizer(tt.convert(v), tt.finalizer)
65			v = nil
66			done <- true
67		}()
68		<-done
69		runtime.GC()
70		<-ch
71	}
72}
73
74type bigValue struct {
75	fill uint64
76	it   bool
77	up   string
78}
79
80func TestFinalizerInterfaceBig(t *testing.T) {
81	ch := make(chan bool)
82	done := make(chan bool, 1)
83	go func() {
84		v := &bigValue{0xDEADBEEFDEADBEEF, true, "It matters not how strait the gate"}
85		old := *v
86		runtime.SetFinalizer(v, func(v any) {
87			i, ok := v.(*bigValue)
88			if !ok {
89				t.Errorf("finalizer called with type %T, want *bigValue", v)
90			}
91			if *i != old {
92				t.Errorf("finalizer called with %+v, want %+v", *i, old)
93			}
94			close(ch)
95		})
96		v = nil
97		done <- true
98	}()
99	<-done
100	runtime.GC()
101	<-ch
102}
103
104func fin(v *int) {
105}
106
107// Verify we don't crash at least. golang.org/issue/6857
108func TestFinalizerZeroSizedStruct(t *testing.T) {
109	type Z struct{}
110	z := new(Z)
111	runtime.SetFinalizer(z, func(*Z) {})
112}
113
114func BenchmarkFinalizer(b *testing.B) {
115	const Batch = 1000
116	b.RunParallel(func(pb *testing.PB) {
117		var data [Batch]*int
118		for i := 0; i < Batch; i++ {
119			data[i] = new(int)
120		}
121		for pb.Next() {
122			for i := 0; i < Batch; i++ {
123				runtime.SetFinalizer(data[i], fin)
124			}
125			for i := 0; i < Batch; i++ {
126				runtime.SetFinalizer(data[i], nil)
127			}
128		}
129	})
130}
131
132func BenchmarkFinalizerRun(b *testing.B) {
133	b.RunParallel(func(pb *testing.PB) {
134		for pb.Next() {
135			v := new(int)
136			runtime.SetFinalizer(v, fin)
137		}
138	})
139}
140
141// One chunk must be exactly one sizeclass in size.
142// It should be a sizeclass not used much by others, so we
143// have a greater chance of finding adjacent ones.
144// size class 19: 320 byte objects, 25 per page, 1 page alloc at a time
145const objsize = 320
146
147type objtype [objsize]byte
148
149func adjChunks() (*objtype, *objtype) {
150	var s []*objtype
151
152	for {
153		c := new(objtype)
154		for _, d := range s {
155			if uintptr(unsafe.Pointer(c))+unsafe.Sizeof(*c) == uintptr(unsafe.Pointer(d)) {
156				return c, d
157			}
158			if uintptr(unsafe.Pointer(d))+unsafe.Sizeof(*c) == uintptr(unsafe.Pointer(c)) {
159				return d, c
160			}
161		}
162		s = append(s, c)
163	}
164}
165
166// Make sure an empty slice on the stack doesn't pin the next object in memory.
167func TestEmptySlice(t *testing.T) {
168	x, y := adjChunks()
169
170	// the pointer inside xs points to y.
171	xs := x[objsize:] // change objsize to objsize-1 and the test passes
172
173	fin := make(chan bool, 1)
174	runtime.SetFinalizer(y, func(z *objtype) { fin <- true })
175	runtime.GC()
176	<-fin
177	xsglobal = xs // keep empty slice alive until here
178}
179
180var xsglobal []byte
181
182func adjStringChunk() (string, *objtype) {
183	b := make([]byte, objsize)
184	for {
185		s := string(b)
186		t := new(objtype)
187		p := *(*uintptr)(unsafe.Pointer(&s))
188		q := uintptr(unsafe.Pointer(t))
189		if p+objsize == q {
190			return s, t
191		}
192	}
193}
194
195// Make sure an empty string on the stack doesn't pin the next object in memory.
196func TestEmptyString(t *testing.T) {
197	x, y := adjStringChunk()
198
199	ss := x[objsize:] // change objsize to objsize-1 and the test passes
200	fin := make(chan bool, 1)
201	// set finalizer on string contents of y
202	runtime.SetFinalizer(y, func(z *objtype) { fin <- true })
203	runtime.GC()
204	<-fin
205	ssglobal = ss // keep 0-length string live until here
206}
207
208var ssglobal string
209
210// Test for issue 7656.
211func TestFinalizerOnGlobal(t *testing.T) {
212	runtime.SetFinalizer(Foo1, func(p *Object1) {})
213	runtime.SetFinalizer(Foo2, func(p *Object2) {})
214	runtime.SetFinalizer(Foo1, nil)
215	runtime.SetFinalizer(Foo2, nil)
216}
217
218type Object1 struct {
219	Something []byte
220}
221
222type Object2 struct {
223	Something byte
224}
225
226var (
227	Foo2 = &Object2{}
228	Foo1 = &Object1{}
229)
230
231func TestDeferKeepAlive(t *testing.T) {
232	if *flagQuick {
233		t.Skip("-quick")
234	}
235
236	// See issue 21402.
237	t.Parallel()
238	type T *int // needs to be a pointer base type to avoid tinyalloc and its never-finalized behavior.
239	x := new(T)
240	finRun := false
241	runtime.SetFinalizer(x, func(x *T) {
242		finRun = true
243	})
244	defer runtime.KeepAlive(x)
245	runtime.GC()
246	time.Sleep(time.Second)
247	if finRun {
248		t.Errorf("finalizer ran prematurely")
249	}
250}
251