riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x0) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     switch((insn.bits >> 0x7) & 0x7)
   7     {
   8       case 0x0:
   9       {
  10         if((insn.bits & 0xffffffff) == 0x0)
  11         {
  12           #include "insns/unimp.h"
  13           break;
  14         }
  15         #include "insns/unimp.h"
  16       }
  17       default:
  18       {
  19         #include "insns/unimp.h"
  20       }
  21     }
  22     break;
  23   }
  24   case 0x3:
  25   {
  26     switch((insn.bits >> 0x7) & 0x7)
  27     {
  28       case 0x0:
  29       {
  30         #include "insns/l_b.h"
  31         break;
  32       }
  33       case 0x1:
  34       {
  35         #include "insns/l_h.h"
  36         break;
  37       }
  38       case 0x2:
  39       {
  40         #include "insns/l_w.h"
  41         break;
  42       }
  43       case 0x3:
  44       {
  45         #include "insns/l_d.h"
  46         break;
  47       }
  48       case 0x4:
  49       {
  50         #include "insns/l_bu.h"
  51         break;
  52       }
  53       case 0x5:
  54       {
  55         #include "insns/l_hu.h"
  56         break;
  57       }
  58       case 0x6:
  59       {
  60         #include "insns/l_wu.h"
  61         break;
  62       }
  63       default:
  64       {
  65         #include "insns/unimp.h"
  66       }
  67     }
  68     break;
  69   }
  70   case 0x7:
  71   {
  72     switch((insn.bits >> 0x7) & 0x7)
  73     {
  74       case 0x2:
  75       {
  76         #include "insns/lf_w.h"
  77         break;
  78       }
  79       case 0x3:
  80       {
  81         #include "insns/lf_d.h"
  82         break;
  83       }
  84       default:
  85       {
  86         #include "insns/unimp.h"
  87       }
  88     }
  89     break;
  90   }
  91   case 0x13:
  92   {
  93     switch((insn.bits >> 0x7) & 0x7)
  94     {
  95       case 0x0:
  96       {
  97         #include "insns/addi.h"
  98         break;
  99       }
 100       case 0x1:
 101       {
 102         if((insn.bits & 0x3f03ff) == 0x93)
 103         {
 104           #include "insns/slli.h"
 105           break;
 106         }
 107         #include "insns/unimp.h"
 108       }
 109       case 0x2:
 110       {
 111         #include "insns/slti.h"
 112         break;
 113       }
 114       case 0x3:
 115       {
 116         #include "insns/sltiu.h"
 117         break;
 118       }
 119       case 0x4:
 120       {
 121         #include "insns/xori.h"
 122         break;
 123       }
 124       case 0x5:
 125       {
 126         if((insn.bits & 0x3f03ff) == 0x293)
 127         {
 128           #include "insns/srli.h"
 129           break;
 130         }
 131         if((insn.bits & 0x3f03ff) == 0x10293)
 132         {
 133           #include "insns/srai.h"
 134           break;
 135         }
 136         #include "insns/unimp.h"
 137       }
 138       case 0x6:
 139       {
 140         #include "insns/ori.h"
 141         break;
 142       }
 143       case 0x7:
 144       {
 145         #include "insns/andi.h"
 146         break;
 147       }
 148       default:
 149       {
 150         #include "insns/unimp.h"
 151       }
 152     }
 153     break;
 154   }
 155   case 0x17:
 156   {
 157     switch((insn.bits >> 0x7) & 0x7)
 158     {
 159       case 0x0:
 160       {
 161         if((insn.bits & 0x7ffffff) == 0x17)
 162         {
 163           #include "insns/rdnpc.h"
 164           break;
 165         }
 166         #include "insns/unimp.h"
 167       }
 168       case 0x1:
 169       {
 170         if((insn.bits & 0xffffffff) == 0x97)
 171         {
 172           #include "insns/synci.h"
 173           break;
 174         }
 175         #include "insns/unimp.h"
 176       }
 177       case 0x2:
 178       {
 179         if((insn.bits & 0xffffffff) == 0x117)
 180         {
 181           #include "insns/sync.h"
 182           break;
 183         }
 184         #include "insns/unimp.h"
 185       }
 186       case 0x3:
 187       {
 188         if((insn.bits & 0xffc003ff) == 0x197)
 189         {
 190           #include "insns/syscall.h"
 191           break;
 192         }
 193         #include "insns/unimp.h"
 194       }
 195       default:
 196       {
 197         #include "insns/unimp.h"
 198       }
 199     }
 200     break;
 201   }
 202   case 0x1b:
 203   {
 204     switch((insn.bits >> 0x7) & 0x7)
 205     {
 206       case 0x0:
 207       {
 208         #include "insns/addiw.h"
 209         break;
 210       }
 211       case 0x1:
 212       {
 213         if((insn.bits & 0x3f83ff) == 0x9b)
 214         {
 215           #include "insns/slliw.h"
 216           break;
 217         }
 218         #include "insns/unimp.h"
 219       }
 220       case 0x5:
 221       {
 222         if((insn.bits & 0x3f83ff) == 0x29b)
 223         {
 224           #include "insns/srliw.h"
 225           break;
 226         }
 227         if((insn.bits & 0x3f83ff) == 0x1029b)
 228         {
 229           #include "insns/sraiw.h"
 230           break;
 231         }
 232         #include "insns/unimp.h"
 233       }
 234       default:
 235       {
 236         #include "insns/unimp.h"
 237       }
 238     }
 239     break;
 240   }
 241   case 0x23:
 242   {
 243     switch((insn.bits >> 0x7) & 0x7)
 244     {
 245       case 0x0:
 246       {
 247         #include "insns/s_b.h"
 248         break;
 249       }
 250       case 0x1:
 251       {
 252         #include "insns/s_h.h"
 253         break;
 254       }
 255       case 0x2:
 256       {
 257         #include "insns/s_w.h"
 258         break;
 259       }
 260       case 0x3:
 261       {
 262         #include "insns/s_d.h"
 263         break;
 264       }
 265       default:
 266       {
 267         #include "insns/unimp.h"
 268       }
 269     }
 270     break;
 271   }
 272   case 0x27:
 273   {
 274     switch((insn.bits >> 0x7) & 0x7)
 275     {
 276       case 0x2:
 277       {
 278         #include "insns/sf_w.h"
 279         break;
 280       }
 281       case 0x3:
 282       {
 283         #include "insns/sf_d.h"
 284         break;
 285       }
 286       default:
 287       {
 288         #include "insns/unimp.h"
 289       }
 290     }
 291     break;
 292   }
 293   case 0x33:
 294   {
 295     switch((insn.bits >> 0x7) & 0x7)
 296     {
 297       case 0x0:
 298       {
 299         if((insn.bits & 0x1ffff) == 0x33)
 300         {
 301           #include "insns/add.h"
 302           break;
 303         }
 304         if((insn.bits & 0x1ffff) == 0x433)
 305         {
 306           #include "insns/mul.h"
 307           break;
 308         }
 309         if((insn.bits & 0x1ffff) == 0x10033)
 310         {
 311           #include "insns/sub.h"
 312           break;
 313         }
 314         #include "insns/unimp.h"
 315       }
 316       case 0x1:
 317       {
 318         if((insn.bits & 0x1ffff) == 0xb3)
 319         {
 320           #include "insns/sll.h"
 321           break;
 322         }
 323         if((insn.bits & 0x1ffff) == 0x4b3)
 324         {
 325           #include "insns/mulh.h"
 326           break;
 327         }
 328         #include "insns/unimp.h"
 329       }
 330       case 0x2:
 331       {
 332         if((insn.bits & 0x1ffff) == 0x533)
 333         {
 334           #include "insns/mulhsu.h"
 335           break;
 336         }
 337         if((insn.bits & 0x1ffff) == 0x133)
 338         {
 339           #include "insns/slt.h"
 340           break;
 341         }
 342         #include "insns/unimp.h"
 343       }
 344       case 0x3:
 345       {
 346         if((insn.bits & 0x1ffff) == 0x1b3)
 347         {
 348           #include "insns/sltu.h"
 349           break;
 350         }
 351         if((insn.bits & 0x1ffff) == 0x5b3)
 352         {
 353           #include "insns/mulhu.h"
 354           break;
 355         }
 356         #include "insns/unimp.h"
 357       }
 358       case 0x4:
 359       {
 360         if((insn.bits & 0x1ffff) == 0x633)
 361         {
 362           #include "insns/div.h"
 363           break;
 364         }
 365         if((insn.bits & 0x1ffff) == 0x233)
 366         {
 367           #include "insns/xor.h"
 368           break;
 369         }
 370         #include "insns/unimp.h"
 371       }
 372       case 0x5:
 373       {
 374         if((insn.bits & 0x1ffff) == 0x102b3)
 375         {
 376           #include "insns/sra.h"
 377           break;
 378         }
 379         if((insn.bits & 0x1ffff) == 0x2b3)
 380         {
 381           #include "insns/srl.h"
 382           break;
 383         }
 384         if((insn.bits & 0x1ffff) == 0x6b3)
 385         {
 386           #include "insns/divu.h"
 387           break;
 388         }
 389         #include "insns/unimp.h"
 390       }
 391       case 0x6:
 392       {
 393         if((insn.bits & 0x1ffff) == 0x733)
 394         {
 395           #include "insns/rem.h"
 396           break;
 397         }
 398         if((insn.bits & 0x1ffff) == 0x333)
 399         {
 400           #include "insns/or.h"
 401           break;
 402         }
 403         #include "insns/unimp.h"
 404       }
 405       case 0x7:
 406       {
 407         if((insn.bits & 0x1ffff) == 0x7b3)
 408         {
 409           #include "insns/remu.h"
 410           break;
 411         }
 412         if((insn.bits & 0x1ffff) == 0x3b3)
 413         {
 414           #include "insns/and.h"
 415           break;
 416         }
 417         #include "insns/unimp.h"
 418       }
 419       default:
 420       {
 421         #include "insns/unimp.h"
 422       }
 423     }
 424     break;
 425   }
 426   case 0x37:
 427   {
 428     #include "insns/lui.h"
 429     break;
 430   }
 431   case 0x3b:
 432   {
 433     switch((insn.bits >> 0x7) & 0x7)
 434     {
 435       case 0x0:
 436       {
 437         if((insn.bits & 0x1ffff) == 0x3b)
 438         {
 439           #include "insns/addw.h"
 440           break;
 441         }
 442         if((insn.bits & 0x1ffff) == 0x1003b)
 443         {
 444           #include "insns/subw.h"
 445           break;
 446         }
 447         if((insn.bits & 0x1ffff) == 0x43b)
 448         {
 449           #include "insns/mulw.h"
 450           break;
 451         }
 452         #include "insns/unimp.h"
 453       }
 454       case 0x1:
 455       {
 456         if((insn.bits & 0x1ffff) == 0xbb)
 457         {
 458           #include "insns/sllw.h"
 459           break;
 460         }
 461         #include "insns/unimp.h"
 462       }
 463       case 0x4:
 464       {
 465         if((insn.bits & 0x1ffff) == 0x63b)
 466         {
 467           #include "insns/divw.h"
 468           break;
 469         }
 470         #include "insns/unimp.h"
 471       }
 472       case 0x5:
 473       {
 474         if((insn.bits & 0x1ffff) == 0x6bb)
 475         {
 476           #include "insns/divuw.h"
 477           break;
 478         }
 479         if((insn.bits & 0x1ffff) == 0x2bb)
 480         {
 481           #include "insns/srlw.h"
 482           break;
 483         }
 484         if((insn.bits & 0x1ffff) == 0x102bb)
 485         {
 486           #include "insns/sraw.h"
 487           break;
 488         }
 489         #include "insns/unimp.h"
 490       }
 491       case 0x6:
 492       {
 493         if((insn.bits & 0x1ffff) == 0x73b)
 494         {
 495           #include "insns/remw.h"
 496           break;
 497         }
 498         #include "insns/unimp.h"
 499       }
 500       case 0x7:
 501       {
 502         if((insn.bits & 0x1ffff) == 0x7bb)
 503         {
 504           #include "insns/remuw.h"
 505           break;
 506         }
 507         #include "insns/unimp.h"
 508       }
 509       default:
 510       {
 511         #include "insns/unimp.h"
 512       }
 513     }
 514     break;
 515   }
 516   case 0x43:
 517   {
 518     switch((insn.bits >> 0x7) & 0x7)
 519     {
 520       case 0x0:
 521       {
 522         #include "insns/fmadd_s.h"
 523         break;
 524       }
 525       case 0x1:
 526       {
 527         #include "insns/fmadd_d.h"
 528         break;
 529       }
 530       case 0x2:
 531       {
 532         if((insn.bits & 0x1ffff) == 0x1943)
 533         {
 534           #include "insns/amominu_w.h"
 535           break;
 536         }
 537         if((insn.bits & 0x1ffff) == 0x943)
 538         {
 539           #include "insns/amoand_w.h"
 540           break;
 541         }
 542         if((insn.bits & 0x1ffff) == 0x1d43)
 543         {
 544           #include "insns/amomaxu_w.h"
 545           break;
 546         }
 547         if((insn.bits & 0x1ffff) == 0x1543)
 548         {
 549           #include "insns/amomax_w.h"
 550           break;
 551         }
 552         if((insn.bits & 0x1ffff) == 0x143)
 553         {
 554           #include "insns/amoadd_w.h"
 555           break;
 556         }
 557         if((insn.bits & 0x1ffff) == 0xd43)
 558         {
 559           #include "insns/amoor_w.h"
 560           break;
 561         }
 562         if((insn.bits & 0x1ffff) == 0x1143)
 563         {
 564           #include "insns/amomin_w.h"
 565           break;
 566         }
 567         if((insn.bits & 0x1ffff) == 0x543)
 568         {
 569           #include "insns/amoswap_w.h"
 570           break;
 571         }
 572         #include "insns/unimp.h"
 573       }
 574       case 0x3:
 575       {
 576         if((insn.bits & 0x1ffff) == 0x19c3)
 577         {
 578           #include "insns/amominu_d.h"
 579           break;
 580         }
 581         if((insn.bits & 0x1ffff) == 0x9c3)
 582         {
 583           #include "insns/amoand_d.h"
 584           break;
 585         }
 586         if((insn.bits & 0x1ffff) == 0x1dc3)
 587         {
 588           #include "insns/amomaxu_d.h"
 589           break;
 590         }
 591         if((insn.bits & 0x1ffff) == 0x11c3)
 592         {
 593           #include "insns/amomin_d.h"
 594           break;
 595         }
 596         if((insn.bits & 0x1ffff) == 0x1c3)
 597         {
 598           #include "insns/amoadd_d.h"
 599           break;
 600         }
 601         if((insn.bits & 0x1ffff) == 0x15c3)
 602         {
 603           #include "insns/amomax_d.h"
 604           break;
 605         }
 606         if((insn.bits & 0x1ffff) == 0xdc3)
 607         {
 608           #include "insns/amoor_d.h"
 609           break;
 610         }
 611         if((insn.bits & 0x1ffff) == 0x5c3)
 612         {
 613           #include "insns/amoswap_d.h"
 614           break;
 615         }
 616         #include "insns/unimp.h"
 617       }
 618       default:
 619       {
 620         #include "insns/unimp.h"
 621       }
 622     }
 623     break;
 624   }
 625   case 0x47:
 626   {
 627     switch((insn.bits >> 0x7) & 0x7)
 628     {
 629       case 0x0:
 630       {
 631         #include "insns/fmsub_s.h"
 632         break;
 633       }
 634       case 0x1:
 635       {
 636         #include "insns/fmsub_d.h"
 637         break;
 638       }
 639       default:
 640       {
 641         #include "insns/unimp.h"
 642       }
 643     }
 644     break;
 645   }
 646   case 0x4b:
 647   {
 648     switch((insn.bits >> 0x7) & 0x7)
 649     {
 650       case 0x0:
 651       {
 652         #include "insns/fnmsub_s.h"
 653         break;
 654       }
 655       case 0x1:
 656       {
 657         #include "insns/fnmsub_d.h"
 658         break;
 659       }
 660       default:
 661       {
 662         #include "insns/unimp.h"
 663       }
 664     }
 665     break;
 666   }
 667   case 0x4f:
 668   {
 669     switch((insn.bits >> 0x7) & 0x7)
 670     {
 671       case 0x0:
 672       {
 673         #include "insns/fnmadd_s.h"
 674         break;
 675       }
 676       case 0x1:
 677       {
 678         #include "insns/fnmadd_d.h"
 679         break;
 680       }
 681       default:
 682       {
 683         #include "insns/unimp.h"
 684       }
 685     }
 686     break;
 687   }
 688   case 0x53:
 689   {
 690     switch((insn.bits >> 0x7) & 0x7)
 691     {
 692       case 0x0:
 693       {
 694         if((insn.bits & 0x3ff1ff) == 0x11053)
 695         {
 696           #include "insns/fcvt_s_d.h"
 697           break;
 698         }
 699         if((insn.bits & 0x1f1ff) == 0x53)
 700         {
 701           #include "insns/fadd_s.h"
 702           break;
 703         }
 704         if((insn.bits & 0x3ff1ff) == 0xe053)
 705         {
 706           #include "insns/fcvt_s_w.h"
 707           break;
 708         }
 709         if((insn.bits & 0x3ff1ff) == 0xb053)
 710         {
 711           #include "insns/fcvtu_w_s.h"
 712           break;
 713         }
 714         if((insn.bits & 0x3ff1ff) == 0x8053)
 715         {
 716           #include "insns/fcvt_l_s.h"
 717           break;
 718         }
 719         if((insn.bits & 0x1f1ff) == 0x3053)
 720         {
 721           #include "insns/fdiv_s.h"
 722           break;
 723         }
 724         if((insn.bits & 0x1f1ff) == 0x2053)
 725         {
 726           #include "insns/fmul_s.h"
 727           break;
 728         }
 729         if((insn.bits & 0x3ff1ff) == 0xa053)
 730         {
 731           #include "insns/fcvt_w_s.h"
 732           break;
 733         }
 734         if((insn.bits & 0x1f1ff) == 0x1053)
 735         {
 736           #include "insns/fsub_s.h"
 737           break;
 738         }
 739         if((insn.bits & 0x3ff1ff) == 0xf053)
 740         {
 741           #include "insns/fcvtu_s_w.h"
 742           break;
 743         }
 744         if((insn.bits & 0x3ff1ff) == 0xd053)
 745         {
 746           #include "insns/fcvtu_s_l.h"
 747           break;
 748         }
 749         if((insn.bits & 0x3ff1ff) == 0x9053)
 750         {
 751           #include "insns/fcvtu_l_s.h"
 752           break;
 753         }
 754         if((insn.bits & 0x3ff1ff) == 0xc053)
 755         {
 756           #include "insns/fcvt_s_l.h"
 757           break;
 758         }
 759         if((insn.bits & 0x3ff1ff) == 0x4053)
 760         {
 761           #include "insns/fsqrt_s.h"
 762           break;
 763         }
 764         #include "insns/unimp.h"
 765       }
 766       case 0x1:
 767       {
 768         if((insn.bits & 0x3ff1ff) == 0xc0d3)
 769         {
 770           #include "insns/fcvt_d_l.h"
 771           break;
 772         }
 773         if((insn.bits & 0x3ff1ff) == 0x80d3)
 774         {
 775           #include "insns/fcvt_l_d.h"
 776           break;
 777         }
 778         if((insn.bits & 0x1f1ff) == 0x20d3)
 779         {
 780           #include "insns/fmul_d.h"
 781           break;
 782         }
 783         if((insn.bits & 0x3ff1ff) == 0xa0d3)
 784         {
 785           #include "insns/fcvt_w_d.h"
 786           break;
 787         }
 788         if((insn.bits & 0x3ff1ff) == 0xb0d3)
 789         {
 790           #include "insns/fcvtu_w_d.h"
 791           break;
 792         }
 793         if((insn.bits & 0x1f1ff) == 0xd3)
 794         {
 795           #include "insns/fadd_d.h"
 796           break;
 797         }
 798         if((insn.bits & 0x3ff1ff) == 0x90d3)
 799         {
 800           #include "insns/fcvtu_l_d.h"
 801           break;
 802         }
 803         if((insn.bits & 0x1f1ff) == 0x10d3)
 804         {
 805           #include "insns/fsub_d.h"
 806           break;
 807         }
 808         if((insn.bits & 0x3ff1ff) == 0x40d3)
 809         {
 810           #include "insns/fsqrt_d.h"
 811           break;
 812         }
 813         if((insn.bits & 0x1f1ff) == 0x30d3)
 814         {
 815           #include "insns/fdiv_d.h"
 816           break;
 817         }
 818         if((insn.bits & 0x3ff1ff) == 0xd0d3)
 819         {
 820           #include "insns/fcvtu_d_l.h"
 821           break;
 822         }
 823         #include "insns/unimp.h"
 824       }
 825       case 0x4:
 826       {
 827         if((insn.bits & 0x1ffff) == 0x6e53)
 828         {
 829           #include "insns/fsinjn_s.h"
 830           break;
 831         }
 832         if((insn.bits & 0x7c1ffff) == 0x18e53)
 833         {
 834           #include "insns/mff_s.h"
 835           break;
 836         }
 837         if((insn.bits & 0xf83fffff) == 0x1de53)
 838         {
 839           #include "insns/mtfsr.h"
 840           break;
 841         }
 842         if((insn.bits & 0x3fffff) == 0x1ce53)
 843         {
 844           #include "insns/mtf_s.h"
 845           break;
 846         }
 847         if((insn.bits & 0x7ffffff) == 0x1be53)
 848         {
 849           #include "insns/mffsr.h"
 850           break;
 851         }
 852         if((insn.bits & 0x1ffff) == 0x16e53)
 853         {
 854           #include "insns/fc_lt_s.h"
 855           break;
 856         }
 857         if((insn.bits & 0x1ffff) == 0x7e53)
 858         {
 859           #include "insns/fsmul_s.h"
 860           break;
 861         }
 862         if((insn.bits & 0x1ffff) == 0x5e53)
 863         {
 864           #include "insns/fsinj_s.h"
 865           break;
 866         }
 867         if((insn.bits & 0x1ffff) == 0x17e53)
 868         {
 869           #include "insns/fc_le_s.h"
 870           break;
 871         }
 872         if((insn.bits & 0x1ffff) == 0x15e53)
 873         {
 874           #include "insns/fc_eq_s.h"
 875           break;
 876         }
 877         #include "insns/unimp.h"
 878       }
 879       case 0x5:
 880       {
 881         if((insn.bits & 0x7c1ffff) == 0x18ed3)
 882         {
 883           #include "insns/mff_d.h"
 884           break;
 885         }
 886         if((insn.bits & 0x1ffff) == 0x6ed3)
 887         {
 888           #include "insns/fsinjn_d.h"
 889           break;
 890         }
 891         if((insn.bits & 0x3fffff) == 0xeed3)
 892         {
 893           #include "insns/fcvt_d_w.h"
 894           break;
 895         }
 896         if((insn.bits & 0x3fffff) == 0x10ed3)
 897         {
 898           #include "insns/fcvt_d_s.h"
 899           break;
 900         }
 901         if((insn.bits & 0x3fffff) == 0x1ced3)
 902         {
 903           #include "insns/mtf_d.h"
 904           break;
 905         }
 906         if((insn.bits & 0x3fffff) == 0xfed3)
 907         {
 908           #include "insns/fcvtu_d_w.h"
 909           break;
 910         }
 911         if((insn.bits & 0x1ffff) == 0x16ed3)
 912         {
 913           #include "insns/fc_lt_d.h"
 914           break;
 915         }
 916         if((insn.bits & 0x1ffff) == 0x15ed3)
 917         {
 918           #include "insns/fc_eq_d.h"
 919           break;
 920         }
 921         if((insn.bits & 0x1ffff) == 0x7ed3)
 922         {
 923           #include "insns/fsmul_d.h"
 924           break;
 925         }
 926         if((insn.bits & 0x1ffff) == 0x5ed3)
 927         {
 928           #include "insns/fsinj_d.h"
 929           break;
 930         }
 931         if((insn.bits & 0x1ffff) == 0x17ed3)
 932         {
 933           #include "insns/fc_le_d.h"
 934           break;
 935         }
 936         #include "insns/unimp.h"
 937       }
 938       default:
 939       {
 940         #include "insns/unimp.h"
 941       }
 942     }
 943     break;
 944   }
 945   case 0x63:
 946   {
 947     switch((insn.bits >> 0x7) & 0x7)
 948     {
 949       case 0x0:
 950       {
 951         #include "insns/beq.h"
 952         break;
 953       }
 954       case 0x1:
 955       {
 956         #include "insns/bne.h"
 957         break;
 958       }
 959       case 0x4:
 960       {
 961         #include "insns/blt.h"
 962         break;
 963       }
 964       case 0x5:
 965       {
 966         #include "insns/bge.h"
 967         break;
 968       }
 969       case 0x6:
 970       {
 971         #include "insns/bltu.h"
 972         break;
 973       }
 974       case 0x7:
 975       {
 976         #include "insns/bgeu.h"
 977         break;
 978       }
 979       default:
 980       {
 981         #include "insns/unimp.h"
 982       }
 983     }
 984     break;
 985   }
 986   case 0x67:
 987   {
 988     #include "insns/j.h"
 989     break;
 990   }
 991   case 0x6b:
 992   {
 993     switch((insn.bits >> 0x7) & 0x7)
 994     {
 995       case 0x0:
 996       {
 997         #include "insns/jalr_c.h"
 998         break;
 999       }
1000       case 0x1:
1001       {
1002         #include "insns/jalr_r.h"
1003         break;
1004       }
1005       case 0x2:
1006       {
1007         #include "insns/jalr_j.h"
1008         break;
1009       }
1010       default:
1011       {
1012         #include "insns/unimp.h"
1013       }
1014     }
1015     break;
1016   }
1017   case 0x6f:
1018   {
1019     #include "insns/jal.h"
1020     break;
1021   }
1022   case 0x7f:
1023   {
1024     switch((insn.bits >> 0x7) & 0x7)
1025     {
1026       case 0x0:
1027       {
1028         if((insn.bits & 0x7ffffff) == 0x47f)
1029         {
1030           #include "insns/di.h"
1031           break;
1032         }
1033         if((insn.bits & 0x7ffffff) == 0x7f)
1034         {
1035           #include "insns/ei.h"
1036           break;
1037         }
1038         #include "insns/unimp.h"
1039       }
1040       case 0x1:
1041       {
1042         if((insn.bits & 0x7c1ffff) == 0xff)
1043         {
1044           #include "insns/mfpcr.h"
1045           break;
1046         }
1047         if((insn.bits & 0xf801ffff) == 0x4ff)
1048         {
1049           #include "insns/mtpcr.h"
1050           break;
1051         }
1052         #include "insns/unimp.h"
1053       }
1054       case 0x2:
1055       {
1056         if((insn.bits & 0xffffffff) == 0x17f)
1057         {
1058           #include "insns/eret.h"
1059           break;
1060         }
1061         #include "insns/unimp.h"
1062       }
1063       default:
1064       {
1065         #include "insns/unimp.h"
1066       }
1067     }
1068     break;
1069   }
1070   default:
1071   {
1072     #include "insns/unimp.h"
1073   }
1074 }