none/tests/mips64/branches.c

   1 #include <stdio.h>
   2
   3 #define TESTINST1(RSval, RD)            \
   4 {                                       \
   5    unsigned int out = 0;                \
   6    __asm__ __volatile__(                \
   7       ".set noreorder"          "\n\t"  \
   8       "move $"#RD", %1"         "\n\t"  \
   9       "b    end"#RSval          "\n\t"  \
  10       "nop"                     "\n\t"  \
  11       "addiu $"#RD", $"#RD", 5"  "\n\t" \
  12       "end"#RSval":"            "\n\t"  \
  13       "addiu $"#RD", $"#RD", 1"  "\n\t" \
  14       "move %0,     $"#RD       "\n\t"  \
  15       ".set reorder"            "\n\t"  \
  16       : "=r" (out)                      \
  17       : "r" (RSval)                     \
  18       : #RD                             \
  19    );                                   \
  20    printf("B :: %d, RSval: %d\n",       \
  21           out, RSval);                  \
  22 }
  23
  24 #define TESTINST2(RSval, RD)            \
  25 {                                       \
  26    unsigned int out = 0;                \
  27    __asm__ __volatile__(                \
  28       ".set noreorder"          "\n\t"  \
  29       "move $"#RD", %1"         "\n\t"  \
  30       "b    end12"#RSval        "\n\t"  \
  31       "addiu $"#RD", $"#RD", 3"  "\n\t" \
  32       "addiu $"#RD", $"#RD", 5"  "\n\t" \
  33       "end12"#RSval":"          "\n\t"  \
  34       "addiu $"#RD", $"#RD", 3"  "\n\t" \
  35       "move %0,     $"#RD       "\n\t"  \
  36       ".set reorder"            "\n\t"  \
  37       : "=r" (out)                      \
  38       : "r" (RSval)                     \
  39       : #RD                             \
  40    );                                   \
  41    printf("B :: %d, RSval: %d\n",       \
  42           out, RSval);                  \
  43 }
  44
  45 #define TESTINST3(RSval, RD)              \
  46 {                                         \
  47    unsigned int out = 0;                  \
  48    __asm__ __volatile__(                  \
  49       ".set noreorder"          "\n\t"    \
  50       "move $"#RD", %1"         "\n\t"    \
  51       "bal  end21"#RSval        "\n\t"    \
  52       "nop"                     "\n\t"    \
  53       "addiu $"#RD", $"#RD", 5"  "\n\t"   \
  54       "b    r_end"#RSval        "\n\t"    \
  55       "nop"                     "\n\t"    \
  56       "addiu $"#RD", $"#RD", 1"  "\n\t"   \
  57       "end21"#RSval":"          "\n\t"    \
  58       "addiu $"#RD", $"#RD", 1"  "\n\t"   \
  59       "jr   $ra"                "\n\t"    \
  60       "nop"                     "\n\t"    \
  61       "r_end"#RSval":"          "\n\t"    \
  62       "move %0,     $"#RD       "\n\t"    \
  63       ".set reorder"            "\n\t"    \
  64       : "=r" (out)                        \
  65       : "r" (RSval)                       \
  66       : #RD, "ra"                         \
  67    );                                     \
  68    printf("B BAL JR :: %d, RSval: %d\n",  \
  69           out, RSval);                    \
  70 }
  71
  72 #define TESTINST3j(RSval, RD)               \
  73 {                                           \
  74    unsigned int out = 0;                    \
  75    __asm__ __volatile__(                    \
  76       ".set noreorder"              "\n\t"  \
  77       "move $"#RD", %1"             "\n\t"  \
  78       "dla  $t9,    end31"#RSval    "\n\t"  \
  79       "jal  $t9"                    "\n\t"  \
  80       "nop"                         "\n\t"  \
  81       "addiu $"#RD", $"#RD", 5"      "\n\t" \
  82       "dla  $t9,    r_end11"#RSval  "\n\t"  \
  83       "j    $t9"                    "\n\t"  \
  84       "nop"                         "\n\t"  \
  85       "end31"#RSval":"              "\n\t"  \
  86       "addiu $"#RD", $"#RD", 1"      "\n\t" \
  87       "jr   $ra"                    "\n\t"  \
  88       "nop"                         "\n\t"  \
  89       "r_end11"#RSval":"            "\n\t"  \
  90       "move %0, $"#RD               "\n\t"  \
  91       ".set reorder"                "\n\t"  \
  92       : "=r" (out)                          \
  93       : "r" (RSval)                         \
  94       : #RD, "t9"                           \
  95    );                                       \
  96    printf("J JAL JR :: %d, RSval: %d\n",    \
  97           out, RSval);                      \
  98 }
  99
 100 #define TESTINST3ja(RSval, RD)             \
 101 {                                          \
 102    unsigned int out = 0;                   \
 103    __asm__ __volatile__(                   \
 104       ".set noreorder"            "\n\t"   \
 105       "move $"#RD", %1"           "\n\t"   \
 106       "dla  $t9,    end41"#RSval  "\n\t"   \
 107       "jalr $t0,    $t9"          "\n\t"   \
 108       "nop"                       "\n\t"   \
 109       "addiu $"#RD", $"#RD", 5"    "\n\t"  \
 110       "dla  $t9, r_end21"#RSval   "\n\t"   \
 111       "j    $t9"                  "\n\t"   \
 112       "nop"                       "\n\t"   \
 113       "addiu $"#RD", $"#RD", 1"    "\n\t"  \
 114       "end41"#RSval":"            "\n\t"   \
 115       "addiu $"#RD", $"#RD", 1"    "\n\t"  \
 116       "move $t9,    $t0"          "\n\t"   \
 117       "jr   $t9"                  "\n\t"   \
 118       "nop"                       "\n\t"   \
 119       "r_end21"#RSval":"          "\n\t"   \
 120       "move %0,     $"#RD         "\n\t"   \
 121       ".set reorder"              "\n\t"   \
 122       : "=r" (out)                         \
 123       : "r" (RSval)                        \
 124       : #RD, "t0", "t9"                    \
 125    );                                      \
 126    printf("J JALR JR :: %d, RSval: %d\n",  \
 127           out, RSval);                     \
 128 }
 129
 130 #define TESTINST4(instruction, RDval, RSval, RTval, RD, RS, RT)         \
 131 {                                                                       \
 132    unsigned int out = 0;                                                \
 133    __asm__ __volatile__(                                                \
 134       ".set noreorder"                                    "\n\t"        \
 135       "move        $"#RS", %1"                            "\n\t"        \
 136       "move        $"#RT", %2"                            "\n\t"        \
 137       "move        $"#RD", %3"                            "\n\t"        \
 138       instruction" $"#RS", $"#RT", end"instruction#RDval  "\n\t"        \
 139       "nop"                                               "\n\t"        \
 140       "addiu        $"#RD", $"#RD", 5"                     "\n\t"       \
 141       "end"instruction#RDval":"                           "\n\t"        \
 142       "addiu        $"#RD", $"#RD", 1"                     "\n\t"       \
 143       "move        %0,     $" #RD                         "\n\t"        \
 144       ".set reorder"                                      "\n\t"        \
 145       : "=r" (out)                                                      \
 146       : "r" (RSval), "r" (RTval), "r" (RDval)                           \
 147       : #RD, #RS, #RT                                                   \
 148    );                                                                   \
 149    printf(instruction" :: out: %d, RDval: %d, RSval: %d, RTval: %d\n",  \
 150           out, RDval, RSval, RTval);                                    \
 151 }
 152
 153 #define TESTINST5(instruction, RDval, RSval, RD, RS)          \
 154 {                                                             \
 155    unsigned int out = 0;                                      \
 156    __asm__ __volatile__(                                      \
 157       ".set        noreorder"                     "\n\t"      \
 158       "move        $"#RS", %1"                    "\n\t"      \
 159       "move        $"#RD", %2"                    "\n\t"      \
 160       instruction" $"#RS", end"instruction#RDval  "\n\t"      \
 161       "nop"                                       "\n\t"      \
 162       "addiu        $"#RD", $"#RD", 5"             "\n\t"     \
 163       "end"instruction#RDval":"                   "\n\t"      \
 164       "addiu        $"#RD", $"#RD", 1"             "\n\t"     \
 165       "move        %0,     $"#RD                  "\n\t"      \
 166       ".set        reorder"                       "\n\t"      \
 167       : "=r" (out)                                            \
 168       : "r" (RSval), "r" (RDval)                              \
 169       : #RD, #RS                                              \
 170     );                                                        \
 171     printf(instruction" :: out: %d, RDval: %d, RSval: %d\n",  \
 172            out, RDval, RSval);                                \
 173 }
 174
 175 #define TESTINST6(instruction, RDval, RSval, RD, RS)         \
 176 {                                                            \
 177    unsigned int out = 0;                                     \
 178    __asm__ __volatile__(                                     \
 179       ".set        noreorder"                       "\n\t"   \
 180       "move        $"#RD", %2"                      "\n\t"   \
 181       "move        $"#RS", %1"                      "\n\t"   \
 182       instruction" $"#RS", end21"instruction#RDval  "\n\t"   \
 183       "nop"                                         "\n\t"   \
 184       "addiu        $"#RD", $"#RD", 5"               "\n\t"  \
 185       "b           r_end"instruction#RDval          "\n\t"   \
 186       "nop"                                         "\n\t"   \
 187       "end21"instruction#RDval":"                   "\n\t"   \
 188       "addiu        $"#RD", $"#RD", 1"               "\n\t"  \
 189       "jr          $ra"                             "\n\t"   \
 190       "r_end"instruction#RDval":"                   "\n\t"   \
 191       "move        %0, $"#RD                        "\n\t"   \
 192       ".set        reorder"                         "\n\t"   \
 193       : "=r" (out)                                           \
 194       : "r" (RSval), "r" (RDval)                             \
 195       : #RD, #RS, "ra"                                       \
 196    );                                                        \
 197    printf(instruction" :: out: %d, RDval: %d, RSval: %d\n",  \
 198           out, RDval, RSval);                                \
 199 }
 200
 201 #define TESTINST4l(instruction, RDval, RSval, RTval, RD, RS, RT)        \
 202 {                                                                       \
 203    unsigned int out = 0;                                                \
 204    __asm__ __volatile__(                                                \
 205       ".set        noreorder"                             "\n\t"        \
 206       "move        $"#RS", %1"                            "\n\t"        \
 207       "move        $"#RT", %2"                            "\n\t"        \
 208       "move        $"#RD", %3"                            "\n\t"        \
 209       instruction" $"#RS", $"#RT", end"instruction#RDval  "\n\t"        \
 210       "addiu        $"#RD", $"#RD", 3"                     "\n\t"       \
 211       "addiu        $"#RD", $"#RD", 5"                     "\n\t"       \
 212       "end"instruction#RDval":"                           "\n\t"        \
 213       "addiu        $"#RD", $"#RD", 1"                     "\n\t"       \
 214       "move        %0, $"#RD                              "\n\t"        \
 215       ".set        reorder"                               "\n\t"        \
 216       : "=r" (out)                                                      \
 217       : "r" (RSval), "r" (RTval), "r" (RDval)                           \
 218       : #RD, #RS, #RT                                                   \
 219    );                                                                   \
 220    printf(instruction" :: out: %d, RDval: %d, RSval: %d, RTval: %d\n",  \
 221           out, RDval, RSval, RTval);                                    \
 222 }
 223
 224 #define TESTINST5l(instruction, RDval, RSval, RD, RS)        \
 225 {                                                            \
 226    unsigned int out = 0;                                     \
 227    __asm__ __volatile__(                                     \
 228       ".set        noreorder"                     "\n\t"     \
 229       "move        $"#RS", %1"                    "\n\t"     \
 230       "move        $"#RD", %2"                    "\n\t"     \
 231       instruction" $"#RS", end"instruction#RDval  "\n\t"     \
 232       "addiu        $"#RD", $"#RD", 3"             "\n\t"    \
 233       "addiu        $"#RD", $"#RD", 5"             "\n\t"    \
 234       "end"instruction#RDval":"                   "\n\t"     \
 235       "addiu        $"#RD", $"#RD", 1"             "\n\t"    \
 236       "move        %0,     $"#RD                  "\n\t"     \
 237       ".set        reorder"                       "\n\t"     \
 238       : "=r" (out)                                           \
 239       : "r" (RSval), "r" (RDval)                             \
 240       : #RD, #RS                                             \
 241    );                                                        \
 242    printf(instruction" :: out: %d, RDval: %d, RSval: %d\n",  \
 243           out, RDval, RSval);                                \
 244 }
 245
 246 #define TESTINST6l(instruction, RDval, RSval, RD, RS)        \
 247 {                                                            \
 248    unsigned int out = 0;                                     \
 249    __asm__ __volatile__(                                     \
 250       ".set        noreorder"                       "\n\t"   \
 251       "move        $"#RD", %2"                      "\n\t"   \
 252       "move        $"#RS", %1"                      "\n\t"   \
 253       instruction" $"#RS", end21"instruction#RDval  "\n\t"   \
 254       "addiu        $"#RD", $"#RD", 3"               "\n\t"  \
 255       "addiu        $"#RD", $"#RD", 5"               "\n\t"  \
 256       "b           r_end"instruction#RDval          "\n\t"   \
 257       "nop"                                         "\n\t"   \
 258       "end21"instruction#RDval":"                   "\n\t"   \
 259       "addiu        $"#RD", $"#RD", 1"               "\n\t"  \
 260       "jr          $ra"                             "\n\t"   \
 261       "nop"                                         "\n\t"   \
 262       "r_end"instruction#RDval":"                   "\n\t"   \
 263       "move        %0, $"#RD                        "\n\t"   \
 264       ".set        reorder"                         "\n\t"   \
 265       : "=r" (out)                                           \
 266       : "r" (RSval), "r" (RDval)                             \
 267       : #RD, #RS, "ra"                                       \
 268    );                                                        \
 269    printf(instruction" :: out: %d, RDval: %d, RSval: %d\n",  \
 270           out, RDval, RSval);                                \
 271 }
 272
 273
 274 int main()
 275 {
 276
 277    printf("b\n");
 278    TESTINST1(0,  2);
 279    TESTINST1(1,  3);
 280    TESTINST1(2,  4);
 281    TESTINST1(3,  5);
 282    TESTINST1(4,  6);
 283    TESTINST1(5,  7);
 284    TESTINST1(6,  8);
 285    TESTINST1(7,  9);
 286    TESTINST1(8,  10);
 287    TESTINST1(9,  11);
 288    TESTINST1(10, 12);
 289    TESTINST1(11, 13);
 290    TESTINST1(12, 14);
 291    TESTINST1(13, 15);
 292    TESTINST1(14, 16);
 293    TESTINST1(15, 17);
 294    TESTINST1(16, 18);
 295    TESTINST1(17, 19);
 296    TESTINST1(18, 20);
 297    TESTINST1(19, 21);
 298    TESTINST1(20, 22);
 299    TESTINST1(21, 23);
 300    TESTINST1(22, 24);
 301    TESTINST1(23, 25);
 302
 303    printf("b\n");
 304    TESTINST2(0,  2);
 305    TESTINST2(1,  3);
 306    TESTINST2(2,  4);
 307    TESTINST2(3,  5);
 308    TESTINST2(4,  6);
 309    TESTINST2(5,  7);
 310    TESTINST2(6,  8);
 311    TESTINST2(7,  9);
 312    TESTINST2(8,  10);
 313    TESTINST2(9,  11);
 314    TESTINST2(10, 12);
 315    TESTINST2(11, 13);
 316    TESTINST2(12, 14);
 317    TESTINST2(13, 15);
 318    TESTINST2(14, 16);
 319    TESTINST2(15, 17);
 320    TESTINST2(16, 18);
 321    TESTINST2(17, 19);
 322    TESTINST2(18, 20);
 323    TESTINST2(19, 21);
 324    TESTINST2(20, 22);
 325    TESTINST2(21, 23);
 326    TESTINST2(22, 24);
 327    TESTINST2(23, 25);
 328
 329    printf("b, bal, jr\n");
 330    TESTINST3(0,  2);
 331    TESTINST3(1,  3);
 332    TESTINST3(2,  4);
 333    TESTINST3(3,  5);
 334    TESTINST3(4,  6);
 335    TESTINST3(5,  7);
 336    TESTINST3(6,  8);
 337    TESTINST3(7,  9);
 338    TESTINST3(8,  10);
 339    TESTINST3(9,  11);
 340    TESTINST3(10, 12);
 341    TESTINST3(11, 13);
 342    TESTINST3(12, 14);
 343    TESTINST3(13, 15);
 344    TESTINST3(14, 16);
 345    TESTINST3(15, 17);
 346    TESTINST3(16, 18);
 347    TESTINST3(17, 19);
 348    TESTINST3(18, 20);
 349    TESTINST3(19, 21);
 350    TESTINST3(20, 22);
 351    TESTINST3(21, 23);
 352    TESTINST3(22, 24);
 353    TESTINST3(23, 25);
 354
 355    printf("--- BEQ ---  if RSval == RTval then " \
 356           "out = RDval + 1 else out = RDval + 6\n");
 357    TESTINST4("beq", 0,  0,          1,          2,  3 , 4);
 358    TESTINST4("beq", 1,  1,          1,          3,  4,  5);
 359    TESTINST4("beq", 2,  0xffffffff, 0xffffffff, 4,  5,  6);
 360    TESTINST4("beq", 3,  0xffffffff, 0xfffffffe, 5,  6,  7);
 361    TESTINST4("beq", 4,  0xfffffffe, 0xffffffff, 6,  8,  9);
 362    TESTINST4("beq", 5,  0xffffffff, 0xffffffff, 7,  8,  9);
 363    TESTINST4("beq", 6,  0x5,        0x5,        8,  9,  10);
 364    TESTINST4("beq", 7,  -3,         -4,         9,  10, 11);
 365    TESTINST4("beq", 8,  125,        125,        10, 11, 12);
 366    TESTINST4("beq", 9,  0x80000000, 0x80000000, 11, 12, 13);
 367    TESTINST4("beq", 10, 0xffffffff, 0x80000000, 12, 13, 14);
 368    TESTINST4("beq", 11, 0x256,      0x256,      13, 14, 15);
 369    TESTINST4("beq", 12, 0x55,       0x55,       14, 15, 16);
 370    TESTINST4("beq", 13, 0xfff,      0xdd,       16, 17, 18);
 371    TESTINST4("beq", 14, -1,         0x5,        2,  25, 24);
 372    TESTINST4("beq", 15, -1,         -1,         25, 24, 7);
 373
 374    printf("--- BNE ---  if RSval != RTval then " \
 375           "out = RDval + 1 else out = RDval + 6\n");
 376    TESTINST4("bne", 0,  0,          1,          2,  3,  4);
 377    TESTINST4("bne", 1,  1,          1,          3,  4,  5);
 378    TESTINST4("bne", 2,  0xffffffff, 0xffffffff, 4,  5,  6);
 379    TESTINST4("bne", 3,  0xffffffff, 0xfffffffe, 5,  6,  7);
 380    TESTINST4("bne", 4,  0xfffffffe, 0xffffffff, 6,  8,  9);
 381    TESTINST4("bne", 5,  0xffffffff, 0xffffffff, 7,  8,  9);
 382    TESTINST4("bne", 6,  0x5,        0x5,        8,  9,  10);
 383    TESTINST4("bne", 7,  -3,         -4,         9,  10, 11);
 384    TESTINST4("bne", 8,  125,        125,        10, 11, 12);
 385    TESTINST4("bne", 9,  0x80000000, 0x80000000, 11, 12, 13);
 386    TESTINST4("bne", 10, 0xffffffff, 0x80000000, 12, 13, 14);
 387    TESTINST4("bne", 11, 0x256,      0x256,      13, 14, 15);
 388    TESTINST4("bne", 12, 0x55,       0x55,       14, 15, 16);
 389    TESTINST4("bne", 13, 0xfff,      0xdd,       16, 17, 18);
 390    TESTINST4("bne", 14, -1,         0x5,        2,  25, 24);
 391    TESTINST4("bne", 15, -1,         -1,         25, 24, 7);
 392
 393    printf("--- BEQZ ---  if RSval == 0 then " \
 394           "out = RDval + 1 else out = RDval + 6\n");
 395    TESTINST5("beqz", 0,  0,          2,  3);
 396    TESTINST5("beqz", 1,  1,          3,  4);
 397    TESTINST5("beqz", 2,  0xffffffff, 4,  5);
 398    TESTINST5("beqz", 3,  0xffffffff, 5,  6);
 399    TESTINST5("beqz", 4,  0xfffffffe, 6,  8);
 400    TESTINST5("beqz", 5,  0xffffffff, 7,  8);
 401    TESTINST5("beqz", 6,  0x5,        8,  9);
 402    TESTINST5("beqz", 7,  -3,         9,  10);
 403    TESTINST5("beqz", 8,  125,        10, 11);
 404    TESTINST5("beqz", 9,  0x80000000, 11, 12);
 405    TESTINST5("beqz", 10, 0xffffffff, 12, 13);
 406    TESTINST5("beqz", 11, 0x256,      13, 14);
 407    TESTINST5("beqz", 12, 0x55,       14, 15);
 408    TESTINST5("beqz", 13, 0xfff,      16, 17);
 409    TESTINST5("beqz", 14, -1,         2,  25);
 410    TESTINST5("beqz", 15, -1,         25, 24);
 411
 412    printf("--- BGEZ ---  if RSval >= 0 then " \
 413           "out = RDval + 1 else out = RDval + 6\n");
 414    TESTINST5("bgez", 0,  0,          2,  3);
 415    TESTINST5("bgez", 1,  1,          3,  4);
 416    TESTINST5("bgez", 2,  0xffffffff, 4,  5);
 417    TESTINST5("bgez", 3,  0xffffffff, 5,  6);
 418    TESTINST5("bgez", 4,  0xfffffffe, 6,  8);
 419    TESTINST5("bgez", 5,  0xffffffff, 7,  8);
 420    TESTINST5("bgez", 6,  0x5,        8,  9);
 421    TESTINST5("bgez", 7,  -3,         9,  10);
 422    TESTINST5("bgez", 8,  125,        10, 11);
 423    TESTINST5("bgez", 9,  0x80000000, 11, 12);
 424    TESTINST5("bgez", 10, 0xffffffff, 12, 13);
 425    TESTINST5("bgez", 11, 0x256,      13, 14);
 426    TESTINST5("bgez", 12, 0x55,       14, 15);
 427    TESTINST5("bgez", 13, 0xfff,      16, 17);
 428    TESTINST5("bgez", 14, -1,         2,  25);
 429    TESTINST5("bgez", 15, -1,         25, 24);
 430
 431    printf("--- BGTZ ---  if RSval > 0 then " \
 432           "out = RDval + 1 else out = RDval + 6\n");
 433    TESTINST5("bgtz", 0,  0,          2,  3);
 434    TESTINST5("bgtz", 1,  1,          3,  4);
 435    TESTINST5("bgtz", 2,  0xffffffff, 4,  5);
 436    TESTINST5("bgtz", 3,  0xffffffff, 5,  6);
 437    TESTINST5("bgtz", 4,  0xfffffffe, 6,  8);
 438    TESTINST5("bgtz", 5,  0xffffffff, 7,  8);
 439    TESTINST5("bgtz", 6,  0x5,        8,  9);
 440    TESTINST5("bgtz", 7,  -3,         9,  10);
 441    TESTINST5("bgtz", 8,  125,        10, 11);
 442    TESTINST5("bgtz", 9,  0x80000000, 11, 12);
 443    TESTINST5("bgtz", 10, 0xffffffff, 12, 13);
 444    TESTINST5("bgtz", 11, 0x256,      13, 14);
 445    TESTINST5("bgtz", 12, 0x55,       14, 15);
 446    TESTINST5("bgtz", 13, 0xfff,      16, 17);
 447    TESTINST5("bgtz", 14, -1,         2,  25);
 448    TESTINST5("bgtz", 15, -1,         25, 24);
 449
 450    printf("--- BLEZ ---  if RSval <= 0 then " \
 451           "out = RDval + 1 else out = RDval + 6\n");
 452    TESTINST5("blez", 0,  0,          2,  3);
 453    TESTINST5("blez", 1,  1,          3,  4);
 454    TESTINST5("blez", 2,  0xffffffff, 4,  5);
 455    TESTINST5("blez", 3,  0xffffffff, 5,  6);
 456    TESTINST5("blez", 4,  0xfffffffe, 6,  8);
 457    TESTINST5("blez", 5,  0xffffffff, 7,  8);
 458    TESTINST5("blez", 6,  0x5,        8,  9);
 459    TESTINST5("blez", 7,  -3,         9,  10);
 460    TESTINST5("blez", 8,  125,        10, 11);
 461    TESTINST5("blez", 9,  0x80000000, 11, 12);
 462    TESTINST5("blez", 10, 0xffffffff, 12, 13);
 463    TESTINST5("blez", 11, 0x256,      13, 14);
 464    TESTINST5("blez", 12, 0x55,       14, 15);
 465    TESTINST5("blez", 13, 0xfff,      16, 17);
 466    TESTINST5("blez", 14, -1,         2,  25);
 467    TESTINST5("blez", 15, -1,         25, 24);
 468
 469    printf("--- BLTZ ---  if RSval < 0 then " \
 470           "out = RDval + 1 else out = RDval + 6\n");
 471    TESTINST5("bltz", 0,  0,          2,  3);
 472    TESTINST5("bltz", 1,  1,          3,  4);
 473    TESTINST5("bltz", 2,  0xffffffff, 4,  5);
 474    TESTINST5("bltz", 3,  0xffffffff, 5,  6);
 475    TESTINST5("bltz", 4,  0xfffffffe, 6,  8);
 476    TESTINST5("bltz", 5,  0xffffffff, 7,  8);
 477    TESTINST5("bltz", 6,  0x5,        8,  9);
 478    TESTINST5("bltz", 7,  -3,         9,  10);
 479    TESTINST5("bltz", 8,  125,        10, 11);
 480    TESTINST5("bltz", 9,  0x80000000, 11, 12);
 481    TESTINST5("bltz", 10, 0xffffffff, 12, 13);
 482    TESTINST5("bltz", 11, 0x256,      13, 14);
 483    TESTINST5("bltz", 12, 0x55,       14, 15);
 484    TESTINST5("bltz", 13, 0xfff,      16, 17);
 485    TESTINST5("bltz", 14, -1,         2,  25);
 486    TESTINST5("bltz", 15, -1,         25, 24);
 487 #if (__mips_isa_rev < 6)
 488    printf("--- BGEZAL ---  if RSval >= 0 then " \
 489           "out = RDval + 6 else out = RDval + 5\n");
 490    TESTINST6("bgezal", 0,  0,          2,  3);
 491    TESTINST6("bgezal", 1,  1,          3,  4);
 492    TESTINST6("bgezal", 2,  0xffffffff, 4,  5);
 493    TESTINST6("bgezal", 3,  0xffffffff, 5,  6);
 494    TESTINST6("bgezal", 4,  0xfffffffe, 6,  8);
 495    TESTINST6("bgezal", 5,  0xffffffff, 7,  8);
 496    TESTINST6("bgezal", 6,  0x5,        8,  9);
 497    TESTINST6("bgezal", 7,  -3,         9,  10);
 498    TESTINST6("bgezal", 8,  125,        10, 11);
 499    TESTINST6("bgezal", 9,  0x80000000, 11, 12);
 500    TESTINST6("bgezal", 10, 0xffffffff, 12, 13);
 501    TESTINST6("bgezal", 11, 0x256,      13, 14);
 502    TESTINST6("bgezal", 12, 0x55,       14, 15);
 503    TESTINST6("bgezal", 13, 0xfff,      16, 17);
 504    TESTINST6("bgezal", 14, -1,         2,  25);
 505    TESTINST6("bgezal", 15, -1,         25, 24);
 506
 507    printf("--- BLTZAL ---  if RSval < 0 then " \
 508           "out = RDval + 6 else out = RDval + 5\n");
 509    TESTINST6("bltzal", 0,  0,          2,  3);
 510    TESTINST6("bltzal", 1,  1,          3,  4);
 511    TESTINST6("bltzal", 2,  0xffffffff, 4,  5);
 512    TESTINST6("bltzal", 3,  0xffffffff, 5,  6);
 513    TESTINST6("bltzal", 4,  0xfffffffe, 6,  8);
 514    TESTINST6("bltzal", 5,  0xffffffff, 7,  8);
 515    TESTINST6("bltzal", 6,  0x5,        8,  9);
 516    TESTINST6("bltzal", 7,  -3,         9,  10);
 517    TESTINST6("bltzal", 8,  125,        10, 11);
 518    TESTINST6("bltzal", 9,  0x80000000, 11, 12);
 519    TESTINST6("bltzal", 10, 0xffffffff, 12, 13);
 520    TESTINST6("bltzal", 11, 0x256,      13, 14);
 521    TESTINST6("bltzal", 12, 0x55,       14, 15);
 522    TESTINST6("bltzal", 13, 0xfff,      16, 17);
 523    TESTINST6("bltzal", 14, -1,         2,  25);
 524    TESTINST6("bltzal", 15, -1,         25, 24);
 525 #endif
 526    printf("--- BNEZ ---  if RSval != 0 then " \
 527           "out = RDval + 1 else out = RDval + 6\n");
 528    TESTINST5("bnez", 0,  0,          2,  3);
 529    TESTINST5("bnez", 1,  1,          3,  4);
 530    TESTINST5("bnez", 2,  0xffffffff, 4,  5);
 531    TESTINST5("bnez", 3,  0xffffffff, 5,  6);
 532    TESTINST5("bnez", 4,  0xfffffffe, 6,  8);
 533    TESTINST5("bnez", 5,  0xffffffff, 7,  8);
 534    TESTINST5("bnez", 6,  0x5,        8,  9);
 535    TESTINST5("bnez", 7,  -3,         9,  10);
 536    TESTINST5("bnez", 8,  125,        10, 11);
 537    TESTINST5("bnez", 9,  0x80000000, 11, 12);
 538    TESTINST5("bnez", 10, 0xffffffff, 12, 13);
 539    TESTINST5("bnez", 11, 0x256,      13, 14);
 540    TESTINST5("bnez", 12, 0x55,       14, 15);
 541    TESTINST5("bnez", 13, 0xfff,      16, 17);
 542    TESTINST5("bnez", 14, -1,         2,  25);
 543    TESTINST5("bnez", 15, -1,         25, 24);
 544 #if (__mips_isa_rev < 6)
 545    printf("--- BEQL ---  if RSval == RTval then " \
 546           "out = RDval + 4 else out = RDval + 6\n");
 547    TESTINST4l("beql", 0,  0,          1,          2,  3,  4);
 548    TESTINST4l("beql", 1,  1,          1,          3,  4,  5);
 549    TESTINST4l("beql", 2,  0xffffffff, 0xffffffff, 4,  5,  6);
 550    TESTINST4l("beql", 3,  0xffffffff, 0xfffffffe, 5,  6,  7);
 551    TESTINST4l("beql", 4,  0xfffffffe, 0xffffffff, 6,  8,  9);
 552    TESTINST4l("beql", 5,  0xffffffff, 0xffffffff, 7,  8,  9);
 553    TESTINST4l("beql", 6,  0x5,        0x5,        8,  9,  10);
 554    TESTINST4l("beql", 7,  -3,         -4,         9,  10, 11);
 555    TESTINST4l("beql", 8,  125,        125,        10, 11, 12);
 556    TESTINST4l("beql", 9,  0x80000000, 0x80000000, 11, 12, 13);
 557    TESTINST4l("beql", 10, 0xffffffff, 0x80000000, 12, 13, 14);
 558    TESTINST4l("beql", 11, 0x256,      0x256,      13, 14, 15);
 559    TESTINST4l("beql", 12, 0x55,       0x55,       14, 15, 16);
 560    TESTINST4l("beql", 13, 0xfff,      0xdd,       16, 17, 18);
 561    TESTINST4l("beql", 14, -1,         0x5,        2,  25, 24);
 562    TESTINST4l("beql", 15, -1,         -1,         25, 24, 7);
 563
 564    printf("--- BGEZALL ---  if RSval >= 0 then " \
 565           "out = RDval + 4 else out = RDval + 6\n");
 566    TESTINST5l("bgezall", 0,  0,          2,  3);
 567    TESTINST5l("bgezall", 1,  1,          3,  4);
 568    TESTINST5l("bgezall", 2,  0xffffffff, 4,  5);
 569    TESTINST5l("bgezall", 3,  0xffffffff, 5,  6);
 570    TESTINST5l("bgezall", 4,  0xfffffffe, 6,  8);
 571    TESTINST5l("bgezall", 5,  0xffffffff, 7,  8);
 572    TESTINST5l("bgezall", 6,  0x5,        8,  9);
 573    TESTINST5l("bgezall", 7,  -3,         9,  10);
 574    TESTINST5l("bgezall", 8,  125,        10, 11);
 575    TESTINST5l("bgezall", 9,  0x80000000, 11, 12);
 576    TESTINST5l("bgezall", 10, 0xffffffff, 12, 13);
 577    TESTINST5l("bgezall", 11, 0x256,      13, 14);
 578    TESTINST5l("bgezall", 12, 0x55,       14, 15);
 579    TESTINST5l("bgezall", 13, 0xfff,      16, 17);
 580    TESTINST5l("bgezall", 14, -1,         2,  25);
 581    TESTINST5l("bgezall", 15, -1,         25, 24);
 582
 583    printf("--- BLTZALL ---  if RSval < 0 then " \
 584           "out = RDval + 4 else out = RDval + 6\n");
 585    TESTINST5l("bltzall", 0,  0,          2,  3);
 586    TESTINST5l("bltzall", 1,  1,          3,  4);
 587    TESTINST5l("bltzall", 2,  0xffffffff, 4,  5);
 588    TESTINST5l("bltzall", 3,  0xffffffff, 5,  6);
 589    TESTINST5l("bltzall", 4,  0xfffffffe, 6,  8);
 590    TESTINST5l("bltzall", 5,  0xffffffff, 7,  8);
 591    TESTINST5l("bltzall", 6,  0x5,        8,  9);
 592    TESTINST5l("bltzall", 7,  -3,         9,  10);
 593    TESTINST5l("bltzall", 8,  125,        10, 11);
 594    TESTINST5l("bltzall", 9,  0x80000000, 11, 12);
 595    TESTINST5l("bltzall", 10, 0xffffffff, 12, 13);
 596    TESTINST5l("bltzall", 11, 0x256,      13, 14);
 597    TESTINST5l("bltzall", 12, 0x55,       14, 15);
 598    TESTINST5l("bltzall", 13, 0xfff,      16, 17);
 599    TESTINST5l("bltzall", 14, -1,         2,  25);
 600    TESTINST5l("bltzall", 15, -1,         25, 24);
 601
 602    printf("--- BGEZL ---  if RSval >= 0 then " \
 603           "out = RDval + 4 else out = RDval + 6\n");
 604    TESTINST5l("bgezl", 0,  0,          2,  3);
 605    TESTINST5l("bgezl", 1,  1,          3,  4);
 606    TESTINST5l("bgezl", 2,  0xffffffff, 4,  5);
 607    TESTINST5l("bgezl", 3,  0xffffffff, 5,  6);
 608    TESTINST5l("bgezl", 4,  0xfffffffe, 6,  8);
 609    TESTINST5l("bgezl", 5,  0xffffffff, 7,  8);
 610    TESTINST5l("bgezl", 6,  0x5,        8,  9);
 611    TESTINST5l("bgezl", 7,  -3,         9,  10);
 612    TESTINST5l("bgezl", 8,  125,        10, 11);
 613    TESTINST5l("bgezl", 9,  0x80000000, 11, 12);
 614    TESTINST5l("bgezl", 10, 0xffffffff, 12, 13);
 615    TESTINST5l("bgezl", 11, 0x256,      13, 14);
 616    TESTINST5l("bgezl", 12, 0x55,       14, 15);
 617    TESTINST5l("bgezl", 13, 0xfff,      16, 17);
 618    TESTINST5l("bgezl", 14, -1,         2,  25);
 619    TESTINST5l("bgezl", 15, -1,         25, 24);
 620
 621    printf("--- BGTZL ---  if RSval > 0 then " \
 622           "out = RDval + 4 else out = RDval + 6\n");
 623    TESTINST5l("bgtzl", 0,  0,          2,  3);
 624    TESTINST5l("bgtzl", 1,  1,          3,  4);
 625    TESTINST5l("bgtzl", 2,  0xffffffff, 4,  5);
 626    TESTINST5l("bgtzl", 3,  0xffffffff, 5,  6);
 627    TESTINST5l("bgtzl", 4,  0xfffffffe, 6,  8);
 628    TESTINST5l("bgtzl", 5,  0xffffffff, 7,  8);
 629    TESTINST5l("bgtzl", 6,  0x5,        8,  9);
 630    TESTINST5l("bgtzl", 7,  -3,         9,  10);
 631    TESTINST5l("bgtzl", 8,  125,        10, 11);
 632    TESTINST5l("bgtzl", 9,  0x80000000, 11, 12);
 633    TESTINST5l("bgtzl", 10, 0xffffffff, 12, 13);
 634    TESTINST5l("bgtzl", 11, 0x256,      13, 14);
 635    TESTINST5l("bgtzl", 12, 0x55,       14, 15);
 636    TESTINST5l("bgtzl", 13, 0xfff,      16, 17);
 637    TESTINST5l("bgtzl", 14, -1,         2,  25);
 638    TESTINST5l("bgtzl", 15, -1,         25, 24);
 639
 640    printf("--- BLEZL ---  if RSval <= 0 then " \
 641           "out = RDval + 4 else out = RDval + 6\n");
 642    TESTINST5l("blezl", 0,  0,          2,  3);
 643    TESTINST5l("blezl", 1,  1,          3,  4);
 644    TESTINST5l("blezl", 2,  0xffffffff, 4,  5);
 645    TESTINST5l("blezl", 3,  0xffffffff, 5,  6);
 646    TESTINST5l("blezl", 4,  0xfffffffe, 6,  8);
 647    TESTINST5l("blezl", 5,  0xffffffff, 7,  8);
 648    TESTINST5l("blezl", 6,  0x5,        8,  9);
 649    TESTINST5l("blezl", 7,  -3,         9,  10);
 650    TESTINST5l("blezl", 8,  125,        10, 11);
 651    TESTINST5l("blezl", 9,  0x80000000, 11, 12);
 652    TESTINST5l("blezl", 10, 0xffffffff, 12, 13);
 653    TESTINST5l("blezl", 11, 0x256,      13, 14);
 654    TESTINST5l("blezl", 12, 0x55,       14, 15);
 655    TESTINST5l("blezl", 13, 0xfff,      16, 17);
 656    TESTINST5l("blezl", 14, -1,         2,  25);
 657    TESTINST5l("blezl", 15, -1,         25, 24);
 658
 659    printf("--- BGEZALL ---  if RSval >= 0 then " \
 660           "out = RDval + 9 else out = RDval + 5\n");
 661    TESTINST6l("bgezall", 0,  0,          2,  3);
 662    TESTINST6l("bgezall", 1,  1,          3,  4);
 663    TESTINST6l("bgezall", 2,  0xffffffff, 4,  5);
 664    TESTINST6l("bgezall", 3,  0xffffffff, 5,  6);
 665    TESTINST6l("bgezall", 4,  0xfffffffe, 6,  8);
 666    TESTINST6l("bgezall", 5,  0xffffffff, 7,  8);
 667    TESTINST6l("bgezall", 6,  0x5,        8,  9);
 668    TESTINST6l("bgezall", 7,  -3,         9,  10);
 669    TESTINST6l("bgezall", 8,  125,        10, 11);
 670    TESTINST6l("bgezall", 9,  0x80000000, 11, 12);
 671    TESTINST6l("bgezall", 10, 0xffffffff, 12, 13);
 672    TESTINST6l("bgezall", 11, 0x256,      13, 14);
 673    TESTINST6l("bgezall", 12, 0x55,       14, 15);
 674    TESTINST6l("bgezall", 13, 0xfff,      16, 17);
 675    TESTINST6l("bgezall", 14, -1,         2,  25);
 676    TESTINST6l("bgezall", 15, -1,         25, 24);
 677
 678    printf("--- BLTZL ---  if RSval < 0 then " \
 679           "out = RDval + 4 else out = RDval + 6\n");
 680    TESTINST5l("bltzl", 0,  0,          2,  3);
 681    TESTINST5l("bltzl", 1,  1,          3,  4);
 682    TESTINST5l("bltzl", 2,  0xffffffff, 4,  5);
 683    TESTINST5l("bltzl", 3,  0xffffffff, 5,  6);
 684    TESTINST5l("bltzl", 4,  0xfffffffe, 6,  8);
 685    TESTINST5l("bltzl", 5,  0xffffffff, 7,  8);
 686    TESTINST5l("bltzl", 6,  0x5,        8,  9);
 687    TESTINST5l("bltzl", 7,  -3,         9,  10);
 688    TESTINST5l("bltzl", 8,  125,        10, 11);
 689    TESTINST5l("bltzl", 9,  0x80000000, 11, 12);
 690    TESTINST5l("bltzl", 10, 0xffffffff, 12, 13);
 691    TESTINST5l("bltzl", 11, 0x256,      13, 14);
 692    TESTINST5l("bltzl", 12, 0x55,       14, 15);
 693    TESTINST5l("bltzl", 13, 0xfff,      16, 17);
 694    TESTINST5l("bltzl", 14, -1,         2,  25);
 695    TESTINST5l("bltzl", 15, -1,         25, 24);
 696
 697    printf("--- BNEL ---  if RSval != RTval then " \
 698           "out = RDval + 4 else out = RDval + 5\n");
 699    TESTINST4l("bnel", 0,  0,          1,          2,  3,  4);
 700    TESTINST4l("bnel", 1,  1,          1,          3,  4,  5);
 701    TESTINST4l("bnel", 2,  0xffffffff, 0xffffffff, 4,  5,  6);
 702    TESTINST4l("bnel", 3,  0xffffffff, 0xfffffffe, 5,  6,  7);
 703    TESTINST4l("bnel", 4,  0xfffffffe, 0xffffffff, 6,  8,  9);
 704    TESTINST4l("bnel", 5,  0xffffffff, 0xffffffff, 7,  8,  9);
 705    TESTINST4l("bnel", 6,  0x5,        0x5,        8,  9,  10);
 706    TESTINST4l("bnel", 7,  -3,         -4,         9,  10, 11);
 707    TESTINST4l("bnel", 8,  125,        125,        10, 11, 12);
 708    TESTINST4l("bnel", 9,  0x80000000, 0x80000000, 11, 12, 13);
 709    TESTINST4l("bnel", 10, 0xffffffff, 0x80000000, 12, 13, 14);
 710    TESTINST4l("bnel", 11, 0x256,      0x256,      13, 14, 15);
 711    TESTINST4l("bnel", 12, 0x55,       0x55,       14, 15, 16);
 712    TESTINST4l("bnel", 13, 0xfff,      0xdd,       16, 17, 18);
 713    TESTINST4l("bnel", 14, -1,         0x5,        2,  25, 24);
 714    TESTINST4l("bnel", 15, -1,         -1,         25, 24, 7);
 715 #endif
 716    printf("j, jal, jr\n");
 717    TESTINST3j(0,  2);
 718    TESTINST3j(1,  3);
 719    TESTINST3j(2,  4);
 720    TESTINST3j(3,  5);
 721    TESTINST3j(4,  6);
 722    TESTINST3j(5,  7);
 723    TESTINST3j(6,  4);
 724    TESTINST3j(7,  9);
 725    TESTINST3j(8,  10);
 726    TESTINST3j(9,  11);
 727    TESTINST3j(10, 12);
 728    TESTINST3j(11, 13);
 729    TESTINST3j(12, 14);
 730    TESTINST3j(13, 15);
 731    TESTINST3j(14, 16);
 732    TESTINST3j(15, 17);
 733    TESTINST3j(16, 18);
 734    TESTINST3j(17, 19);
 735    TESTINST3j(18, 20);
 736    TESTINST3j(19, 21);
 737    TESTINST3j(20, 22);
 738    TESTINST3j(21, 23);
 739    TESTINST3j(22, 24);
 740    TESTINST3j(23, 24);
 741
 742    printf("j, jalr, jr\n");
 743    TESTINST3ja(0,  2);
 744    TESTINST3ja(1,  3);
 745    TESTINST3ja(2,  4);
 746    TESTINST3ja(3,  5);
 747    TESTINST3ja(4,  6);
 748    TESTINST3ja(5,  7);
 749    TESTINST3ja(6,  4);
 750    TESTINST3ja(7,  7);
 751    TESTINST3ja(8,  10);
 752    TESTINST3ja(9,  11);
 753    TESTINST3ja(11, 13);
 754    TESTINST3ja(12, 14);
 755    TESTINST3ja(13, 15);
 756    TESTINST3ja(14, 16);
 757    TESTINST3ja(15, 17);
 758    TESTINST3ja(16, 18);
 759    TESTINST3ja(17, 19);
 760    TESTINST3ja(18, 20);
 761    TESTINST3ja(19, 21);
 762    TESTINST3ja(20, 22);
 763    TESTINST3ja(21, 23);
 764    TESTINST3ja(22, 24);
 765    TESTINST3ja(23, 24);
 766
 767    return 0;
 768 }