riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x0) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     #include "insns/c_li.h"
   7     break;
   8   }
   9   case 0x1:
  10   {
  11     #include "insns/c_addi.h"
  12     break;
  13   }
  14   case 0x2:
  15   {
  16         if((insn.bits & 0x801f) == 0x2)
  17         {
  18           #include "insns/c_move.h"
  19           break;
  20         }
  21         if((insn.bits & 0x801f) == 0x8002)
  22         {
  23           #include "insns/c_j.h"
  24           break;
  25         }
  26         throw_illegal_instruction;
  27     break;
  28   }
  29   case 0x3:
  30   {
  31         if((insn.bits & 0x3ff) == 0x3)
  32         {
  33           #include "insns/lb.h"
  34           break;
  35         }
  36         if((insn.bits & 0x3ff) == 0x83)
  37         {
  38           #include "insns/lh.h"
  39           break;
  40         }
  41         if((insn.bits & 0x3ff) == 0x103)
  42         {
  43           #include "insns/lw.h"
  44           break;
  45         }
  46         if((insn.bits & 0x3ff) == 0x183)
  47         {
  48           #include "insns/ld.h"
  49           break;
  50         }
  51         if((insn.bits & 0x3ff) == 0x303)
  52         {
  53           #include "insns/lwu.h"
  54           break;
  55         }
  56         if((insn.bits & 0x3ff) == 0x203)
  57         {
  58           #include "insns/lbu.h"
  59           break;
  60         }
  61         if((insn.bits & 0x3ff) == 0x283)
  62         {
  63           #include "insns/lhu.h"
  64           break;
  65         }
  66         throw_illegal_instruction;
  67     break;
  68   }
  69   case 0x4:
  70   {
  71     #include "insns/c_ldsp.h"
  72     break;
  73   }
  74   case 0x5:
  75   {
  76     #include "insns/c_lwsp.h"
  77     break;
  78   }
  79   case 0x6:
  80   {
  81     #include "insns/c_sdsp.h"
  82     break;
  83   }
  84   case 0x7:
  85   {
  86         if((insn.bits & 0x3ff) == 0x107)
  87         {
  88           #include "insns/flw.h"
  89           break;
  90         }
  91         if((insn.bits & 0x3ff) == 0x187)
  92         {
  93           #include "insns/fld.h"
  94           break;
  95         }
  96         throw_illegal_instruction;
  97     break;
  98   }
  99   case 0x8:
 100   {
 101     #include "insns/c_swsp.h"
 102     break;
 103   }
 104   case 0x9:
 105   {
 106     #include "insns/c_ld.h"
 107     break;
 108   }
 109   case 0xa:
 110   {
 111     #include "insns/c_lw.h"
 112     break;
 113   }
 114   case 0xb:
 115   {
 116         if((insn.bits & 0x1ffff) == 0x128b)
 117         {
 118           #include "insns/vlsthu.h"
 119           break;
 120         }
 121         if((insn.bits & 0xfff) == 0xb0b)
 122         {
 123           #include "insns/vlsegstwu.h"
 124           break;
 125         }
 126         if((insn.bits & 0x3fffff) == 0x30b)
 127         {
 128           #include "insns/vlwu.h"
 129           break;
 130         }
 131         if((insn.bits & 0x3fffff) == 0x8b)
 132         {
 133           #include "insns/vlh.h"
 134           break;
 135         }
 136         if((insn.bits & 0x1ffff) == 0x158b)
 137         {
 138           #include "insns/vflstd.h"
 139           break;
 140         }
 141         if((insn.bits & 0x3fffff) == 0xb)
 142         {
 143           #include "insns/vlb.h"
 144           break;
 145         }
 146         if((insn.bits & 0x3fffff) == 0x18b)
 147         {
 148           #include "insns/vld.h"
 149           break;
 150         }
 151         if((insn.bits & 0x1ffff) == 0x150b)
 152         {
 153           #include "insns/vflstw.h"
 154           break;
 155         }
 156         if((insn.bits & 0x3fffff) == 0x10b)
 157         {
 158           #include "insns/vlw.h"
 159           break;
 160         }
 161         if((insn.bits & 0x1ffff) == 0x120b)
 162         {
 163           #include "insns/vlstbu.h"
 164           break;
 165         }
 166         if((insn.bits & 0x1ffff) == 0x220b)
 167         {
 168           #include "insns/vlsegbu.h"
 169           break;
 170         }
 171         if((insn.bits & 0xfff) == 0xa8b)
 172         {
 173           #include "insns/vlsegsthu.h"
 174           break;
 175         }
 176         if((insn.bits & 0x1ffff) == 0x110b)
 177         {
 178           #include "insns/vlstw.h"
 179           break;
 180         }
 181         if((insn.bits & 0x1ffff) == 0x108b)
 182         {
 183           #include "insns/vlsth.h"
 184           break;
 185         }
 186         if((insn.bits & 0x1ffff) == 0x100b)
 187         {
 188           #include "insns/vlstb.h"
 189           break;
 190         }
 191         if((insn.bits & 0x1ffff) == 0x118b)
 192         {
 193           #include "insns/vlstd.h"
 194           break;
 195         }
 196         if((insn.bits & 0xfff) == 0xa0b)
 197         {
 198           #include "insns/vlsegstbu.h"
 199           break;
 200         }
 201         if((insn.bits & 0x3fffff) == 0x28b)
 202         {
 203           #include "insns/vlhu.h"
 204           break;
 205         }
 206         if((insn.bits & 0xfff) == 0x90b)
 207         {
 208           #include "insns/vlsegstw.h"
 209           break;
 210         }
 211         if((insn.bits & 0x1ffff) == 0x130b)
 212         {
 213           #include "insns/vlstwu.h"
 214           break;
 215         }
 216         if((insn.bits & 0xfff) == 0x80b)
 217         {
 218           #include "insns/vlsegstb.h"
 219           break;
 220         }
 221         if((insn.bits & 0xfff) == 0x98b)
 222         {
 223           #include "insns/vlsegstd.h"
 224           break;
 225         }
 226         if((insn.bits & 0x1ffff) == 0x258b)
 227         {
 228           #include "insns/vflsegd.h"
 229           break;
 230         }
 231         if((insn.bits & 0x1ffff) == 0x250b)
 232         {
 233           #include "insns/vflsegw.h"
 234           break;
 235         }
 236         if((insn.bits & 0xfff) == 0x88b)
 237         {
 238           #include "insns/vlsegsth.h"
 239           break;
 240         }
 241         if((insn.bits & 0xfff) == 0xd0b)
 242         {
 243           #include "insns/vflsegstw.h"
 244           break;
 245         }
 246         if((insn.bits & 0xfff) == 0xd8b)
 247         {
 248           #include "insns/vflsegstd.h"
 249           break;
 250         }
 251         if((insn.bits & 0x3fffff) == 0x58b)
 252         {
 253           #include "insns/vfld.h"
 254           break;
 255         }
 256         if((insn.bits & 0x1ffff) == 0x230b)
 257         {
 258           #include "insns/vlsegwu.h"
 259           break;
 260         }
 261         if((insn.bits & 0x3fffff) == 0x50b)
 262         {
 263           #include "insns/vflw.h"
 264           break;
 265         }
 266         if((insn.bits & 0x1ffff) == 0x200b)
 267         {
 268           #include "insns/vlsegb.h"
 269           break;
 270         }
 271         if((insn.bits & 0x1ffff) == 0x218b)
 272         {
 273           #include "insns/vlsegd.h"
 274           break;
 275         }
 276         if((insn.bits & 0x1ffff) == 0x208b)
 277         {
 278           #include "insns/vlsegh.h"
 279           break;
 280         }
 281         if((insn.bits & 0x1ffff) == 0x210b)
 282         {
 283           #include "insns/vlsegw.h"
 284           break;
 285         }
 286         if((insn.bits & 0x3fffff) == 0x20b)
 287         {
 288           #include "insns/vlbu.h"
 289           break;
 290         }
 291         if((insn.bits & 0x1ffff) == 0x228b)
 292         {
 293           #include "insns/vlseghu.h"
 294           break;
 295         }
 296         throw_illegal_instruction;
 297     break;
 298   }
 299   case 0xc:
 300   {
 301     #include "insns/c_sd.h"
 302     break;
 303   }
 304   case 0xd:
 305   {
 306     #include "insns/c_sw.h"
 307     break;
 308   }
 309   case 0xf:
 310   {
 311         if((insn.bits & 0x1ffff) == 0x150f)
 312         {
 313           #include "insns/vfsstw.h"
 314           break;
 315         }
 316         if((insn.bits & 0xfff) == 0x90f)
 317         {
 318           #include "insns/vssegstw.h"
 319           break;
 320         }
 321         if((insn.bits & 0xfff) == 0x98f)
 322         {
 323           #include "insns/vssegstd.h"
 324           break;
 325         }
 326         if((insn.bits & 0xfff) == 0x80f)
 327         {
 328           #include "insns/vssegstb.h"
 329           break;
 330         }
 331         if((insn.bits & 0xfff) == 0x88f)
 332         {
 333           #include "insns/vssegsth.h"
 334           break;
 335         }
 336         if((insn.bits & 0x3fffff) == 0x10f)
 337         {
 338           #include "insns/vsw.h"
 339           break;
 340         }
 341         if((insn.bits & 0xfff) == 0xd8f)
 342         {
 343           #include "insns/vfssegstd.h"
 344           break;
 345         }
 346         if((insn.bits & 0x3fffff) == 0xf)
 347         {
 348           #include "insns/vsb.h"
 349           break;
 350         }
 351         if((insn.bits & 0x1ffff) == 0x110f)
 352         {
 353           #include "insns/vsstw.h"
 354           break;
 355         }
 356         if((insn.bits & 0x1ffff) == 0x108f)
 357         {
 358           #include "insns/vssth.h"
 359           break;
 360         }
 361         if((insn.bits & 0x1ffff) == 0x100f)
 362         {
 363           #include "insns/vsstb.h"
 364           break;
 365         }
 366         if((insn.bits & 0x1ffff) == 0x118f)
 367         {
 368           #include "insns/vsstd.h"
 369           break;
 370         }
 371         if((insn.bits & 0x1ffff) == 0x218f)
 372         {
 373           #include "insns/vssegd.h"
 374           break;
 375         }
 376         if((insn.bits & 0x1ffff) == 0x158f)
 377         {
 378           #include "insns/vfsstd.h"
 379           break;
 380         }
 381         if((insn.bits & 0xfff) == 0xd0f)
 382         {
 383           #include "insns/vfssegstw.h"
 384           break;
 385         }
 386         if((insn.bits & 0x1ffff) == 0x210f)
 387         {
 388           #include "insns/vssegw.h"
 389           break;
 390         }
 391         if((insn.bits & 0x3fffff) == 0x18f)
 392         {
 393           #include "insns/vsd.h"
 394           break;
 395         }
 396         if((insn.bits & 0x3fffff) == 0x8f)
 397         {
 398           #include "insns/vsh.h"
 399           break;
 400         }
 401         if((insn.bits & 0x1ffff) == 0x208f)
 402         {
 403           #include "insns/vssegh.h"
 404           break;
 405         }
 406         if((insn.bits & 0x3fffff) == 0x50f)
 407         {
 408           #include "insns/vfsw.h"
 409           break;
 410         }
 411         if((insn.bits & 0x3fffff) == 0x58f)
 412         {
 413           #include "insns/vfsd.h"
 414           break;
 415         }
 416         if((insn.bits & 0x1ffff) == 0x250f)
 417         {
 418           #include "insns/vfssegw.h"
 419           break;
 420         }
 421         if((insn.bits & 0x1ffff) == 0x200f)
 422         {
 423           #include "insns/vssegb.h"
 424           break;
 425         }
 426         if((insn.bits & 0x1ffff) == 0x258f)
 427         {
 428           #include "insns/vfssegd.h"
 429           break;
 430         }
 431         throw_illegal_instruction;
 432     break;
 433   }
 434   case 0x10:
 435   {
 436     #include "insns/c_beq.h"
 437     break;
 438   }
 439   case 0x11:
 440   {
 441     #include "insns/c_bne.h"
 442     break;
 443   }
 444   case 0x12:
 445   {
 446         if((insn.bits & 0x801f) == 0x12)
 447         {
 448           #include "insns/c_lw0.h"
 449           break;
 450         }
 451         if((insn.bits & 0x801f) == 0x8012)
 452         {
 453           #include "insns/c_ld0.h"
 454           break;
 455         }
 456         throw_illegal_instruction;
 457     break;
 458   }
 459   case 0x13:
 460   {
 461         if((insn.bits & 0x3ff) == 0x193)
 462         {
 463           #include "insns/sltiu.h"
 464           break;
 465         }
 466         if((insn.bits & 0x3f03ff) == 0x293)
 467         {
 468           #include "insns/srli.h"
 469           break;
 470         }
 471         if((insn.bits & 0x3ff) == 0x13)
 472         {
 473           #include "insns/addi.h"
 474           break;
 475         }
 476         if((insn.bits & 0x3f03ff) == 0x10293)
 477         {
 478           #include "insns/srai.h"
 479           break;
 480         }
 481         if((insn.bits & 0x3ff) == 0x313)
 482         {
 483           #include "insns/ori.h"
 484           break;
 485         }
 486         if((insn.bits & 0x3ff) == 0x213)
 487         {
 488           #include "insns/xori.h"
 489           break;
 490         }
 491         if((insn.bits & 0x3ff) == 0x393)
 492         {
 493           #include "insns/andi.h"
 494           break;
 495         }
 496         if((insn.bits & 0x3ff) == 0x113)
 497         {
 498           #include "insns/slti.h"
 499           break;
 500         }
 501         if((insn.bits & 0x3f03ff) == 0x93)
 502         {
 503           #include "insns/slli.h"
 504           break;
 505         }
 506         throw_illegal_instruction;
 507     break;
 508   }
 509   case 0x14:
 510   {
 511     #include "insns/c_flw.h"
 512     break;
 513   }
 514   case 0x15:
 515   {
 516     #include "insns/c_fld.h"
 517     break;
 518   }
 519   case 0x16:
 520   {
 521     #include "insns/c_fsw.h"
 522     break;
 523   }
 524   case 0x18:
 525   {
 526     #include "insns/c_fsd.h"
 527     break;
 528   }
 529   case 0x19:
 530   {
 531         if((insn.bits & 0x1c1f) == 0x19)
 532         {
 533           #include "insns/c_slli.h"
 534           break;
 535         }
 536         if((insn.bits & 0x1c1f) == 0x819)
 537         {
 538           #include "insns/c_srli.h"
 539           break;
 540         }
 541         if((insn.bits & 0x1c1f) == 0x1419)
 542         {
 543           #include "insns/c_srai32.h"
 544           break;
 545         }
 546         if((insn.bits & 0x1c1f) == 0x1819)
 547         {
 548           #include "insns/c_slliw.h"
 549           break;
 550         }
 551         if((insn.bits & 0x1c1f) == 0xc19)
 552         {
 553           #include "insns/c_srli32.h"
 554           break;
 555         }
 556         if((insn.bits & 0x1c1f) == 0x1019)
 557         {
 558           #include "insns/c_srai.h"
 559           break;
 560         }
 561         if((insn.bits & 0x1c1f) == 0x419)
 562         {
 563           #include "insns/c_slli32.h"
 564           break;
 565         }
 566         throw_illegal_instruction;
 567     break;
 568   }
 569   case 0x1a:
 570   {
 571         if((insn.bits & 0x801f) == 0x801a)
 572         {
 573           #include "insns/c_sub.h"
 574           break;
 575         }
 576         if((insn.bits & 0x801f) == 0x1a)
 577         {
 578           #include "insns/c_add.h"
 579           break;
 580         }
 581         throw_illegal_instruction;
 582     break;
 583   }
 584   case 0x1b:
 585   {
 586         if((insn.bits & 0x3f83ff) == 0x9b)
 587         {
 588           #include "insns/slliw.h"
 589           break;
 590         }
 591         if((insn.bits & 0x3f83ff) == 0x29b)
 592         {
 593           #include "insns/srliw.h"
 594           break;
 595         }
 596         if((insn.bits & 0x3ff) == 0x1b)
 597         {
 598           #include "insns/addiw.h"
 599           break;
 600         }
 601         if((insn.bits & 0x3f83ff) == 0x1029b)
 602         {
 603           #include "insns/sraiw.h"
 604           break;
 605         }
 606         throw_illegal_instruction;
 607     break;
 608   }
 609   case 0x1c:
 610   {
 611         if((insn.bits & 0x31f) == 0x1c)
 612         {
 613           #include "insns/c_add3.h"
 614           break;
 615         }
 616         if((insn.bits & 0x31f) == 0x21c)
 617         {
 618           #include "insns/c_or3.h"
 619           break;
 620         }
 621         if((insn.bits & 0x31f) == 0x31c)
 622         {
 623           #include "insns/c_and3.h"
 624           break;
 625         }
 626         if((insn.bits & 0x31f) == 0x11c)
 627         {
 628           #include "insns/c_sub3.h"
 629           break;
 630         }
 631         throw_illegal_instruction;
 632     break;
 633   }
 634   case 0x1d:
 635   {
 636     #include "insns/c_addiw.h"
 637     break;
 638   }
 639   case 0x20:
 640   {
 641     #include "insns/c_li.h"
 642     break;
 643   }
 644   case 0x21:
 645   {
 646     #include "insns/c_addi.h"
 647     break;
 648   }
 649   case 0x22:
 650   {
 651         if((insn.bits & 0x801f) == 0x2)
 652         {
 653           #include "insns/c_move.h"
 654           break;
 655         }
 656         if((insn.bits & 0x801f) == 0x8002)
 657         {
 658           #include "insns/c_j.h"
 659           break;
 660         }
 661         throw_illegal_instruction;
 662     break;
 663   }
 664   case 0x23:
 665   {
 666         if((insn.bits & 0x3ff) == 0x123)
 667         {
 668           #include "insns/sw.h"
 669           break;
 670         }
 671         if((insn.bits & 0x3ff) == 0xa3)
 672         {
 673           #include "insns/sh.h"
 674           break;
 675         }
 676         if((insn.bits & 0x3ff) == 0x23)
 677         {
 678           #include "insns/sb.h"
 679           break;
 680         }
 681         if((insn.bits & 0x3ff) == 0x1a3)
 682         {
 683           #include "insns/sd.h"
 684           break;
 685         }
 686         throw_illegal_instruction;
 687     break;
 688   }
 689   case 0x24:
 690   {
 691     #include "insns/c_ldsp.h"
 692     break;
 693   }
 694   case 0x25:
 695   {
 696     #include "insns/c_lwsp.h"
 697     break;
 698   }
 699   case 0x26:
 700   {
 701     #include "insns/c_sdsp.h"
 702     break;
 703   }
 704   case 0x27:
 705   {
 706         if((insn.bits & 0x3ff) == 0x1a7)
 707         {
 708           #include "insns/fsd.h"
 709           break;
 710         }
 711         if((insn.bits & 0x3ff) == 0x127)
 712         {
 713           #include "insns/fsw.h"
 714           break;
 715         }
 716         throw_illegal_instruction;
 717     break;
 718   }
 719   case 0x28:
 720   {
 721     #include "insns/c_swsp.h"
 722     break;
 723   }
 724   case 0x29:
 725   {
 726     #include "insns/c_ld.h"
 727     break;
 728   }
 729   case 0x2a:
 730   {
 731     #include "insns/c_lw.h"
 732     break;
 733   }
 734   case 0x2b:
 735   {
 736         if((insn.bits & 0x1ffff) == 0x19ab)
 737         {
 738           #include "insns/amominu_d.h"
 739           break;
 740         }
 741         if((insn.bits & 0x1ffff) == 0x192b)
 742         {
 743           #include "insns/amominu_w.h"
 744           break;
 745         }
 746         if((insn.bits & 0x1ffff) == 0x9ab)
 747         {
 748           #include "insns/amoand_d.h"
 749           break;
 750         }
 751         if((insn.bits & 0x1ffff) == 0x92b)
 752         {
 753           #include "insns/amoand_w.h"
 754           break;
 755         }
 756         if((insn.bits & 0x1ffff) == 0x1dab)
 757         {
 758           #include "insns/amomaxu_d.h"
 759           break;
 760         }
 761         if((insn.bits & 0x1ffff) == 0x1d2b)
 762         {
 763           #include "insns/amomaxu_w.h"
 764           break;
 765         }
 766         if((insn.bits & 0x1ffff) == 0x1ab)
 767         {
 768           #include "insns/amoadd_d.h"
 769           break;
 770         }
 771         if((insn.bits & 0x1ffff) == 0x152b)
 772         {
 773           #include "insns/amomax_w.h"
 774           break;
 775         }
 776         if((insn.bits & 0x1ffff) == 0x12b)
 777         {
 778           #include "insns/amoadd_w.h"
 779           break;
 780         }
 781         if((insn.bits & 0x1ffff) == 0x15ab)
 782         {
 783           #include "insns/amomax_d.h"
 784           break;
 785         }
 786         if((insn.bits & 0x1ffff) == 0xdab)
 787         {
 788           #include "insns/amoor_d.h"
 789           break;
 790         }
 791         if((insn.bits & 0x1ffff) == 0xd2b)
 792         {
 793           #include "insns/amoor_w.h"
 794           break;
 795         }
 796         if((insn.bits & 0x1ffff) == 0x112b)
 797         {
 798           #include "insns/amomin_w.h"
 799           break;
 800         }
 801         if((insn.bits & 0x1ffff) == 0x5ab)
 802         {
 803           #include "insns/amoswap_d.h"
 804           break;
 805         }
 806         if((insn.bits & 0x1ffff) == 0x11ab)
 807         {
 808           #include "insns/amomin_d.h"
 809           break;
 810         }
 811         if((insn.bits & 0x1ffff) == 0x52b)
 812         {
 813           #include "insns/amoswap_w.h"
 814           break;
 815         }
 816         throw_illegal_instruction;
 817     break;
 818   }
 819   case 0x2c:
 820   {
 821     #include "insns/c_sd.h"
 822     break;
 823   }
 824   case 0x2d:
 825   {
 826     #include "insns/c_sw.h"
 827     break;
 828   }
 829   case 0x2f:
 830   {
 831         if((insn.bits & 0x3ff) == 0x32f)
 832         {
 833           #include "insns/fence_l_cv.h"
 834           break;
 835         }
 836         if((insn.bits & 0x3ff) == 0x2af)
 837         {
 838           #include "insns/fence_g_v.h"
 839           break;
 840         }
 841         if((insn.bits & 0x3ff) == 0x12f)
 842         {
 843           #include "insns/fence.h"
 844           break;
 845         }
 846         if((insn.bits & 0x3ff) == 0xaf)
 847         {
 848           #include "insns/fence_i.h"
 849           break;
 850         }
 851         if((insn.bits & 0x3ff) == 0x3af)
 852         {
 853           #include "insns/fence_g_cv.h"
 854           break;
 855         }
 856         if((insn.bits & 0x3ff) == 0x22f)
 857         {
 858           #include "insns/fence_l_v.h"
 859           break;
 860         }
 861         throw_illegal_instruction;
 862     break;
 863   }
 864   case 0x30:
 865   {
 866     #include "insns/c_beq.h"
 867     break;
 868   }
 869   case 0x31:
 870   {
 871     #include "insns/c_bne.h"
 872     break;
 873   }
 874   case 0x32:
 875   {
 876         if((insn.bits & 0x801f) == 0x12)
 877         {
 878           #include "insns/c_lw0.h"
 879           break;
 880         }
 881         if((insn.bits & 0x801f) == 0x8012)
 882         {
 883           #include "insns/c_ld0.h"
 884           break;
 885         }
 886         throw_illegal_instruction;
 887     break;
 888   }
 889   case 0x33:
 890   {
 891         if((insn.bits & 0x1ffff) == 0x33)
 892         {
 893           #include "insns/add.h"
 894           break;
 895         }
 896         if((insn.bits & 0x1ffff) == 0x433)
 897         {
 898           #include "insns/mul.h"
 899           break;
 900         }
 901         if((insn.bits & 0x1ffff) == 0x633)
 902         {
 903           #include "insns/div.h"
 904           break;
 905         }
 906         if((insn.bits & 0x1ffff) == 0xb3)
 907         {
 908           #include "insns/sll.h"
 909           break;
 910         }
 911         if((insn.bits & 0x1ffff) == 0x233)
 912         {
 913           #include "insns/xor.h"
 914           break;
 915         }
 916         if((insn.bits & 0x1ffff) == 0x10033)
 917         {
 918           #include "insns/sub.h"
 919           break;
 920         }
 921         if((insn.bits & 0x1ffff) == 0x733)
 922         {
 923           #include "insns/rem.h"
 924           break;
 925         }
 926         if((insn.bits & 0x1ffff) == 0x4b3)
 927         {
 928           #include "insns/mulh.h"
 929           break;
 930         }
 931         if((insn.bits & 0x1ffff) == 0x102b3)
 932         {
 933           #include "insns/sra.h"
 934           break;
 935         }
 936         if((insn.bits & 0x1ffff) == 0x2b3)
 937         {
 938           #include "insns/srl.h"
 939           break;
 940         }
 941         if((insn.bits & 0x1ffff) == 0x333)
 942         {
 943           #include "insns/or.h"
 944           break;
 945         }
 946         if((insn.bits & 0x1ffff) == 0x533)
 947         {
 948           #include "insns/mulhsu.h"
 949           break;
 950         }
 951         if((insn.bits & 0x1ffff) == 0x133)
 952         {
 953           #include "insns/slt.h"
 954           break;
 955         }
 956         if((insn.bits & 0x1ffff) == 0x7b3)
 957         {
 958           #include "insns/remu.h"
 959           break;
 960         }
 961         if((insn.bits & 0x1ffff) == 0x1b3)
 962         {
 963           #include "insns/sltu.h"
 964           break;
 965         }
 966         if((insn.bits & 0x1ffff) == 0x3b3)
 967         {
 968           #include "insns/and.h"
 969           break;
 970         }
 971         if((insn.bits & 0x1ffff) == 0x5b3)
 972         {
 973           #include "insns/mulhu.h"
 974           break;
 975         }
 976         if((insn.bits & 0x1ffff) == 0x6b3)
 977         {
 978           #include "insns/divu.h"
 979           break;
 980         }
 981         throw_illegal_instruction;
 982     break;
 983   }
 984   case 0x34:
 985   {
 986     #include "insns/c_flw.h"
 987     break;
 988   }
 989   case 0x35:
 990   {
 991     #include "insns/c_fld.h"
 992     break;
 993   }
 994   case 0x36:
 995   {
 996     #include "insns/c_fsw.h"
 997     break;
 998   }
 999   case 0x37:
