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/lb.h"
  31         break;
  32       }
  33       case 0x1:
  34       {
  35         #include "insns/lh.h"
  36         break;
  37       }
  38       case 0x2:
  39       {
  40         #include "insns/lw.h"
  41         break;
  42       }
  43       case 0x3:
  44       {
  45         #include "insns/ld.h"
  46         break;
  47       }
  48       case 0x4:
  49       {
  50         #include "insns/lbu.h"
  51         break;
  52       }
  53       case 0x5:
  54       {
  55         #include "insns/lhu.h"
  56         break;
  57       }
  58       case 0x6:
  59       {
  60         #include "insns/lwu.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/flw.h"
  77         break;
  78       }
  79       case 0x3:
  80       {
  81         #include "insns/fld.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 0x1b:
 156   {
 157     switch((insn.bits >> 0x7) & 0x7)
 158     {
 159       case 0x0:
 160       {
 161         #include "insns/addiw.h"
 162         break;
 163       }
 164       case 0x1:
 165       {
 166         if((insn.bits & 0x3f83ff) == 0x9b)
 167         {
 168           #include "insns/slliw.h"
 169           break;
 170         }
 171         #include "insns/unimp.h"
 172       }
 173       case 0x5:
 174       {
 175         if((insn.bits & 0x3f83ff) == 0x29b)
 176         {
 177           #include "insns/srliw.h"
 178           break;
 179         }
 180         if((insn.bits & 0x3f83ff) == 0x1029b)
 181         {
 182           #include "insns/sraiw.h"
 183           break;
 184         }
 185         #include "insns/unimp.h"
 186       }
 187       default:
 188       {
 189         #include "insns/unimp.h"
 190       }
 191     }
 192     break;
 193   }
 194   case 0x23:
 195   {
 196     switch((insn.bits >> 0x7) & 0x7)
 197     {
 198       case 0x0:
 199       {
 200         #include "insns/sb.h"
 201         break;
 202       }
 203       case 0x1:
 204       {
 205         #include "insns/sh.h"
 206         break;
 207       }
 208       case 0x2:
 209       {
 210         #include "insns/sw.h"
 211         break;
 212       }
 213       case 0x3:
 214       {
 215         #include "insns/sd.h"
 216         break;
 217       }
 218       default:
 219       {
 220         #include "insns/unimp.h"
 221       }
 222     }
 223     break;
 224   }
 225   case 0x27:
 226   {
 227     switch((insn.bits >> 0x7) & 0x7)
 228     {
 229       case 0x2:
 230       {
 231         #include "insns/fsw.h"
 232         break;
 233       }
 234       case 0x3:
 235       {
 236         #include "insns/fsd.h"
 237         break;
 238       }
 239       default:
 240       {
 241         #include "insns/unimp.h"
 242       }
 243     }
 244     break;
 245   }
 246   case 0x2b:
 247   {
 248     switch((insn.bits >> 0x7) & 0x7)
 249     {
 250       case 0x2:
 251       {
 252         if((insn.bits & 0x1ffff) == 0x192b)
 253         {
 254           #include "insns/amominu_w.h"
 255           break;
 256         }
 257         if((insn.bits & 0x1ffff) == 0x92b)
 258         {
 259           #include "insns/amoand_w.h"
 260           break;
 261         }
 262         if((insn.bits & 0x1ffff) == 0x1d2b)
 263         {
 264           #include "insns/amomaxu_w.h"
 265           break;
 266         }
 267         if((insn.bits & 0x1ffff) == 0x152b)
 268         {
 269           #include "insns/amomax_w.h"
 270           break;
 271         }
 272         if((insn.bits & 0x1ffff) == 0x12b)
 273         {
 274           #include "insns/amoadd_w.h"
 275           break;
 276         }
 277         if((insn.bits & 0x1ffff) == 0xd2b)
 278         {
 279           #include "insns/amoor_w.h"
 280           break;
 281         }
 282         if((insn.bits & 0x1ffff) == 0x112b)
 283         {
 284           #include "insns/amomin_w.h"
 285           break;
 286         }
 287         if((insn.bits & 0x1ffff) == 0x52b)
 288         {
 289           #include "insns/amoswap_w.h"
 290           break;
 291         }
 292         #include "insns/unimp.h"
 293       }
 294       case 0x3:
 295       {
 296         if((insn.bits & 0x1ffff) == 0x19ab)
 297         {
 298           #include "insns/amominu_d.h"
 299           break;
 300         }
 301         if((insn.bits & 0x1ffff) == 0x9ab)
 302         {
 303           #include "insns/amoand_d.h"
 304           break;
 305         }
 306         if((insn.bits & 0x1ffff) == 0x1dab)
 307         {
 308           #include "insns/amomaxu_d.h"
 309           break;
 310         }
 311         if((insn.bits & 0x1ffff) == 0x1ab)
 312         {
 313           #include "insns/amoadd_d.h"
 314           break;
 315         }
 316         if((insn.bits & 0x1ffff) == 0x15ab)
 317         {
 318           #include "insns/amomax_d.h"
 319           break;
 320         }
 321         if((insn.bits & 0x1ffff) == 0xdab)
 322         {
 323           #include "insns/amoor_d.h"
 324           break;
 325         }
 326         if((insn.bits & 0x1ffff) == 0x5ab)
 327         {
 328           #include "insns/amoswap_d.h"
 329           break;
 330         }
 331         if((insn.bits & 0x1ffff) == 0x11ab)
 332         {
 333           #include "insns/amomin_d.h"
 334           break;
 335         }
 336         #include "insns/unimp.h"
 337       }
 338       default:
 339       {
 340         #include "insns/unimp.h"
 341       }
 342     }
 343     break;
 344   }
 345   case 0x2f:
 346   {
 347     switch((insn.bits >> 0x7) & 0x7)
 348     {
 349       case 0x1:
 350       {
 351         #include "insns/fence_i.h"
 352         break;
 353       }
 354       case 0x2:
 355       {
 356         #include "insns/fence.h"
 357         break;
 358       }
 359       default:
 360       {
 361         #include "insns/unimp.h"
 362       }
 363     }
 364     break;
 365   }
 366   case 0x33:
 367   {
 368     switch((insn.bits >> 0x7) & 0x7)
 369     {
 370       case 0x0:
 371       {
 372         if((insn.bits & 0x1ffff) == 0x33)
 373         {
 374           #include "insns/add.h"
 375           break;
 376         }
 377         if((insn.bits & 0x1ffff) == 0x433)
 378         {
 379           #include "insns/mul.h"
 380           break;
 381         }
 382         if((insn.bits & 0x1ffff) == 0x10033)
 383         {
 384           #include "insns/sub.h"
 385           break;
 386         }
 387         #include "insns/unimp.h"
 388       }
 389       case 0x1:
 390       {
 391         if((insn.bits & 0x1ffff) == 0xb3)
 392         {
 393           #include "insns/sll.h"
 394           break;
 395         }
 396         if((insn.bits & 0x1ffff) == 0x4b3)
 397         {
 398           #include "insns/mulh.h"
 399           break;
 400         }
 401         #include "insns/unimp.h"
 402       }
 403       case 0x2:
 404       {
 405         if((insn.bits & 0x1ffff) == 0x533)
 406         {
 407           #include "insns/mulhsu.h"
 408           break;
 409         }
 410         if((insn.bits & 0x1ffff) == 0x133)
 411         {
 412           #include "insns/slt.h"
 413           break;
 414         }
 415         #include "insns/unimp.h"
 416       }
 417       case 0x3:
 418       {
 419         if((insn.bits & 0x1ffff) == 0x1b3)
 420         {
 421           #include "insns/sltu.h"
 422           break;
 423         }
 424         if((insn.bits & 0x1ffff) == 0x5b3)
 425         {
 426           #include "insns/mulhu.h"
 427           break;
 428         }
 429         #include "insns/unimp.h"
 430       }
 431       case 0x4:
 432       {
 433         if((insn.bits & 0x1ffff) == 0x633)
 434         {
 435           #include "insns/div.h"
 436           break;
 437         }
 438         if((insn.bits & 0x1ffff) == 0x233)
 439         {
 440           #include "insns/xor.h"
 441           break;
 442         }
 443         #include "insns/unimp.h"
 444       }
 445       case 0x5:
 446       {
 447         if((insn.bits & 0x1ffff) == 0x102b3)
 448         {
 449           #include "insns/sra.h"
 450           break;
 451         }
 452         if((insn.bits & 0x1ffff) == 0x2b3)
 453         {
 454           #include "insns/srl.h"
 455           break;
 456         }
 457         if((insn.bits & 0x1ffff) == 0x6b3)
 458         {
 459           #include "insns/divu.h"
 460           break;
 461         }
 462         #include "insns/unimp.h"
 463       }
 464       case 0x6:
 465       {
 466         if((insn.bits & 0x1ffff) == 0x733)
 467         {
 468           #include "insns/rem.h"
 469           break;
 470         }
 471         if((insn.bits & 0x1ffff) == 0x333)
 472         {
 473           #include "insns/or.h"
 474           break;
 475         }
 476         #include "insns/unimp.h"
 477       }
 478       case 0x7:
 479       {
 480         if((insn.bits & 0x1ffff) == 0x7b3)
 481         {
 482           #include "insns/remu.h"
 483           break;
 484         }
 485         if((insn.bits & 0x1ffff) == 0x3b3)
 486         {
 487           #include "insns/and.h"
 488           break;
 489         }
 490         #include "insns/unimp.h"
 491       }
 492       default:
 493       {
 494         #include "insns/unimp.h"
 495       }
 496     }
 497     break;
 498   }
 499   case 0x37:
 500   {
 501     #include "insns/lui.h"
 502     break;
 503   }
 504   case 0x3b:
 505   {
 506     switch((insn.bits >> 0x7) & 0x7)
 507     {
 508       case 0x0:
 509       {
 510         if((insn.bits & 0x1ffff) == 0x43b)
 511         {
 512           #include "insns/mulw.h"
 513           break;
 514         }
 515         if((insn.bits & 0x1ffff) == 0x3b)
 516         {
 517           #include "insns/addw.h"
 518           break;
 519         }
 520         if((insn.bits & 0x1ffff) == 0x1003b)
 521         {
 522           #include "insns/subw.h"
 523           break;
 524         }
 525         #include "insns/unimp.h"
 526       }
 527       case 0x1:
 528       {
 529         if((insn.bits & 0x1ffff) == 0xbb)
 530         {
 531           #include "insns/sllw.h"
 532           break;
 533         }
 534         #include "insns/unimp.h"
 535       }
 536       case 0x4:
 537       {
 538         if((insn.bits & 0x1ffff) == 0x63b)
 539         {
 540           #include "insns/divw.h"
 541           break;
 542         }
 543         #include "insns/unimp.h"
 544       }
 545       case 0x5:
 546       {
 547         if((insn.bits & 0x1ffff) == 0x6bb)
 548         {
 549           #include "insns/divuw.h"
 550           break;
 551         }
 552         if((insn.bits & 0x1ffff) == 0x2bb)
 553         {
 554           #include "insns/srlw.h"
 555           break;
 556         }
 557         if((insn.bits & 0x1ffff) == 0x102bb)
 558         {
 559           #include "insns/sraw.h"
 560           break;
 561         }
 562         #include "insns/unimp.h"
 563       }
 564       case 0x6:
 565       {
 566         if((insn.bits & 0x1ffff) == 0x73b)
 567         {
 568           #include "insns/remw.h"
 569           break;
 570         }
 571         #include "insns/unimp.h"
 572       }
 573       case 0x7:
 574       {
 575         if((insn.bits & 0x1ffff) == 0x7bb)
 576         {
 577           #include "insns/remuw.h"
 578           break;
 579         }
 580         #include "insns/unimp.h"
 581       }
 582       default:
 583       {
 584         #include "insns/unimp.h"
 585       }
 586     }
 587     break;
 588   }
 589   case 0x43:
 590   {
 591     switch((insn.bits >> 0x7) & 0x7)
 592     {
 593       case 0x0:
 594       {
 595         #include "insns/fmadd_s.h"
 596         break;
 597       }
 598       case 0x1:
 599       {
 600         #include "insns/fmadd_d.h"
 601         break;
 602       }
 603       default:
 604       {
 605         #include "insns/unimp.h"
 606       }
 607     }
 608     break;
 609   }
 610   case 0x47:
 611   {
 612     switch((insn.bits >> 0x7) & 0x7)
 613     {
 614       case 0x0:
 615       {
 616         #include "insns/fmsub_s.h"
 617         break;
 618       }
 619       case 0x1:
 620       {
 621         #include "insns/fmsub_d.h"
 622         break;
 623       }
 624       default:
 625       {
 626         #include "insns/unimp.h"
 627       }
 628     }
 629     break;
 630   }
 631   case 0x4b:
 632   {
 633     switch((insn.bits >> 0x7) & 0x7)
 634     {
 635       case 0x0:
 636       {
 637         #include "insns/fnmsub_s.h"
 638         break;
 639       }
 640       case 0x1:
 641       {
 642         #include "insns/fnmsub_d.h"
 643         break;
 644       }
 645       default:
 646       {
 647         #include "insns/unimp.h"
 648       }
 649     }
 650     break;
 651   }
 652   case 0x4f:
 653   {
 654     switch((insn.bits >> 0x7) & 0x7)
 655     {
 656       case 0x0:
 657       {
 658         #include "insns/fnmadd_s.h"
 659         break;
 660       }
 661       case 0x1:
 662       {
 663         #include "insns/fnmadd_d.h"
 664         break;
 665       }
 666       default:
 667       {
 668         #include "insns/unimp.h"
 669       }
 670     }
 671     break;
 672   }
 673   case 0x53:
 674   {
 675     switch((insn.bits >> 0x7) & 0x7)
 676     {
 677       case 0x0:
 678       {
 679         if((insn.bits & 0x3ff1ff) == 0x9053)
 680         {
 681           #include "insns/fcvt_lu_s.h"
 682           break;
 683         }
 684         if((insn.bits & 0x1ffff) == 0x18053)
 685         {
 686           #include "insns/fmin_s.h"
 687           break;
 688         }
 689         if((insn.bits & 0x3ff1ff) == 0x11053)
 690         {
 691           #include "insns/fcvt_s_d.h"
 692           break;
 693         }
 694         if((insn.bits & 0x3ff1ff) == 0xe053)
 695         {
 696           #include "insns/fcvt_s_w.h"
 697           break;
 698         }
 699         if((insn.bits & 0x7c1ffff) == 0x1c053)
 700         {
 701           #include "insns/mftx_s.h"
 702           break;
 703         }
 704         if((insn.bits & 0x3ff1ff) == 0x8053)
 705         {
 706           #include "insns/fcvt_l_s.h"
 707           break;
 708         }
 709         if((insn.bits & 0x1ffff) == 0x17053)
 710         {
 711           #include "insns/fle_s.h"
 712           break;
 713         }
 714         if((insn.bits & 0x7ffffff) == 0x1d053)
 715         {
 716           #include "insns/mffsr.h"
 717           break;
 718         }
 719         if((insn.bits & 0x1f1ff) == 0x3053)
 720         {
 721           #include "insns/fdiv_s.h"
 722           break;
 723         }
 724         if((insn.bits & 0x3fffff) == 0x1f053)
 725         {
 726           #include "insns/mtfsr.h"
 727           break;
 728         }
 729         if((insn.bits & 0x3ff1ff) == 0xd053)
 730         {
 731           #include "insns/fcvt_s_lu.h"
 732           break;
 733         }
 734         if((insn.bits & 0x1f1ff) == 0x2053)
 735         {
 736           #include "insns/fmul_s.h"
 737           break;
 738         }
 739         if((insn.bits & 0x1ffff) == 0x16053)
 740         {
 741           #include "insns/flt_s.h"
 742           break;
 743         }
 744         if((insn.bits & 0x1ffff) == 0x15053)
 745         {
 746           #include "insns/feq_s.h"
 747           break;
 748         }
 749         if((insn.bits & 0x1ffff) == 0x7053)
 750         {
 751           #include "insns/fsgnjx_s.h"
 752           break;
 753         }
 754         if((insn.bits & 0x1ffff) == 0x19053)
 755         {
 756           #include "insns/fmax_s.h"
 757           break;
 758         }
 759         if((insn.bits & 0x3ff1ff) == 0xb053)
 760         {
 761           #include "insns/fcvt_wu_s.h"
 762           break;
 763         }
 764         if((insn.bits & 0x3ff1ff) == 0xa053)
 765         {
 766           #include "insns/fcvt_w_s.h"
 767           break;
 768         }
 769         if((insn.bits & 0x3fffff) == 0x1e053)
 770         {
 771           #include "insns/mxtf_s.h"
 772           break;
 773         }
 774         if((insn.bits & 0x1f1ff) == 0x1053)
 775         {
 776           #include "insns/fsub_s.h"
 777           break;
 778         }
 779         if((insn.bits & 0x1ffff) == 0x5053)
 780         {
 781           #include "insns/fsgnj_s.h"
 782           break;
 783         }
 784         if((insn.bits & 0x3ff1ff) == 0xf053)
 785         {
 786           #include "insns/fcvt_s_wu.h"
 787           break;
 788         }
 789         if((insn.bits & 0x3ff1ff) == 0xc053)
 790         {
 791           #include "insns/fcvt_s_l.h"
 792           break;
 793         }
 794         if((insn.bits & 0x3ff1ff) == 0x4053)
 795         {
 796           #include "insns/fsqrt_s.h"
 797           break;
 798         }
 799         if((insn.bits & 0x1ffff) == 0x6053)
 800         {
 801           #include "insns/fsgnjn_s.h"
 802           break;
 803         }
 804         if((insn.bits & 0x1f1ff) == 0x53)
 805         {
 806           #include "insns/fadd_s.h"
 807           break;
 808         }
 809         #include "insns/unimp.h"
 810       }
 811       case 0x1:
 812       {
 813         if((insn.bits & 0x1ffff) == 0x180d3)
 814         {
 815           #include "insns/fmin_d.h"
 816           break;
 817         }
 818         if((insn.bits & 0x3ff1ff) == 0xc0d3)
 819         {
 820           #include "insns/fcvt_d_l.h"
 821           break;
 822         }
 823         if((insn.bits & 0x3fffff) == 0xe0d3)
 824         {
 825           #include "insns/fcvt_d_w.h"
 826           break;
 827         }
 828         if((insn.bits & 0x3fffff) == 0x100d3)
 829         {
 830           #include "insns/fcvt_d_s.h"
 831           break;
 832         }
 833         if((insn.bits & 0x1ffff) == 0x190d3)
 834         {
 835           #include "insns/fmax_d.h"
 836           break;
 837         }
 838         if((insn.bits & 0x7c1ffff) == 0x1c0d3)
 839         {
 840           #include "insns/mftx_d.h"
 841           break;
 842         }
 843         if((insn.bits & 0x1ffff) == 0x170d3)
 844         {
 845           #include "insns/fle_d.h"
 846           break;
 847         }
 848         if((insn.bits & 0x1ffff) == 0x160d3)
 849         {
 850           #include "insns/flt_d.h"
 851           break;
 852         }
 853         if((insn.bits & 0x1f1ff) == 0x20d3)
 854         {
 855           #include "insns/fmul_d.h"
 856           break;
 857         }
 858         if((insn.bits & 0x1ffff) == 0x70d3)
 859         {
 860           #include "insns/fsgnjx_d.h"
 861           break;
 862         }
 863         if((insn.bits & 0x1ffff) == 0x150d3)
 864         {
 865           #include "insns/feq_d.h"
 866           break;
 867         }
 868         if((insn.bits & 0x3fffff) == 0xf0d3)
 869         {
 870           #include "insns/fcvt_d_wu.h"
 871           break;
 872         }
 873         if((insn.bits & 0x3ff1ff) == 0xb0d3)
 874         {
 875           #include "insns/fcvt_wu_d.h"
 876           break;
 877         }
 878         if((insn.bits & 0x1ffff) == 0x60d3)
 879         {
 880           #include "insns/fsgnjn_d.h"
 881           break;
 882         }
 883         if((insn.bits & 0x3ff1ff) == 0xd0d3)
 884         {
 885           #include "insns/fcvt_d_lu.h"
 886           break;
 887         }
 888         if((insn.bits & 0x3ff1ff) == 0xa0d3)
 889         {
 890           #include "insns/fcvt_w_d.h"
 891           break;
 892         }
 893         if((insn.bits & 0x3fffff) == 0x1e0d3)
 894         {
 895           #include "insns/mxtf_d.h"
 896           break;
 897         }
 898         if((insn.bits & 0x1ffff) == 0x50d3)
 899         {
 900           #include "insns/fsgnj_d.h"
 901           break;
 902         }
 903         if((insn.bits & 0x3ff1ff) == 0x80d3)
 904         {
 905           #include "insns/fcvt_l_d.h"
 906           break;
 907         }
 908         if((insn.bits & 0x1f1ff) == 0xd3)
 909         {
 910           #include "insns/fadd_d.h"
 911           break;
 912         }
 913         if((insn.bits & 0x3ff1ff) == 0x90d3)
 914         {
 915           #include "insns/fcvt_lu_d.h"
 916           break;
 917         }
 918         if((insn.bits & 0x1f1ff) == 0x10d3)
 919         {
 920           #include "insns/fsub_d.h"
 921           break;
 922         }
 923         if((insn.bits & 0x3ff1ff) == 0x40d3)
 924         {
 925           #include "insns/fsqrt_d.h"
 926           break;
 927         }
 928         if((insn.bits & 0x1f1ff) == 0x30d3)
 929         {
 930           #include "insns/fdiv_d.h"
 931           break;
 932         }
 933         #include "insns/unimp.h"
 934       }
 935       default:
 936       {
 937         #include "insns/unimp.h"
 938       }
 939     }
 940     break;
 941   }
 942   case 0x63:
 943   {
 944     switch((insn.bits >> 0x7) & 0x7)
 945     {
 946       case 0x0:
 947       {
 948         #include "insns/beq.h"
 949         break;
 950       }
 951       case 0x1:
 952       {
 953         #include "insns/bne.h"
 954         break;
 955       }
 956       case 0x4:
 957       {
 958         #include "insns/blt.h"
 959         break;
 960       }
 961       case 0x5:
 962       {
 963         #include "insns/bge.h"
 964         break;
 965       }
 966       case 0x6:
 967       {
 968         #include "insns/bltu.h"
 969         break;
 970       }
 971       case 0x7:
 972       {
 973         #include "insns/bgeu.h"
 974         break;
 975       }
 976       default:
 977       {
 978         #include "insns/unimp.h"
 979       }
 980     }
 981     break;
 982   }
 983   case 0x67:
 984   {
 985     #include "insns/j.h"
 986     break;
 987   }
 988   case 0x6b:
 989   {
 990     switch((insn.bits >> 0x7) & 0x7)
 991     {
 992       case 0x0:
 993       {
 994         #include "insns/jalr_c.h"
 995         break;
 996       }
 997       case 0x1:
 998       {
 999         #include "insns/jalr_r.h"
1000         break;
1001       }
1002       case 0x2:
1003       {
1004         #include "insns/jalr_j.h"
1005         break;
1006       }
1007       case 0x4:
1008       {
1009         if((insn.bits & 0x7ffffff) == 0x26b)
1010         {
1011           #include "insns/rdnpc.h"
1012           break;
1013         }
1014         #include "insns/unimp.h"
1015       }
1016       default:
1017       {
1018         #include "insns/unimp.h"
1019       }
1020     }
1021     break;
1022   }
1023   case 0x6f:
1024   {
1025     #include "insns/jal.h"
1026     break;
1027   }
1028   case 0x77:
1029   {
1030     switch((insn.bits >> 0x7) & 0x7)
1031     {
1032       case 0x0:
1033       {
1034         if((insn.bits & 0xffffffff) == 0x77)
1035         {
1036           #include "insns/syscall.h"
1037           break;
1038         }
1039         #include "insns/unimp.h"
1040       }
1041       case 0x1:
1042       {
1043         if((insn.bits & 0xffffffff) == 0xf7)
1044         {
1045           #include "insns/break.h"
1046           break;
1047         }
1048         #include "insns/unimp.h"
1049       }
1050       default:
1051       {
1052         #include "insns/unimp.h"
1053       }
1054     }
1055     break;
1056   }
1057   case 0x7b:
1058   {
1059     switch((insn.bits >> 0x7) & 0x7)
1060     {
1061       case 0x0:
1062       {
1063         if((insn.bits & 0x7ffffff) == 0x7b)
1064         {
1065           #include "insns/ei.h"
1066           break;
1067         }
1068         #include "insns/unimp.h"
1069       }
1070       case 0x1:
1071       {
1072         if((insn.bits & 0x7ffffff) == 0xfb)
1073         {
1074           #include "insns/di.h"
1075           break;
1076         }
1077         #include "insns/unimp.h"
1078       }
1079       case 0x2:
1080       {
1081         if((insn.bits & 0x7c1ffff) == 0x17b)
1082         {
1083           #include "insns/mfpcr.h"
1084           break;
1085         }
1086         #include "insns/unimp.h"
1087       }
1088       case 0x3:
1089       {
1090         if((insn.bits & 0xf801ffff) == 0x1fb)
1091         {
1092           #include "insns/mtpcr.h"
1093           break;
1094         }
1095         #include "insns/unimp.h"
1096       }
1097       case 0x4:
1098       {
1099         if((insn.bits & 0xffffffff) == 0x27b)
1100         {
1101           #include "insns/eret.h"
1102           break;
1103         }
1104         #include "insns/unimp.h"
1105       }
1106       default:
1107       {
1108         #include "insns/unimp.h"
1109       }
1110     }
1111     break;
1112   }
1113   default:
1114   {
1115     #include "insns/unimp.h"
1116   }
1117 }