1// Copyright 2016 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 input was created by taking the mips64 testcase and modified
6// by hand.
7
8#include "../../../../../runtime/textflag.h"
9
10TEXT foo(SB),DUPOK|NOSPLIT,$0
11
12	//inst:
13	//
14	// load ints and bytes
15	//
16	//	LMOVW rreg ',' rreg
17	//	{
18	//		outcode(int($1), &$2, 0, &$4);
19	//	}
20	MOVW	R1, R2
21	MOVW	LO, R1
22	MOVW	HI, R1
23	MOVW	R1, LO
24	MOVW	R1, HI
25	MOVW	R1, R2
26	MOVW	LO, R1
27	MOVW	HI, R1
28	MOVW	R1, LO
29	MOVW	R1, HI
30
31	//	LMOVW addr ',' rreg
32	//	{
33	//		outcode(int($1), &$2, 0, &$4);
34	//	}
35	MOVW	foo<>+3(SB), R2
36	MOVW	16(R1), R2
37	MOVW	(R1), R2
38	MOVW	foo<>+3(SB), R2
39	MOVW	16(R1), R2
40	MOVW	(R1), R2
41	LL	(R1), R2
42
43	//	LMOVB rreg ',' rreg
44	//	{
45	//		outcode(int($1), &$2, 0, &$4);
46	//	}
47	MOVB	R1, R2
48
49	//	LMOVB addr ',' rreg
50	//	{
51	//		outcode(int($1), &$2, 0, &$4);
52	//	}
53	MOVB	foo<>+3(SB), R2
54	MOVB	16(R1), R2
55	MOVB	(R1), R2
56
57	//
58	// load floats
59	//
60	//	LFMOV addr ',' freg
61	//	{
62	//		outcode(int($1), &$2, 0, &$4);
63	//	}
64	MOVF	foo<>+3(SB), F2
65	MOVF	16(R1), F2
66	MOVF	(R1), F2
67
68	//	LFMOV fimm ',' freg
69	//	{
70	//		outcode(int($1), &$2, 0, &$4);
71	//	}
72	MOVF	$0.1, F2	// MOVF $(0.10000000000000001), F2
73
74	//	LFMOV freg ',' freg
75	//	{
76	//		outcode(int($1), &$2, 0, &$4);
77	//	}
78	MOVF	F1, F2
79
80	//	LFMOV freg ',' addr
81	//	{
82	//		outcode(int($1), &$2, 0, &$4);
83	//	}
84	MOVF	F2, foo<>+3(SB)
85	MOVF	F2, 16(R1)
86	MOVF	F2, (R1)
87
88	//
89	// store ints and bytes
90	//
91	//	LMOVW rreg ',' addr
92	//	{
93	//		outcode(int($1), &$2, 0, &$4);
94	//	}
95	MOVW	R1, foo<>+3(SB)
96	MOVW	R1, 16(R2)
97	MOVW	R1, (R2)
98	MOVW	R1, foo<>+3(SB)
99	MOVW	R1, 16(R2)
100	MOVW	R1, (R2)
101	SC	R1, (R2)
102
103	//	LMOVB rreg ',' addr
104	//	{
105	//		outcode(int($1), &$2, 0, &$4);
106	//	}
107	MOVB	R1, foo<>+3(SB)
108	MOVB	R1, 16(R2)
109	MOVB	R1, (R2)
110
111	//
112	// store floats
113	//
114	//	LMOVW freg ',' addr
115	//	{
116	//		outcode(int($1), &$2, 0, &$4);
117	//	}
118	MOVD	F1, foo<>+3(SB)
119	MOVD	F1, 16(R2)
120	MOVD	F1, (R2)
121
122	//
123	// floating point status
124	//
125	//	LMOVW fpscr ',' freg
126	//	{
127	//		outcode(int($1), &$2, 0, &$4);
128	//	}
129	MOVW	FCR0, R1
130
131	//	LMOVW freg ','  fpscr
132	//	{
133	//		outcode(int($1), &$2, 0, &$4);
134	//	}
135	MOVW	R1, FCR0
136
137	//	LMOVW rreg ',' mreg
138	//	{
139	//		outcode(int($1), &$2, 0, &$4);
140	//	}
141	MOVW	R1, M1
142	MOVW	R1, M1
143
144	//	LMOVW mreg ',' rreg
145	//	{
146	//		outcode(int($1), &$2, 0, &$4);
147	//	}
148	MOVW	M1, R1
149	MOVW	M1, R1
150
151
152	//
153	// integer operations
154	// logical instructions
155	// shift instructions
156	// unary instructions
157	//
158	//	LADDW rreg ',' sreg ',' rreg
159	//	{
160	//		outcode(int($1), &$2, int($4), &$6);
161	//	}
162	ADD	R1, R2, R3
163
164	//	LADDW imm ',' sreg ',' rreg
165	//	{
166	//		outcode(int($1), &$2, int($4), &$6);
167	//	}
168	ADD	$1, R2, R3
169
170	//	LADDW rreg ',' rreg
171	//	{
172	//		outcode(int($1), &$2, 0, &$4);
173	//	}
174	ADD	R1, R2
175
176	//	LADDW imm ',' rreg
177	//	{
178	//		outcode(int($1), &$2, 0, &$4);
179	//	}
180	ADD	$4, R1
181
182	//	LMUL rreg ',' rreg
183	//	{
184	//		outcode(int($1), &$2, 0, &$4);
185	//	}
186	MUL	R1, R2
187
188	//	LSHW rreg ',' sreg ',' rreg
189	//	{
190	//		outcode(int($1), &$2, int($4), &$6);
191	//	}
192	SLL	R1, R2, R3
193
194	//	LSHW rreg ',' rreg
195	//	{
196	//		outcode(int($1), &$2, 0, &$4);
197	//	}
198	SLL	R1, R2
199
200	//	LSHW imm ',' sreg ',' rreg
201	//	{
202	//		outcode(int($1), &$2, int($4), &$6);
203	//	}
204	SLL	$4, R1, R2
205
206	//	LSHW imm ',' rreg
207	//	{
208	//		outcode(int($1), &$2, 0, &$4);
209	//	}
210	SLL	$4, R1
211
212	//
213	// move immediate: macro for lui+or, addi, addis, and other combinations
214	//
215	//	LMOVW imm ',' rreg
216	//	{
217	//		outcode(int($1), &$2, 0, &$4);
218	//	}
219	MOVW	$1, R1
220	MOVW	$1, R1
221
222	//	LMOVW ximm ',' rreg
223	//	{
224	//		outcode(int($1), &$2, 0, &$4);
225	//	}
226	MOVW	$1, R1
227	MOVW	$foo(SB), R1
228	MOVW	$1, R1
229	MOVW	$foo(SB), R1
230
231
232	//
233	// branch
234	//
235	//	LBRA rel
236	//	{
237	//		outcode(int($1), &nullgen, 0, &$2);
238	//	}
239	BEQ	R1, 2(PC)
240label0:
241	JMP	1(PC)
242	BEQ	R1, 2(PC)
243	JMP	label0+0	// JMP 66
244	BEQ	R1, 2(PC)
245	JAL	1(PC)	// CALL 1(PC)
246	BEQ	R1, 2(PC)
247	JAL	label0+0	// CALL 66
248
249	//	LBRA addr
250	//	{
251	//		outcode(int($1), &nullgen, 0, &$2);
252	//	}
253	BEQ	R1, 2(PC)
254	JMP	0(R1)	// JMP (R1)
255	BEQ	R1, 2(PC)
256	JMP	foo+0(SB)	// JMP foo(SB)
257	BEQ	R1, 2(PC)
258	JAL	0(R1)	// CALL (R1)
259	BEQ	R1, 2(PC)
260	JAL	foo+0(SB)	// CALL foo(SB)
261
262//
263// BEQ/BNE
264//
265//	LBRA rreg ',' rel
266//	{
267//		outcode(int($1), &$2, 0, &$4);
268//	}
269label1:
270	BEQ	R1, 1(PC)
271	BEQ	R1, label1	// BEQ R1, 81
272
273//	LBRA rreg ',' sreg ',' rel
274//	{
275//		outcode(int($1), &$2, 0, &$4);
276//	}
277label2:
278	BEQ	R1, R2, 1(PC)
279	BEQ	R1, R2, label2	// BEQ R1, R2, 83
280
281//
282// other integer conditional branch
283//
284//	LBRA rreg ',' rel
285//	{
286//		outcode(int($1), &$2, 0, &$4);
287//	}
288label3:
289	BLTZ	R1, 1(PC)
290	BLTZ	R1, label3	// BLTZ R1, 85
291
292//
293// floating point conditional branch
294//
295//	LBRA rel
296label4:
297	BFPT	1(PC)
298	BFPT	label4	// BFPT 87
299
300
301	//
302	// floating point operate
303	//
304	//	LFCONV freg ',' freg
305	//	{
306	//		outcode(int($1), &$2, 0, &$4);
307	//	}
308	ABSD	F1, F2
309
310	//	LFADD freg ',' freg
311	//	{
312	//		outcode(int($1), &$2, 0, &$4);
313	//	}
314	ADDD	F1, F2
315
316	//	LFADD freg ',' freg ',' freg
317	//	{
318	//		outcode(int($1), &$2, int($4.Reg), &$6);
319	//	}
320	ADDD	F1, F2, F3
321
322	//	LFCMP freg ',' freg
323	//	{
324	//		outcode(int($1), &$2, 0, &$4);
325	//	}
326	CMPEQD	F1, F2
327
328
329	//
330	// WORD
331	//
332	WORD	$1
333
334	//
335	// NOP
336	//
337	//	LNOP comma // asm doesn't support the trailing comma.
338	//	{
339	//		outcode(int($1), &nullgen, 0, &nullgen);
340	//	}
341	NOP
342
343	//	LNOP rreg comma // asm doesn't support the trailing comma.
344	//	{
345	//		outcode(int($1), &$2, 0, &nullgen);
346	//	}
347	NOP	R2
348
349	//	LNOP freg comma // asm doesn't support the trailing comma.
350	//	{
351	//		outcode(int($1), &$2, 0, &nullgen);
352	//	}
353	NOP	F2
354
355	//	LNOP ',' rreg // asm doesn't support the leading comma.
356	//	{
357	//		outcode(int($1), &nullgen, 0, &$3);
358	//	}
359	NOP	R2
360
361	//	LNOP ',' freg // asm doesn't support the leading comma.
362	//	{
363	//		outcode(int($1), &nullgen, 0, &$3);
364	//	}
365	NOP	F2
366
367	//	LNOP imm
368	//	{
369	//		outcode(int($1), &$2, 0, &nullgen);
370	//	}
371	NOP	$4
372
373	//
374	// special
375	//
376	SYSCALL
377	BREAK
378	SYNC
379
380	//
381	// conditional move on zero/nonzero gp value
382	//
383	CMOVN	R1, R2, R3
384	CMOVZ	R1, R2, R3
385
386	//
387	// conditional move on fp false/true
388	//
389	CMOVF	R1, R2
390	CMOVT	R1, R2
391
392	//
393	// conditional traps
394	//
395	TEQ	$1, R1, R2
396	TEQ	$1, R1
397
398
399	//
400	// other
401	//
402	CLO	R1, R2
403	SQRTD	F0, F1
404	MUL	R1, R2, R3
405
406
407	//
408	// RET
409	//
410	//	LRETRN	comma // asm doesn't support the trailing comma.
411	//	{
412	//		outcode(int($1), &nullgen, 0, &nullgen);
413	//	}
414	SYSCALL
415	BEQ	R1, 2(PC)
416	RET
417
418
419	// More JMP/JAL cases, and canonical names JMP, CALL.
420
421	JAL	foo(SB)	// CALL foo(SB)
422	BEQ	R1, 2(PC)
423	JMP	foo(SB)
424	CALL	foo(SB)
425
426	// END
427	//
428	//	LEND	comma // asm doesn't support the trailing comma.
429	//	{
430	//		outcode(int($1), &nullgen, 0, &nullgen);
431	//	}
432	END
433