1// asmcheck
2
3// Copyright 2018 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
7package codegen
8
9// These tests check that mapaccess calls are not used.
10// Issues #23661 and #24364.
11
12func mapCompoundAssignmentInt8() {
13	m := make(map[int8]int8, 0)
14	var k int8 = 0
15
16	// 386:-".*mapaccess"
17	// amd64:-".*mapaccess"
18	// arm:-".*mapaccess"
19	// arm64:-".*mapaccess"
20	m[k] += 67
21
22	// 386:-".*mapaccess"
23	// amd64:-".*mapaccess"
24	// arm:-".*mapaccess"
25	// arm64:-".*mapaccess"
26	m[k] -= 123
27
28	// 386:-".*mapaccess"
29	// amd64:-".*mapaccess"
30	// arm:-".*mapaccess"
31	// arm64:-".*mapaccess"
32	m[k] *= 45
33
34	// 386:-".*mapaccess"
35	// amd64:-".*mapaccess"
36	// arm:-".*mapaccess"
37	// arm64:-".*mapaccess"
38	m[k] |= 78
39
40	// 386:-".*mapaccess"
41	// amd64:-".*mapaccess"
42	// arm:-".*mapaccess"
43	// arm64:-".*mapaccess"
44	m[k] ^= 89
45
46	// 386:-".*mapaccess"
47	// amd64:-".*mapaccess"
48	// arm:-".*mapaccess"
49	// arm64:-".*mapaccess"
50	m[k] <<= 9
51
52	// 386:-".*mapaccess"
53	// amd64:-".*mapaccess"
54	// arm:-".*mapaccess"
55	// arm64:-".*mapaccess"
56	m[k] >>= 10
57
58	// 386:-".*mapaccess"
59	// amd64:-".*mapaccess"
60	// arm:-".*mapaccess"
61	// arm64:-".*mapaccess"
62	m[k]++
63
64	// 386:-".*mapaccess"
65	// amd64:-".*mapaccess"
66	// arm:-".*mapaccess"
67	// arm64:-".*mapaccess"
68	m[k]--
69}
70
71func mapCompoundAssignmentInt32() {
72	m := make(map[int32]int32, 0)
73	var k int32 = 0
74
75	// 386:-".*mapaccess"
76	// amd64:-".*mapaccess"
77	// arm:-".*mapaccess"
78	// arm64:-".*mapaccess"
79	m[k] += 67890
80
81	// 386:-".*mapaccess"
82	// amd64:-".*mapaccess"
83	// arm:-".*mapaccess"
84	// arm64:-".*mapaccess"
85	m[k] -= 123
86
87	// 386:-".*mapaccess"
88	// amd64:-".*mapaccess"
89	// arm:-".*mapaccess"
90	// arm64:-".*mapaccess"
91	m[k] *= 456
92
93	// 386:-".*mapaccess"
94	// amd64:-".*mapaccess"
95	// arm:-".*mapaccess"
96	// arm64:-".*mapaccess"
97	m[k] |= 78
98
99	// 386:-".*mapaccess"
100	// amd64:-".*mapaccess"
101	// arm:-".*mapaccess"
102	// arm64:-".*mapaccess"
103	m[k] ^= 89
104
105	// 386:-".*mapaccess"
106	// amd64:-".*mapaccess"
107	// arm:-".*mapaccess"
108	// arm64:-".*mapaccess"
109	m[k] <<= 9
110
111	// 386:-".*mapaccess"
112	// amd64:-".*mapaccess"
113	// arm:-".*mapaccess"
114	// arm64:-".*mapaccess"
115	m[k] >>= 10
116
117	// 386:-".*mapaccess"
118	// amd64:-".*mapaccess"
119	// arm:-".*mapaccess"
120	// arm64:-".*mapaccess"
121	m[k]++
122
123	// 386:-".*mapaccess"
124	// amd64:-".*mapaccess"
125	// arm:-".*mapaccess"
126	// arm64:-".*mapaccess"
127	m[k]--
128}
129
130func mapCompoundAssignmentInt64() {
131	m := make(map[int64]int64, 0)
132	var k int64 = 0
133
134	// 386:-".*mapaccess"
135	// amd64:-".*mapaccess"
136	// arm:-".*mapaccess"
137	// arm64:-".*mapaccess"
138	m[k] += 67890
139
140	// 386:-".*mapaccess"
141	// amd64:-".*mapaccess"
142	// arm:-".*mapaccess"
143	// arm64:-".*mapaccess"
144	m[k] -= 123
145
146	// 386:-".*mapaccess"
147	// amd64:-".*mapaccess"
148	// arm:-".*mapaccess"
149	// arm64:-".*mapaccess"
150	m[k] *= 456
151
152	// 386:-".*mapaccess"
153	// amd64:-".*mapaccess"
154	// arm:-".*mapaccess"
155	// arm64:-".*mapaccess"
156	m[k] |= 78
157
158	// 386:-".*mapaccess"
159	// amd64:-".*mapaccess"
160	// arm:-".*mapaccess"
161	// arm64:-".*mapaccess"
162	m[k] ^= 89
163
164	// 386:-".*mapaccess"
165	// amd64:-".*mapaccess"
166	// arm:-".*mapaccess"
167	// arm64:-".*mapaccess"
168	m[k] <<= 9
169
170	// 386:-".*mapaccess"
171	// amd64:-".*mapaccess"
172	// arm:-".*mapaccess"
173	// arm64:-".*mapaccess"
174	m[k] >>= 10
175
176	// 386:-".*mapaccess"
177	// amd64:-".*mapaccess"
178	// arm:-".*mapaccess"
179	// arm64:-".*mapaccess"
180	m[k]++
181
182	// 386:-".*mapaccess"
183	// amd64:-".*mapaccess"
184	// arm:-".*mapaccess"
185	// arm64:-".*mapaccess"
186	m[k]--
187}
188
189func mapCompoundAssignmentComplex128() {
190	m := make(map[complex128]complex128, 0)
191	var k complex128 = 0
192
193	// 386:-".*mapaccess"
194	// amd64:-".*mapaccess"
195	// arm:-".*mapaccess"
196	// arm64:-".*mapaccess"
197	m[k] += 67890
198
199	// 386:-".*mapaccess"
200	// amd64:-".*mapaccess"
201	// arm:-".*mapaccess"
202	// arm64:-".*mapaccess"
203	m[k] -= 123
204
205	// 386:-".*mapaccess"
206	// amd64:-".*mapaccess"
207	// arm:-".*mapaccess"
208	// arm64:-".*mapaccess"
209	m[k] *= 456
210
211	// 386:-".*mapaccess"
212	// amd64:-".*mapaccess"
213	// arm:-".*mapaccess"
214	// arm64:-".*mapaccess"
215	m[k]++
216
217	// 386:-".*mapaccess"
218	// amd64:-".*mapaccess"
219	// arm:-".*mapaccess"
220	// arm64:-".*mapaccess"
221	m[k]--
222}
223
224func mapCompoundAssignmentString() {
225	m := make(map[string]string, 0)
226	var k string = "key"
227
228	// 386:-".*mapaccess"
229	// amd64:-".*mapaccess"
230	// arm:-".*mapaccess"
231	// arm64:-".*mapaccess"
232	m[k] += "value"
233}
234
235var sinkAppend bool
236
237func mapAppendAssignmentInt8() {
238	m := make(map[int8][]int8, 0)
239	var k int8 = 0
240
241	// 386:-".*mapaccess"
242	// amd64:-".*mapaccess"
243	// arm:-".*mapaccess"
244	// arm64:-".*mapaccess"
245	m[k] = append(m[k], 1)
246
247	// 386:-".*mapaccess"
248	// amd64:-".*mapaccess"
249	// arm:-".*mapaccess"
250	// arm64:-".*mapaccess"
251	m[k] = append(m[k], 1, 2, 3)
252
253	a := []int8{7, 8, 9, 0}
254
255	// 386:-".*mapaccess"
256	// amd64:-".*mapaccess"
257	// arm:-".*mapaccess"
258	// arm64:-".*mapaccess"
259	m[k] = append(m[k], a...)
260
261	// Exceptions
262
263	// 386:".*mapaccess"
264	// amd64:".*mapaccess"
265	// arm:".*mapaccess"
266	// arm64:".*mapaccess"
267	m[k] = append(a, m[k]...)
268
269	// 386:".*mapaccess"
270	// amd64:".*mapaccess"
271	// arm:".*mapaccess"
272	// arm64:".*mapaccess"
273	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
274
275	// 386:".*mapaccess"
276	// amd64:".*mapaccess"
277	// arm:".*mapaccess"
278	// arm64:".*mapaccess"
279	m[k] = append(m[k+1], 100)
280}
281
282func mapAppendAssignmentInt32() {
283	m := make(map[int32][]int32, 0)
284	var k int32 = 0
285
286	// 386:-".*mapaccess"
287	// amd64:-".*mapaccess"
288	// arm:-".*mapaccess"
289	// arm64:-".*mapaccess"
290	m[k] = append(m[k], 1)
291
292	// 386:-".*mapaccess"
293	// amd64:-".*mapaccess"
294	// arm:-".*mapaccess"
295	// arm64:-".*mapaccess"
296	m[k] = append(m[k], 1, 2, 3)
297
298	a := []int32{7, 8, 9, 0}
299
300	// 386:-".*mapaccess"
301	// amd64:-".*mapaccess"
302	// arm:-".*mapaccess"
303	// arm64:-".*mapaccess"
304	m[k] = append(m[k], a...)
305
306	// 386:-".*mapaccess"
307	// amd64:-".*mapaccess"
308	// arm:-".*mapaccess"
309	// arm64:-".*mapaccess"
310	m[k+1] = append(m[k+1], a...)
311
312	// 386:-".*mapaccess"
313	// amd64:-".*mapaccess"
314	// arm:-".*mapaccess"
315	// arm64:-".*mapaccess"
316	m[-k] = append(m[-k], a...)
317
318	// Exceptions
319
320	// 386:".*mapaccess"
321	// amd64:".*mapaccess"
322	// arm:".*mapaccess"
323	// arm64:".*mapaccess"
324	m[k] = append(a, m[k]...)
325
326	// 386:".*mapaccess"
327	// amd64:".*mapaccess"
328	// arm:".*mapaccess"
329	// arm64:".*mapaccess"
330	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
331
332	// 386:".*mapaccess"
333	// amd64:".*mapaccess"
334	// arm:".*mapaccess"
335	// arm64:".*mapaccess"
336	m[k] = append(m[k+1], 100)
337}
338
339func mapAppendAssignmentInt64() {
340	m := make(map[int64][]int64, 0)
341	var k int64 = 0
342
343	// 386:-".*mapaccess"
344	// amd64:-".*mapaccess"
345	// arm:-".*mapaccess"
346	// arm64:-".*mapaccess"
347	m[k] = append(m[k], 1)
348
349	// 386:-".*mapaccess"
350	// amd64:-".*mapaccess"
351	// arm:-".*mapaccess"
352	// arm64:-".*mapaccess"
353	m[k] = append(m[k], 1, 2, 3)
354
355	a := []int64{7, 8, 9, 0}
356
357	// 386:-".*mapaccess"
358	// amd64:-".*mapaccess"
359	// arm:-".*mapaccess"
360	// arm64:-".*mapaccess"
361	m[k] = append(m[k], a...)
362
363	// 386:-".*mapaccess"
364	// amd64:-".*mapaccess"
365	// arm:-".*mapaccess"
366	// arm64:-".*mapaccess"
367	m[k+1] = append(m[k+1], a...)
368
369	// 386:-".*mapaccess"
370	// amd64:-".*mapaccess"
371	// arm:-".*mapaccess"
372	// arm64:-".*mapaccess"
373	m[-k] = append(m[-k], a...)
374
375	// Exceptions
376
377	// 386:".*mapaccess"
378	// amd64:".*mapaccess"
379	// arm:".*mapaccess"
380	// arm64:".*mapaccess"
381	m[k] = append(a, m[k]...)
382
383	// 386:".*mapaccess"
384	// amd64:".*mapaccess"
385	// arm:".*mapaccess"
386	// arm64:".*mapaccess"
387	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
388
389	// 386:".*mapaccess"
390	// amd64:".*mapaccess"
391	// arm:".*mapaccess"
392	// arm64:".*mapaccess"
393	m[k] = append(m[k+1], 100)
394}
395
396func mapAppendAssignmentComplex128() {
397	m := make(map[complex128][]complex128, 0)
398	var k complex128 = 0
399
400	// 386:-".*mapaccess"
401	// amd64:-".*mapaccess"
402	// arm:-".*mapaccess"
403	// arm64:-".*mapaccess"
404	m[k] = append(m[k], 1)
405
406	// 386:-".*mapaccess"
407	// amd64:-".*mapaccess"
408	// arm:-".*mapaccess"
409	// arm64:-".*mapaccess"
410	m[k] = append(m[k], 1, 2, 3)
411
412	a := []complex128{7, 8, 9, 0}
413
414	// 386:-".*mapaccess"
415	// amd64:-".*mapaccess"
416	// arm:-".*mapaccess"
417	// arm64:-".*mapaccess"
418	m[k] = append(m[k], a...)
419
420	// Exceptions
421
422	// 386:".*mapaccess"
423	// amd64:".*mapaccess"
424	// arm:".*mapaccess"
425	// arm64:".*mapaccess"
426	m[k] = append(a, m[k]...)
427
428	// 386:".*mapaccess"
429	// amd64:".*mapaccess"
430	// arm:".*mapaccess"
431	// arm64:".*mapaccess"
432	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
433
434	// 386:".*mapaccess"
435	// amd64:".*mapaccess"
436	// arm:".*mapaccess"
437	// arm64:".*mapaccess"
438	m[k] = append(m[k+1], 100)
439}
440
441func mapAppendAssignmentString() {
442	m := make(map[string][]string, 0)
443	var k string = "key"
444
445	// 386:-".*mapaccess"
446	// amd64:-".*mapaccess"
447	// arm:-".*mapaccess"
448	// arm64:-".*mapaccess"
449	m[k] = append(m[k], "1")
450
451	// 386:-".*mapaccess"
452	// amd64:-".*mapaccess"
453	// arm:-".*mapaccess"
454	// arm64:-".*mapaccess"
455	m[k] = append(m[k], "1", "2", "3")
456
457	a := []string{"7", "8", "9", "0"}
458
459	// 386:-".*mapaccess"
460	// amd64:-".*mapaccess"
461	// arm:-".*mapaccess"
462	// arm64:-".*mapaccess"
463	m[k] = append(m[k], a...)
464
465	// Exceptions
466
467	// 386:".*mapaccess"
468	// amd64:".*mapaccess"
469	// arm:".*mapaccess"
470	// arm64:".*mapaccess"
471	m[k] = append(a, m[k]...)
472
473	// 386:".*mapaccess"
474	// amd64:".*mapaccess"
475	// arm:".*mapaccess"
476	// arm64:".*mapaccess"
477	sinkAppend, m[k] = !sinkAppend, append(m[k], "99")
478
479	// 386:".*mapaccess"
480	// amd64:".*mapaccess"
481	// arm:".*mapaccess"
482	// arm64:".*mapaccess"
483	m[k] = append(m[k+"1"], "100")
484}
485