1// Copyright 2019 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
5// This file contains tests for the atomic alignment checker.
6
7// +build arm 386
8
9package testdata
10
11import (
12	"io"
13	"sync/atomic"
14)
15
16func intsAlignment() {
17	var s struct {
18		a bool
19		b uint8
20		c int8
21		d byte
22		f int16
23		g int16
24		h int64
25		i byte
26		j uint64
27	}
28	atomic.AddInt64(&s.h, 9)
29	atomic.AddUint64(&s.j, 0) // want "address of non 64-bit aligned field .j passed to atomic.AddUint64"
30}
31
32func floatAlignment() {
33	var s struct {
34		a float32
35		b int64
36		c float32
37		d float64
38		e uint64
39	}
40	atomic.LoadInt64(&s.b) // want "address of non 64-bit aligned field .b passed to atomic.LoadInt64"
41	atomic.LoadUint64(&s.e)
42}
43
44func uintptrAlignment() {
45	var s struct {
46		a uintptr
47		b int64
48		c int
49		d uint
50		e int32
51		f uint64
52	}
53	atomic.StoreInt64(&s.b, 0) // want "address of non 64-bit aligned field .b passed to atomic.StoreInt64"
54	atomic.StoreUint64(&s.f, 0)
55}
56
57func runeAlignment() {
58	var s struct {
59		a rune
60		b int64
61		_ rune
62		c uint64
63	}
64	atomic.SwapInt64(&s.b, 0) // want "address of non 64-bit aligned field .b passed to atomic.SwapInt64"
65	atomic.SwapUint64(&s.c, 0)
66}
67
68func complexAlignment() {
69	var s struct {
70		a complex64
71		b int64
72		c complex128
73		d uint64
74	}
75	atomic.CompareAndSwapInt64(&s.b, 0, 1)
76	atomic.CompareAndSwapUint64(&s.d, 0, 1)
77}
78
79// continuer ici avec les tests
80
81func channelAlignment() {
82	var a struct {
83		a chan struct{}
84		b int64
85		c <-chan struct{}
86		d uint64
87	}
88
89	atomic.AddInt64(&a.b, 0) // want "address of non 64-bit aligned field .b passed to atomic.AddInt64"
90	atomic.AddUint64(&a.d, 0)
91}
92
93func arrayAlignment() {
94	var a struct {
95		a [1]uint16
96		b int64
97		_ [2]uint16
98		c int64
99		d [1]uint16
100		e uint64
101	}
102
103	atomic.LoadInt64(&a.b) // want "address of non 64-bit aligned field .b passed to atomic.LoadInt64"
104	atomic.LoadInt64(&a.c)
105	atomic.LoadUint64(&a.e) // want "address of non 64-bit aligned field .e passed to atomic.LoadUint64"
106}
107
108func anonymousFieldAlignment() {
109	var f struct {
110		a, b int32
111		c, d int64
112		_    bool
113		e, f uint64
114	}
115
116	atomic.StoreInt64(&f.c, 12)
117	atomic.StoreInt64(&f.d, 27)
118	atomic.StoreUint64(&f.e, 6)  // want "address of non 64-bit aligned field .e passed to atomic.StoreUint64"
119	atomic.StoreUint64(&f.f, 79) // want "address of non 64-bit aligned field .f passed to atomic.StoreUint64"
120}
121
122type ts struct {
123	e  int64
124	e2 []int
125	f  uint64
126}
127
128func typedStructAlignment() {
129	var b ts
130	atomic.SwapInt64(&b.e, 9)
131	atomic.SwapUint64(&b.f, 9) // want "address of non 64-bit aligned field .f passed to atomic.SwapUint64"
132}
133
134func aliasAlignment() {
135	type (
136		mybytea uint8
137		mybyteb byte
138		mybytec = uint8
139		mybyted = byte
140	)
141
142	var e struct {
143		a    byte
144		b    mybytea
145		c    mybyteb
146		e    mybytec
147		f    int64
148		g, h uint16
149		i    uint64
150	}
151
152	atomic.CompareAndSwapInt64(&e.f, 0, 1) // want "address of non 64-bit aligned field .f passed to atomic.CompareAndSwapInt64"
153	atomic.CompareAndSwapUint64(&e.i, 1, 2)
154}
155
156func stringAlignment() {
157	var a struct {
158		a uint32
159		b string
160		c int64
161	}
162	atomic.AddInt64(&a.c, 10) // want "address of non 64-bit aligned field .c passed to atomic.AddInt64"
163}
164
165func sliceAlignment() {
166	var s struct {
167		a []int32
168		b int64
169		c uint32
170		d uint64
171	}
172
173	atomic.LoadInt64(&s.b) // want "address of non 64-bit aligned field .b passed to atomic.LoadInt64"
174	atomic.LoadUint64(&s.d)
175}
176
177func interfaceAlignment() {
178	var s struct {
179		a interface{}
180		b int64
181		c io.Writer
182		e int64
183		_ int32
184		f uint64
185	}
186
187	atomic.StoreInt64(&s.b, 9)
188	atomic.StoreInt64(&s.e, 9)
189	atomic.StoreUint64(&s.f, 9) // want "address of non 64-bit aligned field .f passed to atomic.StoreUint64"
190}
191
192func pointerAlignment() {
193	var s struct {
194		a, b *int
195		c    int64
196		d    *interface{}
197		e    uint64
198	}
199
200	atomic.SwapInt64(&s.c, 9)
201	atomic.SwapUint64(&s.e, 9) // want "address of non 64-bit aligned field .e passed to atomic.SwapUint64"
202}
203
204// non-struct fields are already 64-bits correctly aligned per Go spec
205func nonStructFields() {
206	var (
207		a *int64
208		b [2]uint64
209		c int64
210	)
211
212	atomic.CompareAndSwapInt64(a, 10, 11)
213	atomic.CompareAndSwapUint64(&b[0], 5, 23)
214	atomic.CompareAndSwapInt64(&c, -1, -15)
215}
216
217func embeddedStructFields() {
218	var s1 struct {
219		_ struct{ _ int32 }
220		a int64
221		_ struct{}
222		b uint64
223		_ struct{ _ [2]uint16 }
224		c int64
225	}
226
227	atomic.AddInt64(&s1.a, 9)  // want "address of non 64-bit aligned field .a passed to atomic.AddInt64"
228	atomic.AddUint64(&s1.b, 9) // want "address of non 64-bit aligned field .b passed to atomic.AddUint64"
229	atomic.AddInt64(&s1.c, 9)
230}
231