none/tests/mips32/MoveIns.c

   1 #if defined(__mips_hard_float)
   2
   3 #include <stdint.h>
   4 #include <stdio.h>
   5
   6 const 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
  15 unsigned 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
  26 unsigned 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
 271 int 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 #if (__mips_isa_rev < 6)
 428    printf("MOVF\n");
 429    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, 0xffffffff, t0, t1, 1);
 430    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 0xffffffff, t0, t1, 0);
 431    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  555, 0xffffffff, t0, t1, 1);
 432    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, 5, t0, t1, 0);
 433    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0, -1, t0, t1, 1);
 434    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 25, t0, t1, 0);
 435    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 0, t0, t1, 1);
 436    TESTINSNMOVE2("movf $t0, $t1, $fcc0",  0xffffffff, 66, t0, t1, 0);
 437    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, 0xffffffff, t0, t1, 1);
 438    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 0xffffffff, t0, t1, 0);
 439    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  555, 0xffffffff, t0, t1, 1);
 440    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, 5, t0, t1, 0);
 441    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0, -1, t0, t1, 1);
 442    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 25, t0, t1, 0);
 443    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 0, t0, t1, 1);
 444    TESTINSNMOVE2("movf $t0, $t1, $fcc4",  0xffffffff, 66, t0, t1, 0);
 445
 446    printf("MOVF.S\n");
 447    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 0);
 448    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 4);
 449    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 8);
 450    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 12);
 451    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 16);
 452    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 20);
 453    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 24);
 454    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 28);
 455    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 32);
 456    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 36)
 457    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 40)
 458    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 44)
 459    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 48)
 460    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 52)
 461    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 1, 56)
 462    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 0);
 463    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 4);
 464    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 8);
 465    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 12);
 466    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 16);
 467    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 20);
 468    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 24);
 469    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 28);
 470    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 32);
 471    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 36);
 472    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 40);
 473    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 44);
 474    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 48);
 475    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 52);
 476    TESTINSNMOVE2s("movf.s $f4, $f6, $fcc0", f4, f6, 0, 56);
 477
 478    printf("MOVF.D\n");
 479    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 0);
 480    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 8);
 481    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 16);
 482    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 24);
 483    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 32);
 484    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 40);
 485    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 48);
 486    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 56);
 487    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 64);
 488    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 0)
 489    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 8)
 490    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 16)
 491    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 24)
 492    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 32)
 493    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 1, 40)
 494    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 48);
 495    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 56);
 496    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 64);
 497    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 0);
 498    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 8);
 499    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 16);
 500    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 24);
 501    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 32);
 502    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 40);
 503    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 48);
 504    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 56);
 505    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 64);
 506    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 0);
 507    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 8);
 508    TESTINSNMOVE2d("movf.d $f4, $f6, $fcc0", f4, f6, 0, 16);
 509
 510    printf("MOVN.S\n");
 511    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 0, 0, f0, f2, t3);
 512    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 4, 1, f0, f2, t3);
 513    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
 514    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 12, -1, f0, f2, t3);
 515    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 16, 5, f0, f2, t3);
 516    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 20, 0, f0, f2, t3);
 517    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
 518    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 28, 5, f0, f2, t3);
 519    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 32, 125487, f0, f2, t3);
 520    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 36, 68, f0, f2, t3);
 521    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 40, -122544, f0, f2, t3);
 522    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 44, 0, f0, f2, t3);
 523    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 48, 0, f0, f2, t3);
 524    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
 525    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
 526    TESTINSNMOVEN1s("movn.s $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
 527
 528    printf("MOVN.D\n");
 529    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 0, 0, f0, f2, t3);
 530    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 4, 1, f0, f2, t3);
 531    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
 532    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 12, -1, f0, f2, t3);
 533    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 16, 5, f0, f2, t3);
 534    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 20, 0, f0, f2, t3);
 535    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 24, 0, f0, f2, t3);
 536    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 28, 5, f0, f2, t3);
 537    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 32, 125487, f0, f2, t3);
 538    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 36, 68, f0, f2, t3);
 539    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 40, -122544, f0, f2, t3);
 540    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 44, 0, f0, f2, t3);
 541    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 48, 0, f0, f2, t3);
 542    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
 543    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
 544    TESTINSNMOVEN1s("movn.d $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
 545
 546    printf("MOVT\n");
 547    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, 0xffffffff, t0, t1, 1);
 548    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 0xffffffff, t0, t1, 0);
 549    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  555, 0xffffffff, t0, t1, 1);
 550    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, 5, t0, t1, 0);
 551    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0, -1, t0, t1, 1);
 552    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 25, t0, t1, 0);
 553    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 0, t0, t1, 1);
 554    TESTINSNMOVE2("movt $t0, $t1, $fcc0",  0xffffffff, 66, t0, t1, 0);
 555    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, 0xffffffff, t0, t1, 1);
 556    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 0xffffffff, t0, t1, 0);
 557    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  555, 0xffffffff, t0, t1, 1);
 558    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, 5, t0, t1, 0);
 559    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0, -1, t0, t1, 1);
 560    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 25, t0, t1, 0);
 561    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 0, t0, t1, 1);
 562    TESTINSNMOVE2("movt $t0, $t1, $fcc4",  0xffffffff, 66, t0, t1, 0);
 563
 564    printf("MOVT.S\n");
 565    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 0);
 566    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 4);
 567    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 8);
 568    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 12);
 569    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 16);
 570    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 20);
 571    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 24);
 572    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 28);
 573    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 32);
 574    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 36)
 575    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 40)
 576    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 44)
 577    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 48)
 578    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 52)
 579    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 1, 56)
 580    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 0);
 581    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 4);
 582    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 8);
 583    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 12);
 584    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 16);
 585    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 20);
 586    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 24);
 587    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 28);
 588    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 32);
 589    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 36);
 590    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 40);
 591    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 44);
 592    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 48);
 593    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 52);
 594    TESTINSNMOVE2s("movt.s $f4, $f6, $fcc0", f4, f6, 0, 56);
 595
 596    printf("MOVT.D\n");
 597    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 0);
 598    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 8);
 599    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 16);
 600    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 24);
 601    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 32);
 602    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 40);
 603    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 48);
 604    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 56);
 605    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 64);
 606    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 0)
 607    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 8)
 608    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 16)
 609    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 24)
 610    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 32)
 611    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 1, 40)
 612    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 48);
 613    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 56);
 614    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 64);
 615    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 0);
 616    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 8);
 617    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 16);
 618    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 24);
 619    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 32);
 620    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 40);
 621    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 48);
 622    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 56);
 623    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 64);
 624    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 0);
 625    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 8);
 626    TESTINSNMOVE2d("movt.d $f4, $f6, $fcc0", f4, f6, 0, 16);
 627
 628    printf("MOVZ.S\n");
 629    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 0, 0, f0, f2, t3);
 630    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 4, 1, f0, f2, t3);
 631    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
 632    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 12, -1, f0, f2, t3);
 633    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 16, 5, f0, f2, t3);
 634    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 20, 0, f0, f2, t3);
 635    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
 636    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 24, 0, f0, f2, t3);
 637    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 28, 5, f0, f2, t3);
 638    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 32, 125487, f0, f2, t3);
 639    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 36, 68, f0, f2, t3);
 640    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 40, -122544, f0, f2, t3);
 641    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 44, 0, f0, f2, t3);
 642    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 48, 0, f0, f2, t3);
 643    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
 644    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
 645    TESTINSNMOVEN1s("movz.s $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
 646
 647    printf("MOVZ.D\n");
 648    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 0, 0, f0, f2, t3);
 649    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 4, 1, f0, f2, t3);
 650    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 8, 0xffff, f0, f2, t3);
 651    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 12, -1, f0, f2, t3);
 652    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 16, 5, f0, f2, t3);
 653    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 20, 0, f0, f2, t3);
 654    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 24, 0, f0, f2, t3);
 655    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 28, 5, f0, f2, t3);
 656    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 32, 125487, f0, f2, t3);
 657    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 36, 68, f0, f2, t3);
 658    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 40, -122544, f0, f2, t3);
 659    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 44, 0, f0, f2, t3);
 660    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 48, 0, f0, f2, t3);
 661    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 52, 0xffffffff, f0, f2, t3);
 662    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 56, 0x80000000, f0, f2, t3);
 663    TESTINSNMOVEN1s("movz.d $f0, $f2, $t3", 60, 0x7fffffff, f0, f2, t3);
 664 #endif
 665
 666    return 0;
 667 }
 668 #else
 669 int main() {
 670    return 0;
 671 }
 672 #endif