Home | History | Annotate | Download | only in mips32
      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    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
    667 int main() {
    668    return 0;
    669 }
    670 #endif
    671