1#if defined(__mips_hard_float)
2
3#include <stdint.h>
4#include <stdio.h>
5
6const float fs_f[] = {
7   0, 456.2489562, 3, -1,
8   1384.6, -7.2945676, 1000000000, -5786.47,
9   1752, 0.0024575, 0.00000001, -248562.76,
10   -45786.476, 456.2489562, 34.00046, 45786.476,
11   1752065, 107, -45667.24, -7.2945676,
12   -347856.475, 356047.56, -1.0, 23.04
13};
14
15unsigned long long data[] = {
16   0x1234567887654321ull, 0x66785bd668466667ull,
17   0xBFF550ff07788000ull, 0x0004789236500000ull,
18   0x3FF0001256789600ull, 0x0012365478000000ull,
19   0x252a2e2b252a2e2bull, 0x26852147962d2d2aull,
20   0x1234567887654321ull, 0x66785bd668466667ull,
21   0x789651ff07788055ull, 0x00ff23f4f1f5f6f8ull,
22   0x3FF0001256789600ull, 0xaabbcdfeefcd1256ull,
23   0xa1b2b2a1a3a5a6aaull, 0x2569874123654786ull
24};
25
26unsigned int mem[] = {
27   0x4095A266, 0x66666666,
28   0xBFF00000, 0x00000000,
29   0x3FF00000, 0x00000000,
30   0x252a2e2b, 0x262d2d2a,
31   0xFFFFFFFF, 0xFFFFFFFF,
32   0x41D26580, 0xB487E5C9,
33   0x42026580, 0xB750E388,
34   0x3E45798E, 0xE2308C3A,
35   0x3FBF9ADD, 0x3746F65F
36};
37
38// mfc1 rt, fs
39#define TESTINSNMOVE(instruction, offset, FS, RT)          \
40{                                                          \
41   float out;                                              \
42   int out1;                                               \
43   __asm__ volatile(                                       \
44      ".set push \n\t"                                     \
45      ".set oddspreg \n\t"                                 \
46      "move $t0, %2\n\t"                                   \
47      "lwc1 $" #FS ", "#offset"($t0)\n\t"                  \
48      instruction "\n\t"                                   \
49      "mov.s %0, $" #FS"\n\t"                              \
50      "move %1, $" #RT "\n\t"                              \
51      ".set pop \n\t"                                      \
52      : "=f" (out), "=r" (out1)                            \
53      : "r" (mem)                                          \
54      : "t0", "$"#FS, #RT, "memory"                        \
55   );                                                      \
56   printf("%s :: fs %f, rt 0x%x\n",                        \
57          instruction, out, out1);                         \
58}
59
60// mfhc1 rt, fs
61#define TESTINSNMOVEd(instruction, offset, FS, RT)         \
62{                                                          \
63   unsigned int out;                                       \
64   __asm__ volatile(                                       \
65      "move $t0, %1\n\t"                                   \
66      "ldc1 $" #FS ", "#offset"($t0)\n\t"                  \
67      instruction "\n\t"                                   \
68      "move %0, $" #RT "\n\t"                              \
69      : "=r" (out)                                         \
70      : "r" (data)                                         \
71      : "t0", "$"#FS, #RT, "memory"                        \
72   );                                                      \
73   printf("%s :: rt 0x%x\n",                               \
74          instruction, out);                               \
75}
76
77// mtc1 rt, fs
78#define TESTINSNMOVEt(instruction, offset, FS, RT)         \
79{                                                          \
80   float out;                                              \
81   int out1;                                               \
82   __asm__ volatile(                                       \
83      ".set push \n\t"                                     \
84      ".set oddspreg \n\t"                                 \
85      "move $t0, %2\n\t"                                   \
86      "lw $" #RT ", "#offset"($t0)\n\t"                    \
87      instruction "\n\t"                                   \
88      "mov.s %0, $" #FS"\n\t"                              \
89      "move %1, $" #RT "\n\t"                              \
90      ".set pop \n\t"                                      \
91      : "=f" (out), "=r" (out1)                            \
92      : "r" (mem)                                          \
93      : "t0", "$"#FS, #RT, "memory"                        \
94   );                                                      \
95   printf("%s :: fs %f, rt 0x%x\n",                        \
96          instruction, out, out1);                         \
97}
98
99// mthc1 rt, fs
100#define TESTINSNMOVEtd(instruction, offset, offset2, FS, RT)    \
101{                                                               \
102   unsigned long long out = 0;                                  \
103   __asm__ volatile (                                           \
104      "move $t0, %2 \n\t"                                       \
105      "move $t1, %1 \n\t"                                       \
106      "ldc1 $"#FS"," #offset2"($t0)" "\n\t"                     \
107      "lw $"#RT"," #offset"($t1) \n\t"                          \
108      instruction "\n\t"                                        \
109      "move $"#RT", %0 \n\t"                                    \
110      "sdc1 $"#FS ", 0($"#RT")" "\n\t"                          \
111      : : "r" (&out),  "r" (mem), "r" (data)                    \
112      : "t0", "t1", "$"#FS, #RT, "memory"                       \
113   );                                                           \
114   printf("%s :: out: %llx\n", instruction, out);               \
115}
116
117// mov.s fd, fs
118#define TESTINSNMOVE1s(instruction, offset, FD, FS)             \
119{                                                               \
120   float out;                                                   \
121   int out1;                                                    \
122   __asm__ volatile(                                            \
123      ".set push \n\t"                                          \
124      ".set oddspreg \n\t"                                      \
125      "move $t0, %2\n\t"                                        \
126      "lwc1 $" #FS ", "#offset"($t0)\n\t"                       \
127      instruction "\n\t"                                        \
128      "mov.s %0, $" #FD"\n\t"                                   \
129      "mfc1 %1, $" #FD"\n\t"                                    \
130      ".set pop \n\t"                                           \
131      : "=f" (out), "=r" (out1)                                 \
132      : "r" (fs_f)                                              \
133      : "t0", "$"#FS, "$"#FD, "memory"                          \
134   );                                                           \
135   printf("%s :: fs %f, rt 0x%x\n",                             \
136          instruction, out, out1);                              \
137}
138
139// mov.d fd, fs
140#define TESTINSNMOVE1d(instruction, offset, FD, FS)             \
141{                                                               \
142   double out;                                                  \
143   int out1;                                                    \
144   __asm__ volatile(                                            \
145      "move $t0, %2\n\t"                                        \
146      "ldc1 $" #FS ", "#offset"($t0)\n\t"                       \
147      instruction "\n\t"                                        \
148      "mov.d %0, $" #FD"\n\t"                                   \
149      "mfc1 %1, $" #FD"\n\t"                                    \
150      : "=f" (out), "=r" (out1)                                 \
151      : "r" (fs_f)                                              \
152      : "t0", "$"#FS, "$"#FD, "memory"                          \
153   );                                                           \
154   printf("%s ::fs %f, rt 0x%x\n",                              \
155          instruction, out, out1);                              \
156}
157
158// movf rd, rs
159#define TESTINSNMOVE2(instruction, RDval, RSval, RD, RS, cc)    \
160{                                                               \
161   int out;                                                     \
162   __asm__ volatile(                                            \
163      "li $t0, 1\n\t"                                           \
164      "move $t1, %3\n\t"                                        \
165      "mtc1 $t0, $f0\n\t"                                       \
166      "mtc1 $t1, $f2\n\t"                                       \
167      "c.eq.s $f0, $f2\n\t"                                     \
168      "move $" #RS ", %1\n\t"                                   \
169      "move $" #RD ", %2\n\t"                                   \
170      instruction "\n\t"                                        \
171      "move %0, $" #RD "\n\t"                                   \
172      : "=r" (out)                                              \
173      : "r" (RSval), "r" (RDval), "r" (cc)                      \
174      : "t0", "t1", #RD, #RS                                    \
175   );                                                           \
176   printf("%s :: out: 0x%x, RDval: 0x%x, RSval: 0x%x, cc: %d\n",\
177          instruction, out, RDval, RSval, cc);                  \
178}
179
180// movf.s fd, fs
181#define TESTINSNMOVE2s(instruction, FD, FS, cc, offset)         \
182{                                                               \
183   float out;                                                   \
184   __asm__ volatile(                                            \
185      "li $t0, 1\n\t"                                           \
186      "move $t1, %1\n\t"                                        \
187      "mtc1 $t0, $f0\n\t"                                       \
188      "mtc1 $t1, $f2\n\t"                                       \
189      "c.eq.s $f0, $f2\n\t"                                     \
190      "move $t0, %2\n\t"                                        \
191      "lwc1 $" #FD ", 4($t0)\n\t"                               \
192      "lwc1 $" #FS ", "#offset"($t0)\n\t"                       \
193      instruction "\n\t"                                        \
194      "mov.s %0, $" #FD"\n\t"                                   \
195      : "=f" (out)                                              \
196      : "r" (cc), "r" (fs_f)                                    \
197      : "t0", "t1", "$"#FD, "$"#FS, "memory"                    \
198   );                                                           \
199   printf("%s :: out: %f, cc: %d\n",                            \
200          instruction, out, cc);                                \
201}
202
203// movf.d fd, fs
204#define TESTINSNMOVE2d(instruction, FD, FS, cc, offset)             \
205{                                                                   \
206   double out;                                                      \
207   uint64_t outl;                                                   \
208   __asm__ volatile(                                                \
209      "li $t0, 1 \n\t"                                              \
210      "move $t1, %1 \n\t"                                           \
211      "mtc1 $t0, $f0 \n\t"                                          \
212      "mtc1 $t1, $f2 \n\t"                                          \
213      "move $t0, %2 \n\t"                                           \
214      "ldc1 $f4, 8($t0) \n\t"                                       \
215      "c.eq.s $f0, $f2\n\t"                                         \
216      "ldc1 $" #FS ", "#offset"($t0)\n\t"                           \
217      instruction "\n\t"                                            \
218      "mov.d %0, $" #FD"\n\t"                                       \
219      "sdc1 $f4, 0(%3)"                                             \
220      : "=&f" (out)                                                 \
221      : "r" (cc), "r" (mem), "r" (&outl)                            \
222      : "t0", "t1", "$f0", "$f2", "$f4", "$"#FS, "$"#FD, "memory"   \
223   );                                                               \
224   printf("%s :: out: 0x%x 0x%x, cc: %d\n",                         \
225          instruction, (uint32_t)outl, (uint32_t)(outl >> 32), cc); \
226}
227
228// movn.s fd, fs, rt
229#define TESTINSNMOVEN1s(instruction, offset, RTval, FD, FS, RT)     \
230{                                                                   \
231   float out;                                                       \
232   int out1;                                                        \
233   __asm__ volatile(                                                \
234      "move $" #RT ", %3\n\t"                                       \
235      "move $t0, %2\n\t"                                            \
236      "lwc1 $" #FS ", "#offset"($t0)\n\t"                           \
237      "mtc1 $0, $" #FD "\n\t"                                       \
238      instruction "\n\t"                                            \
239      "mov.s %0, $" #FD"\n\t"                                       \
240      "mfc1 %1, $" #FD"\n\t"                                        \
241      : "=f" (out), "=r" (out1)                                     \
242      : "r" (fs_f), "r" (RTval)                                     \
243      : "t0", "$"#FS, "$"#FD, #RT, "memory"                         \
244   );                                                               \
245   printf("%s :: fs rt 0x%x\n",                                     \
246          instruction, out1);                                       \
247}
248
249// movn.d fd, fs, rt
250#define TESTINSNMOVEN1d(instruction, offset, RTval, FD, FS, RT)     \
251{                                                                   \
252   double out;                                                      \
253   int out1;                                                        \
254   __asm__ volatile(                                                \
255      "move $" #RT ", %3\n\t"                                       \
256      "move $t0, %2\n\t"                                            \
257      "ldc1 $" #FS ", "#offset"($t0)\n\t"                           \
258      "mtc1 $0, $" #FD "\n\t"                                       \
259      "mtc1 $0, $" #FD + 1"\n\t"                                    \
260      instruction "\n\t"                                            \
261      "mov.d %0, $" #FD"\n\t"                                       \
262      "mfc1 %1, $" #FD"\n\t"                                        \
263      : "=f" (out), "=r" (out1)                                     \
264      : "r" (fs_f), "r" (RTval)                                     \
265      : "t0", "$"#FS, "$"#FD, #RT, "memory"                         \
266   );                                                               \
267   printf("%s :: fs %lf, rt 0x%x\n",                                \
268          instruction, out, out1);                                  \
269}
270
271int main()
272{
273   printf("MFC1\n");
274   TESTINSNMOVE("mfc1 $t1, $f0",  0, f0, t1);
275   TESTINSNMOVE("mfc1 $t2, $f1", 4, f1, t2);
276   TESTINSNMOVE("mfc1 $t3, $f2",  8, f2, t3);
277   TESTINSNMOVE("mfc1 $t4, $f3", 12, f3, t4);
278   TESTINSNMOVE("mfc1 $t5, $f4", 16, f4, t5);
279   TESTINSNMOVE("mfc1 $t6, $f5", 20, f5, t6);
280   TESTINSNMOVE("mfc1 $t7, $f6", 24, f6, t7);
281   TESTINSNMOVE("mfc1 $v0, $f7", 28, f7, v0);
282   TESTINSNMOVE("mfc1 $v1, $f8", 32, f8, v1);
283   TESTINSNMOVE("mfc1 $s0, $f9", 36, f9, s0);
284   TESTINSNMOVE("mfc1 $s1, $f10", 40, f10, s1);
285   TESTINSNMOVE("mfc1 $s2, $f11", 44, f11, s2);
286   TESTINSNMOVE("mfc1 $s3, $f12", 48, f12, s3);
287   TESTINSNMOVE("mfc1 $s4, $f13", 52, f13, s4);
288   TESTINSNMOVE("mfc1 $s5, $f14", 56, f14, s5);
289   TESTINSNMOVE("mfc1 $s6, $f15", 60, f15, s6);
290   TESTINSNMOVE("mfc1 $s7, $f16", 64, f16, s7);
291   TESTINSNMOVE("mfc1 $a0, $f17", 0, f17, a0);
292   TESTINSNMOVE("mfc1 $a1, $f18", 4, f18, a1);
293   TESTINSNMOVE("mfc1 $a2, $f19", 8, f19, a2);
294   TESTINSNMOVE("mfc1 $a3, $f20", 12, f20, a3);
295   TESTINSNMOVE("mfc1 $v0, $f21", 16, f21, v0);
296   TESTINSNMOVE("mfc1 $v1, $f22", 20, f22, v1);
297   TESTINSNMOVE("mfc1 $t8, $f23", 24, f23, t8);
298   TESTINSNMOVE("mfc1 $t9, $f24", 28, f24, t9);
299   TESTINSNMOVE("mfc1 $t1, $f25", 32, f25, t1);
300   TESTINSNMOVE("mfc1 $t2, $f26", 36, f26, t2);
301
302   printf("MTC1\n");
303   TESTINSNMOVEt("mtc1 $t1, $f0",  0, f0, t1);
304   TESTINSNMOVEt("mtc1 $t2, $f1", 4, f1, t2);
305   TESTINSNMOVEt("mtc1 $t3, $f2",  8, f2, t3);
306   TESTINSNMOVEt("mtc1 $t4, $f3", 12, f3, t4);
307   TESTINSNMOVEt("mtc1 $t5, $f4", 16, f4, t5);
308   TESTINSNMOVEt("mtc1 $t6, $f5", 20, f5, t6);
309   TESTINSNMOVEt("mtc1 $t7, $f6", 24, f6, t7);
310   TESTINSNMOVEt("mtc1 $v0, $f7", 28, f7, v0);
311   TESTINSNMOVEt("mtc1 $v1, $f8", 32, f8, v1);
312   TESTINSNMOVEt("mtc1 $s0, $f9", 36, f9, s0);
313   TESTINSNMOVEt("mtc1 $s1, $f10", 40, f10, s1);
314   TESTINSNMOVEt("mtc1 $s2, $f11", 44, f11, s2);
315   TESTINSNMOVEt("mtc1 $s3, $f12", 48, f12, s3);
316   TESTINSNMOVEt("mtc1 $s4, $f13", 52, f13, s4);
317   TESTINSNMOVEt("mtc1 $s5, $f14", 56, f14, s5);
318   TESTINSNMOVEt("mtc1 $s6, $f15", 60, f15, s6);
319   TESTINSNMOVEt("mtc1 $s7, $f16", 64, f16, s7);
320   TESTINSNMOVEt("mtc1 $a0, $f17", 2, f17, a0);
321   TESTINSNMOVEt("mtc1 $a1, $f18", 6, f18, a1);
322   TESTINSNMOVEt("mtc1 $a2, $f19", 10, f19, a2);
323   TESTINSNMOVEt("mtc1 $a3, $f20", 14, f20, a3);
324   TESTINSNMOVEt("mtc1 $v0, $f21", 18, f21, v0);
325   TESTINSNMOVEt("mtc1 $v1, $f22", 22, f22, v1);
326   TESTINSNMOVEt("mtc1 $t8, $f23", 26, f23, t8);
327   TESTINSNMOVEt("mtc1 $t9, $f24", 30, f24, t9);
328   TESTINSNMOVEt("mtc1 $t1, $f25", 34, f25, t1);
329   TESTINSNMOVEt("mtc1 $t2, $f26", 38, f26, t2);
330
331#if defined(__mips__) && ((defined(__mips_isa_rev) && __mips_isa_rev >= 2))
332   printf("MFHC1\n");
333   TESTINSNMOVEd("mfhc1 $t1, $f0",    0,  f0, t1);
334   TESTINSNMOVEd("mfhc1 $t2, $f2",    8,  f2, t2);
335   TESTINSNMOVEd("mfhc1 $t3, $f4",   16,  f4, t3);
336   TESTINSNMOVEd("mfhc1 $v0, $f6",   24,  f6, v0);
337   TESTINSNMOVEd("mfhc1 $v1, $f8",   32,  f8, v1);
338   TESTINSNMOVEd("mfhc1 $a0, $f10",  40, f10, a0);
339   TESTINSNMOVEd("mfhc1 $a1, $f12",  48, f12, a1);
340   TESTINSNMOVEd("mfhc1 $a2, $f14",  56, f14, a2);
341   TESTINSNMOVEd("mfhc1 $a3, $f16",  64, f16, a3);
342   TESTINSNMOVEd("mfhc1 $s0, $f18",  72, f18, s0);
343   TESTINSNMOVEd("mfhc1 $s1, $f20",  80, f20, s1);
344   TESTINSNMOVEd("mfhc1 $s2, $f22",  88, f22, s2);
345   TESTINSNMOVEd("mfhc1 $s3, $f24",  96, f24, s3);
346   TESTINSNMOVEd("mfhc1 $s4, $f26", 104, f26, s4);
347   TESTINSNMOVEd("mfhc1 $s5, $f28", 112, f28, s5);
348   TESTINSNMOVEd("mfhc1 $s6, $f30", 120, f30, s6);
349
350   printf("MTHC1\n");
351   TESTINSNMOVEtd("mthc1 $t2, $f0",   0,   0,  f0, t2);
352   TESTINSNMOVEtd("mthc1 $t3, $f2",   4,   8,  f2, t3);
353   TESTINSNMOVEtd("mthc1 $v0, $f4",   8,  16,  f4, v0);
354   TESTINSNMOVEtd("mthc1 $v1, $f6",  12,  24,  f6, v1);
355   TESTINSNMOVEtd("mthc1 $a0, $f8",  16,  32,  f8, a0);
356   TESTINSNMOVEtd("mthc1 $a1, $f10", 20,  40, f10, a1);
357   TESTINSNMOVEtd("mthc1 $a2, $f12", 24,  48, f12, a2);
358   TESTINSNMOVEtd("mthc1 $a3, $f14", 28,  56, f14, a3);
359   TESTINSNMOVEtd("mthc1 $s0, $f16", 32,  64, f16, s0);
360   TESTINSNMOVEtd("mthc1 $s1, $f18", 36,  72, f18, s1);
361   TESTINSNMOVEtd("mthc1 $s2, $f20", 40,  80, f20, s2);
362   TESTINSNMOVEtd("mthc1 $s3, $f22", 44,  88, f22, s3);
363   TESTINSNMOVEtd("mthc1 $s4, $f24", 48,  96, f24, s4);
364   TESTINSNMOVEtd("mthc1 $s5, $f26", 52, 104, f26, s5);
365   TESTINSNMOVEtd("mthc1 $s6, $f28", 56, 112, f28, s6);
366   TESTINSNMOVEtd("mthc1 $s7, $f30", 60, 120, f30, s7);
367#endif
368
369   printf("MOV.S\n");
370   TESTINSNMOVE1s("mov.s $f0, $f0",  0, f0, f0);
371   TESTINSNMOVE1s("mov.s $f0, $f1", 4, f0, f1);
372   TESTINSNMOVE1s("mov.s $f1, $f2",  8, f1, f2);
373   TESTINSNMOVE1s("mov.s $f2, $f3", 12, f2, f3);
374   TESTINSNMOVE1s("mov.s $f3, $f4", 16, f3, f4);
375   TESTINSNMOVE1s("mov.s $f4, $f5", 20, f4, f5);
376   TESTINSNMOVE1s("mov.s $f5, $f6", 24, f5, f6);
377   TESTINSNMOVE1s("mov.s $f6, $f7", 28, f6, f7);
378   TESTINSNMOVE1s("mov.s $f7, $f8", 32, f7, f8);
379   TESTINSNMOVE1s("mov.s $f8, $f9", 36, f8, f9);
380   TESTINSNMOVE1s("mov.s $f9, $f10", 40, f9, f10);
381   TESTINSNMOVE1s("mov.s $f10, $f11", 44, f10, f11);
382   TESTINSNMOVE1s("mov.s $f11, $f12", 48, f11, f12);
383   TESTINSNMOVE1s("mov.s $f12, $f13", 52, f12, f13);
384   TESTINSNMOVE1s("mov.s $f13, $f14", 56, f13, f14);
385   TESTINSNMOVE1s("mov.s $f14, $f15", 60, f14, f15);
386   TESTINSNMOVE1s("mov.s $f15, $f16", 64, f15, f16);
387   TESTINSNMOVE1s("mov.s $f16, $f17", 0, f16, f17);
388   TESTINSNMOVE1s("mov.s $f17, $f18", 4, f17, f18);
389   TESTINSNMOVE1s("mov.s $f18, $f19", 8, f18, f19);
390   TESTINSNMOVE1s("mov.s $f19, $f20", 12, f19, f20);
391   TESTINSNMOVE1s("mov.s $f20, $f21", 16, f20, f21);
392   TESTINSNMOVE1s("mov.s $f21, $f22", 20, f21, f22);
393   TESTINSNMOVE1s("mov.s $f22, $f23", 24, f22, f23);
394   TESTINSNMOVE1s("mov.s $f23, $f24", 28, f23, f24);
395   TESTINSNMOVE1s("mov.s $f24, $f25", 32, f24, f25);
396   TESTINSNMOVE1s("mov.s $f25, $f26", 36, f25, f26);
397
398   printf("MOV.D\n");
399   TESTINSNMOVE1d("mov.d $f0, $f0",  0, f0, f0);
400   TESTINSNMOVE1d("mov.d $f0, $f0", 8, f0, f0);
401   TESTINSNMOVE1d("mov.d $f0, $f2",  16, f0, f2);
402   TESTINSNMOVE1d("mov.d $f2, $f4", 24, f2, f4);
403   TESTINSNMOVE1d("mov.d $f2, $f4", 32, f2, f4);
404   TESTINSNMOVE1d("mov.d $f4, $f6", 40, f4, f6);
405   TESTINSNMOVE1d("mov.d $f4, $f6", 48, f4, f6);
406   TESTINSNMOVE1d("mov.d $f6, $f8", 56, f6, f8);
407   TESTINSNMOVE1d("mov.d $f6, $f8", 64, f6, f8);
408   TESTINSNMOVE1d("mov.d $f8, $f10", 0, f8, f10);
409   TESTINSNMOVE1d("mov.d $f8, $f10", 8, f8, f10);
410   TESTINSNMOVE1d("mov.d $f10, $f12", 16, f10, f12);
411   TESTINSNMOVE1d("mov.d $f10, $f12", 24, f10, f12);
412   TESTINSNMOVE1d("mov.d $f12, $f14", 32, f12, f14);
413   TESTINSNMOVE1d("mov.d $f12, $f14", 40, f12, f14);
414   TESTINSNMOVE1d("mov.d $f14, $f16", 48, f14, f16);
415   TESTINSNMOVE1d("mov.d $f14, $f16", 56, f14, f16);
416   TESTINSNMOVE1d("mov.d $f16, $f18", 64, f16, f18);
417   TESTINSNMOVE1d("mov.d $f16, $f18", 0, f16, f18);
418   TESTINSNMOVE1d("mov.d $f18, $f20", 8, f18, f20);
419   TESTINSNMOVE1d("mov.d $f18, $f20", 16, f18, f20);
420   TESTINSNMOVE1d("mov.d $f20, $f22", 24, f20, f22);
421   TESTINSNMOVE1d("mov.d $f20, $f22", 32, f20, f22);
422   TESTINSNMOVE1d("mov.d $f22, $f24", 40, f22, f24);
423   TESTINSNMOVE1d("mov.d $f22, $f24", 48, f22, f24);
424   TESTINSNMOVE1d("mov.d $f24, $f26", 56, f24, f26);
425   TESTINSNMOVE1d("mov.d $f24, $f26", 64, f24, f26);
426
427   printf("MOVF\n");
428   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, 0xffffffff, t0, t1, 1);
429   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 0xffffffff, t0, t1, 0);
430   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  555, 0xffffffff, t0, t1, 1);
431   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, 5, t0, t1, 0);
432   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, -1, t0, t1, 1);
433   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 25, t0, t1, 0);
434   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 0, t0, t1, 1);
435   TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 66, t0, t1, 0);
436   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, 0xffffffff, t0, t1, 1);
437   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 0xffffffff, t0, t1, 0);
438   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  555, 0xffffffff, t0, t1, 1);
439   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, 5, t0, t1, 0);
440   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, -1, t0, t1, 1);
441   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 25, t0, t1, 0);
442   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 0, t0, t1, 1);
443   TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 66, t0, t1, 0);
444
445   printf("MOVF.S\n");
446   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 0);
447   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 4);
448   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 8);
449   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 12);
450   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 16);
451   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 20);
452   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 24);
453   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 28);
454   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 32);
455   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 36)
456   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 40)
457   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 44)
458   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 48)
459   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 52)
460   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 56)
461   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 0);
462   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 4);
463   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 8);
464   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 12);
465   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 16);
466   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 20);
467   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 24);
468   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 28);
469   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 32);
470   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 36);
471   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 40);
472   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 44);
473   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 48);
474   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 52);
475   TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 56);
476
477   printf("MOVF.D\n");
478   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 0);
479   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 8);
480   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 16);
481   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 24);
482   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 32);
483   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 40);
484   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 48);
485   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 56);
486   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 64);
487   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 0)
488   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 8)
489   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 16)
490   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 24)
491   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 32)
492   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 40)
493   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 48);
494   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 56);
495   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 64);
496   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 0);
497   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 8);
498   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 16);
499   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 24);
500   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 32);
501   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 40);
502   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 48);
503   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 56);
504   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 64);
505   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 0);
506   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 8);
507   TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 16);
508
509   printf("MOVN.S\n");
510   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 0, 0, f0, f2, t3);
511   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 4, 1, f0, f2, t3);
512   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
513   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 12, -1, f0, f2, t3);
514   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 16, 5, f0, f2, t3);
515   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 20, 0, f0, f2, t3);
516   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
517   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 28, 5, f0, f2, t3);
518   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 32, 125487, f0, f2, t3);
519   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 36, 68, f0, f2, t3);
520   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 40, -122544, f0, f2, t3);
521   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 44, 0, f0, f2, t3);
522   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 48, 0, f0, f2, t3);
523   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
524   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
525   TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
526
527   printf("MOVN.D\n");
528   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 0, 0, f0, f2, t3);
529   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 4, 1, f0, f2, t3);
530   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
531   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 12, -1, f0, f2, t3);
532   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 16, 5, f0, f2, t3);
533   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 20, 0, f0, f2, t3);
534   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 24, 0, f0, f2, t3);
535   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 28, 5, f0, f2, t3);
536   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 32, 125487, f0, f2, t3);
537   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 36, 68, f0, f2, t3);
538   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 40, -122544, f0, f2, t3);
539   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 44, 0, f0, f2, t3);
540   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 48, 0, f0, f2, t3);
541   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
542   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
543   TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
544
545   printf("MOVT\n");
546   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, 0xffffffff, t0, t1, 1);
547   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 0xffffffff, t0, t1, 0);
548   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  555, 0xffffffff, t0, t1, 1);
549   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, 5, t0, t1, 0);
550   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, -1, t0, t1, 1);
551   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 25, t0, t1, 0);
552   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 0, t0, t1, 1);
553   TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 66, t0, t1, 0);
554   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, 0xffffffff, t0, t1, 1);
555   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 0xffffffff, t0, t1, 0);
556   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  555, 0xffffffff, t0, t1, 1);
557   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, 5, t0, t1, 0);
558   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, -1, t0, t1, 1);
559   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 25, t0, t1, 0);
560   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 0, t0, t1, 1);
561   TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 66, t0, t1, 0);
562
563   printf("MOVT.S\n");
564   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 0);
565   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 4);
566   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 8);
567   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 12);
568   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 16);
569   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 20);
570   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 24);
571   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 28);
572   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 32);
573   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 36)
574   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 40)
575   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 44)
576   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 48)
577   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 52)
578   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 56)
579   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 0);
580   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 4);
581   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 8);
582   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 12);
583   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 16);
584   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 20);
585   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 24);
586   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 28);
587   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 32);
588   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 36);
589   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 40);
590   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 44);
591   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 48);
592   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 52);
593   TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 56);
594
595   printf("MOVT.D\n");
596   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 0);
597   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 8);
598   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 16);
599   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 24);
600   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 32);
601   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 40);
602   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 48);
603   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 56);
604   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 64);
605   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 0)
606   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 8)
607   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 16)
608   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 24)
609   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 32)
610   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 40)
611   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 48);
612   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 56);
613   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 64);
614   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 0);
615   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 8);
616   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 16);
617   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 24);
618   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 32);
619   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 40);
620   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 48);
621   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 56);
622   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 64);
623   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 0);
624   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 8);
625   TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 16);
626
627   printf("MOVZ.S\n");
628   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 0, 0, f0, f2, t3);
629   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 4, 1, f0, f2, t3);
630   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
631   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 12, -1, f0, f2, t3);
632   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 16, 5, f0, f2, t3);
633   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 20, 0, f0, f2, t3);
634   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
635   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
636   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 28, 5, f0, f2, t3);
637   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 32, 125487, f0, f2, t3);
638   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 36, 68, f0, f2, t3);
639   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 40, -122544, f0, f2, t3);
640   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 44, 0, f0, f2, t3);
641   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 48, 0, f0, f2, t3);
642   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
643   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
644   TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
645
646   printf("MOVZ.D\n");
647   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 0, 0, f0, f2, t3);
648   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 4, 1, f0, f2, t3);
649   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
650   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 12, -1, f0, f2, t3);
651   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 16, 5, f0, f2, t3);
652   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 20, 0, f0, f2, t3);
653   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 24, 0, f0, f2, t3);
654   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 28, 5, f0, f2, t3);
655   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 32, 125487, f0, f2, t3);
656   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 36, 68, f0, f2, t3);
657   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 40, -122544, f0, f2, t3);
658   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 44, 0, f0, f2, t3);
659   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 48, 0, f0, f2, t3);
660   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
661   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
662   TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
663
664   return 0;
665}
666#else
667int main() {
668   return 0;
669}
670#endif
671