1000   {
1001     #include "insns/lui.h"
1002     break;
1003   }
1004   case 0x38:
1005   {
1006     #include "insns/c_fsd.h"
1007     break;
1008   }
1009   case 0x39:
1010   {
1011         if((insn.bits & 0x1c1f) == 0x19)
1012         {
1013           #include "insns/c_slli.h"
1014           break;
1015         }
1016         if((insn.bits & 0x1c1f) == 0x819)
1017         {
1018           #include "insns/c_srli.h"
1019           break;
1020         }
1021         if((insn.bits & 0x1c1f) == 0x1419)
1022         {
1023           #include "insns/c_srai32.h"
1024           break;
1025         }
1026         if((insn.bits & 0x1c1f) == 0x1819)
1027         {
1028           #include "insns/c_slliw.h"
1029           break;
1030         }
1031         if((insn.bits & 0x1c1f) == 0xc19)
1032         {
1033           #include "insns/c_srli32.h"
1034           break;
1035         }
1036         if((insn.bits & 0x1c1f) == 0x1019)
1037         {
1038           #include "insns/c_srai.h"
1039           break;
1040         }
1041         if((insn.bits & 0x1c1f) == 0x419)
1042         {
1043           #include "insns/c_slli32.h"
1044           break;
1045         }
1046         throw_illegal_instruction;
1047     break;
1048   }
1049   case 0x3a:
1050   {
1051         if((insn.bits & 0x801f) == 0x801a)
1052         {
1053           #include "insns/c_sub.h"
1054           break;
1055         }
1056         if((insn.bits & 0x801f) == 0x1a)
1057         {
1058           #include "insns/c_add.h"
1059           break;
1060         }
1061         throw_illegal_instruction;
1062     break;
1063   }
1064   case 0x3b:
1065   {
1066         if((insn.bits & 0x1ffff) == 0x7bb)
1067         {
1068           #include "insns/remuw.h"
1069           break;
1070         }
1071         if((insn.bits & 0x1ffff) == 0x6bb)
1072         {
1073           #include "insns/divuw.h"
1074           break;
1075         }
1076         if((insn.bits & 0x1ffff) == 0x43b)
1077         {
1078           #include "insns/mulw.h"
1079           break;
1080         }
1081         if((insn.bits & 0x1ffff) == 0x2bb)
1082         {
1083           #include "insns/srlw.h"
1084           break;
1085         }
1086         if((insn.bits & 0x1ffff) == 0x3b)
1087         {
1088           #include "insns/addw.h"
1089           break;
1090         }
1091         if((insn.bits & 0x1ffff) == 0x102bb)
1092         {
1093           #include "insns/sraw.h"
1094           break;
1095         }
1096         if((insn.bits & 0x1ffff) == 0x1003b)
1097         {
1098           #include "insns/subw.h"
1099           break;
1100         }
1101         if((insn.bits & 0x1ffff) == 0xbb)
1102         {
1103           #include "insns/sllw.h"
1104           break;
1105         }
1106         if((insn.bits & 0x1ffff) == 0x73b)
1107         {
1108           #include "insns/remw.h"
1109           break;
1110         }
1111         if((insn.bits & 0x1ffff) == 0x63b)
1112         {
1113           #include "insns/divw.h"
1114           break;
1115         }
1116         throw_illegal_instruction;
1117     break;
1118   }
1119   case 0x3c:
1120   {
1121         if((insn.bits & 0x31f) == 0x1c)
1122         {
1123           #include "insns/c_add3.h"
1124           break;
1125         }
1126         if((insn.bits & 0x31f) == 0x21c)
1127         {
1128           #include "insns/c_or3.h"
1129           break;
1130         }
1131         if((insn.bits & 0x31f) == 0x31c)
1132         {
1133           #include "insns/c_and3.h"
1134           break;
1135         }
1136         if((insn.bits & 0x31f) == 0x11c)
1137         {
1138           #include "insns/c_sub3.h"
1139           break;
1140         }
1141         throw_illegal_instruction;
1142     break;
1143   }
1144   case 0x3d:
1145   {
1146     #include "insns/c_addiw.h"
1147     break;
1148   }
1149   case 0x40:
1150   {
1151     #include "insns/c_li.h"
1152     break;
1153   }
1154   case 0x41:
1155   {
1156     #include "insns/c_addi.h"
1157     break;
1158   }
1159   case 0x42:
1160   {
1161         if((insn.bits & 0x801f) == 0x2)
1162         {
1163           #include "insns/c_move.h"
1164           break;
1165         }
1166         if((insn.bits & 0x801f) == 0x8002)
1167         {
1168           #include "insns/c_j.h"
1169           break;
1170         }
1171         throw_illegal_instruction;
1172     break;
1173   }
1174   case 0x43:
1175   {
1176         if((insn.bits & 0x1ff) == 0x43)
1177         {
1178           #include "insns/fmadd_s.h"
1179           break;
1180         }
1181         if((insn.bits & 0x1ff) == 0xc3)
1182         {
1183           #include "insns/fmadd_d.h"
1184           break;
1185         }
1186         throw_illegal_instruction;
1187     break;
1188   }
1189   case 0x44:
1190   {
1191     #include "insns/c_ldsp.h"
1192     break;
1193   }
1194   case 0x45:
1195   {
1196     #include "insns/c_lwsp.h"
1197     break;
1198   }
1199   case 0x46:
1200   {
1201     #include "insns/c_sdsp.h"
1202     break;
1203   }
1204   case 0x47:
1205   {
1206         if((insn.bits & 0x1ff) == 0x47)
1207         {
1208           #include "insns/fmsub_s.h"
1209           break;
1210         }
1211         if((insn.bits & 0x1ff) == 0xc7)
1212         {
1213           #include "insns/fmsub_d.h"
1214           break;
1215         }
1216         throw_illegal_instruction;
1217     break;
1218   }
1219   case 0x48:
1220   {
1221     #include "insns/c_swsp.h"
1222     break;
1223   }
1224   case 0x49:
1225   {
1226     #include "insns/c_ld.h"
1227     break;
1228   }
1229   case 0x4a:
1230   {
1231     #include "insns/c_lw.h"
1232     break;
1233   }
1234   case 0x4b:
1235   {
1236         if((insn.bits & 0x1ff) == 0x4b)
1237         {
1238           #include "insns/fnmsub_s.h"
1239           break;
1240         }
1241         if((insn.bits & 0x1ff) == 0xcb)
1242         {
1243           #include "insns/fnmsub_d.h"
1244           break;
1245         }
1246         throw_illegal_instruction;
1247     break;
1248   }
1249   case 0x4c:
1250   {
1251     #include "insns/c_sd.h"
1252     break;
1253   }
1254   case 0x4d:
1255   {
1256     #include "insns/c_sw.h"
1257     break;
1258   }
1259   case 0x4f:
1260   {
1261         if((insn.bits & 0x1ff) == 0x4f)
1262         {
1263           #include "insns/fnmadd_s.h"
1264           break;
1265         }
1266         if((insn.bits & 0x1ff) == 0xcf)
1267         {
1268           #include "insns/fnmadd_d.h"
1269           break;
1270         }
1271         throw_illegal_instruction;
1272     break;
1273   }
1274   case 0x50:
1275   {
1276     #include "insns/c_beq.h"
1277     break;
1278   }
1279   case 0x51:
1280   {
1281     #include "insns/c_bne.h"
1282     break;
1283   }
1284   case 0x52:
1285   {
1286         if((insn.bits & 0x801f) == 0x12)
1287         {
1288           #include "insns/c_lw0.h"
1289           break;
1290         }
1291         if((insn.bits & 0x801f) == 0x8012)
1292         {
1293           #include "insns/c_ld0.h"
1294           break;
1295         }
1296         throw_illegal_instruction;
1297     break;
1298   }
1299   case 0x53:
1300   {
1301         if((insn.bits & 0x1ffff) == 0x180d3)
1302         {
1303           #include "insns/fmin_d.h"
1304           break;
1305         }
1306         if((insn.bits & 0x3ff1ff) == 0x9053)
1307         {
1308           #include "insns/fcvt_lu_s.h"
1309           break;
1310         }
1311         if((insn.bits & 0x1ffff) == 0x18053)
1312         {
1313           #include "insns/fmin_s.h"
1314           break;
1315         }
1316         if((insn.bits & 0x3ff1ff) == 0xc0d3)
1317         {
1318           #include "insns/fcvt_d_l.h"
1319           break;
1320         }
1321         if((insn.bits & 0x3ff1ff) == 0xe0d3)
1322         {
1323           #include "insns/fcvt_d_w.h"
1324           break;
1325         }
1326         if((insn.bits & 0x3ff1ff) == 0x100d3)
1327         {
1328           #include "insns/fcvt_d_s.h"
1329           break;
1330         }
1331         if((insn.bits & 0x1ffff) == 0x190d3)
1332         {
1333           #include "insns/fmax_d.h"
1334           break;
1335         }
1336         if((insn.bits & 0x3ff1ff) == 0x11053)
1337         {
1338           #include "insns/fcvt_s_d.h"
1339           break;
1340         }
1341         if((insn.bits & 0x3ff1ff) == 0xe053)
1342         {
1343           #include "insns/fcvt_s_w.h"
1344           break;
1345         }
1346         if((insn.bits & 0x7c1ffff) == 0x1c0d3)
1347         {
1348           #include "insns/mftx_d.h"
1349           break;
1350         }
1351         if((insn.bits & 0x7c1ffff) == 0x1c053)
1352         {
1353           #include "insns/mftx_s.h"
1354           break;
1355         }
1356         if((insn.bits & 0x3ff1ff) == 0x8053)
1357         {
1358           #include "insns/fcvt_l_s.h"
1359           break;
1360         }
1361         if((insn.bits & 0x1ffff) == 0x17053)
1362         {
1363           #include "insns/fle_s.h"
1364           break;
1365         }
1366         if((insn.bits & 0x7ffffff) == 0x1d053)
1367         {
1368           #include "insns/mffsr.h"
1369           break;
1370         }
1371         if((insn.bits & 0x1f1ff) == 0x3053)
1372         {
1373           #include "insns/fdiv_s.h"
1374           break;
1375         }
1376         if((insn.bits & 0x1ffff) == 0x170d3)
1377         {
1378           #include "insns/fle_d.h"
1379           break;
1380         }
1381         if((insn.bits & 0x3fffff) == 0x1f053)
1382         {
1383           #include "insns/mtfsr.h"
1384           break;
1385         }
1386         if((insn.bits & 0x3ff1ff) == 0xd053)
1387         {
1388           #include "insns/fcvt_s_lu.h"
1389           break;
1390         }
1391         if((insn.bits & 0x1f1ff) == 0x2053)
1392         {
1393           #include "insns/fmul_s.h"
1394           break;
1395         }
1396         if((insn.bits & 0x1ffff) == 0x160d3)
1397         {
1398           #include "insns/flt_d.h"
1399           break;
1400         }
1401         if((insn.bits & 0x1f1ff) == 0x20d3)
1402         {
1403           #include "insns/fmul_d.h"
1404           break;
1405         }
1406         if((insn.bits & 0x1ffff) == 0x16053)
1407         {
1408           #include "insns/flt_s.h"
1409           break;
1410         }
1411         if((insn.bits & 0x1ffff) == 0x15053)
1412         {
1413           #include "insns/feq_s.h"
1414           break;
1415         }
1416         if((insn.bits & 0x1ffff) == 0x70d3)
1417         {
1418           #include "insns/fsgnjx_d.h"
1419           break;
1420         }
1421         if((insn.bits & 0x1ffff) == 0x7053)
1422         {
1423           #include "insns/fsgnjx_s.h"
1424           break;
1425         }
1426         if((insn.bits & 0x1ffff) == 0x150d3)
1427         {
1428           #include "insns/feq_d.h"
1429           break;
1430         }
1431         if((insn.bits & 0x3ff1ff) == 0xf0d3)
1432         {
1433           #include "insns/fcvt_d_wu.h"
1434           break;
1435         }
1436         if((insn.bits & 0x3ff1ff) == 0xb0d3)
1437         {
1438           #include "insns/fcvt_wu_d.h"
1439           break;
1440         }
1441         if((insn.bits & 0x1ffff) == 0x19053)
1442         {
1443           #include "insns/fmax_s.h"
1444           break;
1445         }
1446         if((insn.bits & 0x3ff1ff) == 0xb053)
1447         {
1448           #include "insns/fcvt_wu_s.h"
1449           break;
1450         }
1451         if((insn.bits & 0x1ffff) == 0x60d3)
1452         {
1453           #include "insns/fsgnjn_d.h"
1454           break;
1455         }
1456         if((insn.bits & 0x3ff1ff) == 0xd0d3)
1457         {
1458           #include "insns/fcvt_d_lu.h"
1459           break;
1460         }
1461         if((insn.bits & 0x3ff1ff) == 0xa0d3)
1462         {
1463           #include "insns/fcvt_w_d.h"
1464           break;
1465         }
1466         if((insn.bits & 0x3fffff) == 0x1e0d3)
1467         {
1468           #include "insns/mxtf_d.h"
1469           break;
1470         }
1471         if((insn.bits & 0x3fffff) == 0x1e053)
1472         {
1473           #include "insns/mxtf_s.h"
1474           break;
1475         }
1476         if((insn.bits & 0x1f1ff) == 0x1053)
1477         {
1478           #include "insns/fsub_s.h"
1479           break;
1480         }
1481         if((insn.bits & 0x1ffff) == 0x5053)
1482         {
1483           #include "insns/fsgnj_s.h"
1484           break;
1485         }
1486         if((insn.bits & 0x1ffff) == 0x50d3)
1487         {
1488           #include "insns/fsgnj_d.h"
1489           break;
1490         }
1491         if((insn.bits & 0x3ff1ff) == 0x80d3)
1492         {
1493           #include "insns/fcvt_l_d.h"
1494           break;
1495         }
1496         if((insn.bits & 0x1f1ff) == 0xd3)
1497         {
1498           #include "insns/fadd_d.h"
1499           break;
1500         }
1501         if((insn.bits & 0x3ff1ff) == 0xf053)
1502         {
1503           #include "insns/fcvt_s_wu.h"
1504           break;
1505         }
1506         if((insn.bits & 0x3ff1ff) == 0xc053)
1507         {
1508           #include "insns/fcvt_s_l.h"
1509           break;
1510         }
1511         if((insn.bits & 0x3ff1ff) == 0x90d3)
1512         {
1513           #include "insns/fcvt_lu_d.h"
1514           break;
1515         }
1516         if((insn.bits & 0x1f1ff) == 0x10d3)
1517         {
1518           #include "insns/fsub_d.h"
1519           break;
1520         }
1521         if((insn.bits & 0x3ff1ff) == 0xa053)
1522         {
1523           #include "insns/fcvt_w_s.h"
1524           break;
1525         }
1526         if((insn.bits & 0x3ff1ff) == 0x4053)
1527         {
1528           #include "insns/fsqrt_s.h"
1529           break;
1530         }
1531         if((insn.bits & 0x1ffff) == 0x6053)
1532         {
1533           #include "insns/fsgnjn_s.h"
1534           break;
1535         }
1536         if((insn.bits & 0x3ff1ff) == 0x40d3)
1537         {
1538           #include "insns/fsqrt_d.h"
1539           break;
1540         }
1541         if((insn.bits & 0x1f1ff) == 0x30d3)
1542         {
1543           #include "insns/fdiv_d.h"
1544           break;
1545         }
1546         if((insn.bits & 0x1f1ff) == 0x53)
1547         {
1548           #include "insns/fadd_s.h"
1549           break;
1550         }
1551         throw_illegal_instruction;
1552     break;
1553   }
1554   case 0x54:
1555   {
1556     #include "insns/c_flw.h"
1557     break;
1558   }
1559   case 0x55:
1560   {
1561     #include "insns/c_fld.h"
1562     break;
1563   }
1564   case 0x56:
1565   {
1566     #include "insns/c_fsw.h"
1567     break;
1568   }
1569   case 0x58:
1570   {
1571     #include "insns/c_fsd.h"
1572     break;
1573   }
1574   case 0x59:
1575   {
1576         if((insn.bits & 0x1c1f) == 0x19)
1577         {
1578           #include "insns/c_slli.h"
1579           break;
1580         }
1581         if((insn.bits & 0x1c1f) == 0x819)
1582         {
1583           #include "insns/c_srli.h"
1584           break;
1585         }
1586         if((insn.bits & 0x1c1f) == 0x1419)
1587         {
1588           #include "insns/c_srai32.h"
1589           break;
1590         }
1591         if((insn.bits & 0x1c1f) == 0x1819)
1592         {
1593           #include "insns/c_slliw.h"
1594           break;
1595         }
1596         if((insn.bits & 0x1c1f) == 0xc19)
1597         {
1598           #include "insns/c_srli32.h"
1599           break;
1600         }
1601         if((insn.bits & 0x1c1f) == 0x1019)
1602         {
1603           #include "insns/c_srai.h"
1604           break;
1605         }
1606         if((insn.bits & 0x1c1f) == 0x419)
1607         {
1608           #include "insns/c_slli32.h"
1609           break;
1610         }
1611         throw_illegal_instruction;
1612     break;
1613   }
1614   case 0x5a:
1615   {
1616         if((insn.bits & 0x801f) == 0x801a)
1617         {
1618           #include "insns/c_sub.h"
1619           break;
1620         }
1621         if((insn.bits & 0x801f) == 0x1a)
1622         {
1623           #include "insns/c_add.h"
1624           break;
1625         }
1626         throw_illegal_instruction;
1627     break;
1628   }
1629   case 0x5c:
1630   {
1631         if((insn.bits & 0x31f) == 0x1c)
1632         {
1633           #include "insns/c_add3.h"
1634           break;
1635         }
1636         if((insn.bits & 0x31f) == 0x21c)
1637         {
1638           #include "insns/c_or3.h"
1639           break;
1640         }
1641         if((insn.bits & 0x31f) == 0x31c)
1642         {
1643           #include "insns/c_and3.h"
1644           break;
1645         }
1646         if((insn.bits & 0x31f) == 0x11c)
1647         {
1648           #include "insns/c_sub3.h"
1649           break;
1650         }
1651         throw_illegal_instruction;
1652     break;
1653   }
1654   case 0x5d:
1655   {
1656     #include "insns/c_addiw.h"
1657     break;
1658   }
1659   case 0x60:
1660   {
1661     #include "insns/c_li.h"
1662     break;
1663   }
1664   case 0x61:
1665   {
1666     #include "insns/c_addi.h"
1667     break;
1668   }
1669   case 0x62:
1670   {
1671         if((insn.bits & 0x801f) == 0x2)
1672         {
1673           #include "insns/c_move.h"
1674           break;
1675         }
1676         if((insn.bits & 0x801f) == 0x8002)
1677         {
1678           #include "insns/c_j.h"
1679           break;
1680         }
1681         throw_illegal_instruction;
1682     break;
1683   }
1684   case 0x63:
1685   {
1686         if((insn.bits & 0x3ff) == 0x363)
1687         {
1688           #include "insns/bltu.h"
1689           break;
1690         }
1691         if((insn.bits & 0x3ff) == 0xe3)
1692         {
1693           #include "insns/bne.h"
1694           break;
1695         }
1696         if((insn.bits & 0x3ff) == 0x3e3)
1697         {
1698           #include "insns/bgeu.h"
1699           break;
1700         }
1701         if((insn.bits & 0x3ff) == 0x263)
1702         {
1703           #include "insns/blt.h"
1704           break;
1705         }
1706         if((insn.bits & 0x3ff) == 0x2e3)
1707         {
1708           #include "insns/bge.h"
1709           break;
1710         }
1711         if((insn.bits & 0x3ff) == 0x63)
1712         {
1713           #include "insns/beq.h"
1714           break;
1715         }
1716         throw_illegal_instruction;
1717     break;
1718   }
1719   case 0x64:
1720   {
1721     #include "insns/c_ldsp.h"
1722     break;
1723   }
1724   case 0x65:
1725   {
1726     #include "insns/c_lwsp.h"
1727     break;
1728   }
1729   case 0x66:
1730   {
1731     #include "insns/c_sdsp.h"
1732     break;
1733   }
1734   case 0x67:
1735   {
1736     #include "insns/j.h"
1737     break;
1738   }
1739   case 0x68:
1740   {
1741     #include "insns/c_swsp.h"
1742     break;
1743   }
1744   case 0x69:
1745   {
1746     #include "insns/c_ld.h"
1747     break;
1748   }
1749   case 0x6a:
1750   {
1751     #include "insns/c_lw.h"
1752     break;
1753   }
1754   case 0x6b:
1755   {
1756         if((insn.bits & 0x3ff) == 0x6b)
1757         {
1758           #include "insns/jalr_c.h"
1759           break;
1760         }
1761         if((insn.bits & 0x3ff) == 0x16b)
1762         {
1763           #include "insns/jalr_j.h"
1764           break;
1765         }
1766         if((insn.bits & 0x3ff) == 0xeb)
1767         {
1768           #include "insns/jalr_r.h"
1769           break;
1770         }
1771         if((insn.bits & 0x7ffffff) == 0x26b)
1772         {
1773           #include "insns/rdnpc.h"
1774           break;
1775         }
1776         throw_illegal_instruction;
1777     break;
1778   }
1779   case 0x6c:
1780   {
1781     #include "insns/c_sd.h"
1782     break;
1783   }
1784   case 0x6d:
1785   {
1786     #include "insns/c_sw.h"
1787     break;
1788   }
1789   case 0x6f:
1790   {
1791     #include "insns/jal.h"
1792     break;
1793   }
1794   case 0x70:
1795   {
1796     #include "insns/c_beq.h"
1797     break;
1798   }
1799   case 0x71:
1800   {
1801     #include "insns/c_bne.h"
1802     break;
1803   }
1804   case 0x72:
1805   {
1806         if((insn.bits & 0x801f) == 0x12)
1807         {
1808           #include "insns/c_lw0.h"
1809           break;
1810         }
1811         if((insn.bits & 0x801f) == 0x8012)
1812         {
1813           #include "insns/c_ld0.h"
1814           break;
1815         }
1816         throw_illegal_instruction;
1817     break;
1818   }
1819   case 0x73:
1820   {
1821         if((insn.bits & 0x3ff) == 0xf3)
1822         {
1823           #include "insns/vvcfgivl.h"
1824           break;
1825         }
1826         if((insn.bits & 0x3fffff) == 0x2f3)
1827         {
1828           #include "insns/vsetvl.h"
1829           break;
1830         }
1831         if((insn.bits & 0x1ffff) == 0x1173)
1832         {
1833           #include "insns/vfmst.h"
1834           break;
1835         }
1836         if((insn.bits & 0x1ffff) == 0x1973)
1837         {
1838           #include "insns/vfmts.h"
1839           break;
1840         }
1841         if((insn.bits & 0x3fffff) == 0x973)
1842         {
1843           #include "insns/vfmsv.h"
1844           break;
1845         }
1846         if((insn.bits & 0x1ffff) == 0x1873)
1847         {
1848           #include "insns/vmts.h"
1849           break;
1850         }
1851         if((insn.bits & 0x3fffff) == 0x73)
1852         {
1853           #include "insns/vmvv.h"
1854           break;
1855         }
1856         if((insn.bits & 0x3ff) == 0x1f3)
1857         {
1858           #include "insns/vtcfgivl.h"
1859           break;
1860         }
1861         if((insn.bits & 0xf80003ff) == 0x3f3)
1862         {
1863           #include "insns/vf.h"
1864           break;
1865         }
1866         if((insn.bits & 0x3fffff) == 0x173)
1867         {
1868           #include "insns/vfmvv.h"
1869           break;
1870         }
1871         if((insn.bits & 0x3fffff) == 0x873)
1872         {
1873           #include "insns/vmsv.h"
1874           break;
1875         }
1876         if((insn.bits & 0x1ffff) == 0x1073)
1877         {
1878           #include "insns/vmst.h"
1879           break;
1880         }
1881         throw_illegal_instruction;
1882     break;
1883   }
1884   case 0x74:
1885   {
1886     #include "insns/c_flw.h"
1887     break;
1888   }
1889   case 0x75:
1890   {
1891     #include "insns/c_fld.h"
1892     break;
1893   }
1894   case 0x76:
1895   {
1896     #include "insns/c_fsw.h"
1897     break;
1898   }
1899   case 0x77:
1900   {
1901         if((insn.bits & 0x1ffff) == 0x6f7)
1902         {
1903           #include "insns/movn.h"
1904           break;
1905         }
1906         if((insn.bits & 0x1ffff) == 0x2f7)
1907         {
1908           #include "insns/movz.h"
1909           break;
1910         }
1911         if((insn.bits & 0x7ffffff) == 0x277)
1912         {
1913           #include "insns/rdcycle.h"
1914           break;
1915         }
1916         if((insn.bits & 0xffffffff) == 0x177)
1917         {
1918           #include "insns/stop.h"
1919           break;
1920         }
1921         if((insn.bits & 0xffffffff) == 0xf7)
1922         {
1923           #include "insns/break.h"
1924           break;
1925         }
1926         if((insn.bits & 0x7ffffff) == 0x1f7)
1927         {
1928           #include "insns/utidx.h"
1929           break;
1930         }
1931         if((insn.bits & 0x7ffffff) == 0xa77)
1932         {
1933           #include "insns/rdinstret.h"
1934           break;
1935         }
1936         if((insn.bits & 0x7ffffff) == 0x677)
1937         {
1938           #include "insns/rdtime.h"
1939           break;
1940         }
1941         if((insn.bits & 0x1ffff) == 0xef7)
1942         {
1943           #include "insns/fmovn.h"
1944           break;
1945         }
1946         if((insn.bits & 0x1ffff) == 0xaf7)
1947         {
1948           #include "insns/fmovz.h"
1949           break;
1950         }
1951         if((insn.bits & 0xffffffff) == 0x77)
1952         {
1953           #include "insns/syscall.h"
1954           break;
1955         }
1956         throw_illegal_instruction;
1957     break;
1958   }
1959   case 0x78:
1960   {
1961     #include "insns/c_fsd.h"
1962     break;
1963   }
1964   case 0x79:
1965   {
1966         if((insn.bits & 0x1c1f) == 0x19)
1967         {
1968           #include "insns/c_slli.h"
1969           break;
1970         }
1971         if((insn.bits & 0x1c1f) == 0x819)
1972         {
1973           #include "insns/c_srli.h"
1974           break;
1975         }
1976         if((insn.bits & 0x1c1f) == 0x1419)
1977         {
1978           #include "insns/c_srai32.h"
1979           break;
1980         }
1981         if((insn.bits & 0x1c1f) == 0x1819)
1982         {
1983           #include "insns/c_slliw.h"
1984           break;
1985         }
1986         if((insn.bits & 0x1c1f) == 0xc19)
1987         {
1988           #include "insns/c_srli32.h"
1989           break;
1990         }
1991         if((insn.bits & 0x1c1f) == 0x1019)
1992         {
1993           #include "insns/c_srai.h"
1994           break;
1995         }
1996         if((insn.bits & 0x1c1f) == 0x419)
1997         {
1998           #include "insns/c_slli32.h"
1999           break;
2000         }
2001         throw_illegal_instruction;
2002     break;
2003   }
2004   case 0x7a:
2005   {
2006         if((insn.bits & 0x801f) == 0x801a)
2007         {
2008           #include "insns/c_sub.h"
2009           break;
2010         }
2011         if((insn.bits & 0x801f) == 0x1a)
2012         {
2013           #include "insns/c_add.h"
2014           break;
2015         }
2016         throw_illegal_instruction;
2017     break;
2018   }
2019   case 0x7b:
2020   {
2021         if((insn.bits & 0x7c1ffff) == 0x17b)
2022         {
2023           #include "insns/mfpcr.h"
2024           break;
2025         }
2026         if((insn.bits & 0x7ffffff) == 0xfb)
2027         {
2028           #include "insns/di.h"
2029           break;
2030         }
2031         if((insn.bits & 0xf801ffff) == 0x1fb)
2032         {
2033           #include "insns/mtpcr.h"
2034           break;
2035         }
2036         if((insn.bits & 0xffffffff) == 0x2fb)
2037         {
2038           #include "insns/cflush.h"
2039           break;
2040         }
2041         if((insn.bits & 0x7ffffff) == 0x7b)
2042         {
2043           #include "insns/ei.h"
2044           break;
2045         }
2046         if((insn.bits & 0xffffffff) == 0x27b)
2047         {
2048           #include "insns/eret.h"
2049           break;
2050         }
2051         throw_illegal_instruction;
2052     break;
2053   }
2054   case 0x7c:
2055   {
2056         if((insn.bits & 0x31f) == 0x1c)
2057         {
2058           #include "insns/c_add3.h"
2059           break;
2060         }
2061         if((insn.bits & 0x31f) == 0x21c)
2062         {
2063           #include "insns/c_or3.h"
2064           break;
2065         }
2066         if((insn.bits & 0x31f) == 0x31c)
2067         {
2068           #include "insns/c_and3.h"
2069           break;
2070         }
2071         if((insn.bits & 0x31f) == 0x11c)
2072         {
2073           #include "insns/c_sub3.h"
2074           break;
2075         }
2076         throw_illegal_instruction;
2077     break;
2078   }
2079   case 0x7d:
2080   {
2081     #include "insns/c_addiw.h"
2082     break;
2083   }
2084   default:
2085   {
2086     throw_illegal_instruction;
2087   }
2088 }