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
10 TEXT 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)
240 label0:
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 // }
269 label1:
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 // }
277 label2:
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 // }
288 label3:
289 BLTZ R1, 1(PC)
290 BLTZ R1, label3 // BLTZ R1, 85
291
292 //
293 // floating point conditional branch
294 //
295 // LBRA rel
296 label4:
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 RET foo(SB)
426
427 // unary operation
428 NEGW R1, R2 // 00011023
429 CLZ R1, R2 // 70221020
430 CLO R1, R2 // 70221021
431
432 WSBH R1, R2 // 7c0110a0
433
434 SEB R1, R2 // 7c011420
435 SEH R1, R2 // 7c011620
436
437 // to (Hi, Lo)
438 MADD R2, R1 // 70220000
439 MSUB R2, R1 // 70220004
440 MUL R2, R1 // 00220018
441
442 // END
443 //
444 // LEND comma // asm doesn't support the trailing comma.
445 // {
446 // outcode(int($1), &nullgen, 0, &nullgen);
447 // }
448 END
449
View as plain text