riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x19) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     switch((insn.bits >> 0xc) & 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 0x60:
  25   {
  26     #include "insns/j.h"
  27     break;
  28   }
  29   case 0x61:
  30   {
  31     #include "insns/j.h"
  32     break;
  33   }
  34   case 0x62:
  35   {
  36     #include "insns/j.h"
  37     break;
  38   }
  39   case 0x63:
  40   {
  41     #include "insns/j.h"
  42     break;
  43   }
  44   case 0x64:
  45   {
  46     #include "insns/jal.h"
  47     break;
  48   }
  49   case 0x65:
  50   {
  51     #include "insns/jal.h"
  52     break;
  53   }
  54   case 0x66:
  55   {
  56     #include "insns/jal.h"
  57     break;
  58   }
  59   case 0x67:
  60   {
  61     #include "insns/jal.h"
  62     break;
  63   }
  64   case 0x68:
  65   {
  66     switch((insn.bits >> 0xc) & 0x7)
  67     {
  68       case 0x0:
  69       {
  70         if((insn.bits & 0xfe007c00) == 0xd0000000)
  71         {
  72           #include "insns/add_fmt.h"
  73           break;
  74         }
  75         #include "insns/unimp.h"
  76       }
  77       case 0x1:
  78       {
  79         if((insn.bits & 0xfe007c00) == 0xd0001000)
  80         {
  81           #include "insns/sub_fmt.h"
  82           break;
  83         }
  84         #include "insns/unimp.h"
  85       }
  86       case 0x2:
  87       {
  88         if((insn.bits & 0xfe007c00) == 0xd0002000)
  89         {
  90           #include "insns/mul_fmt.h"
  91           break;
  92         }
  93         #include "insns/unimp.h"
  94       }
  95       case 0x3:
  96       {
  97         if((insn.bits & 0xfe007c00) == 0xd0003000)
  98         {
  99           #include "insns/div_fmt.h"
 100           break;
 101         }
 102         #include "insns/unimp.h"
 103       }
 104       case 0x4:
 105       {
 106         if((insn.bits & 0xfe0ffc00) == 0xd0004000)
 107         {
 108           #include "insns/sqrt_fmt.h"
 109           break;
 110         }
 111         #include "insns/unimp.h"
 112       }
 113       case 0x5:
 114       {
 115         if((insn.bits & 0xfe0ffc00) == 0xd0005000)
 116         {
 117           #include "insns/abs_fmt.h"
 118           break;
 119         }
 120         #include "insns/unimp.h"
 121       }
 122       case 0x6:
 123       {
 124         if((insn.bits & 0xfe0ffc00) == 0xd0006000)
 125         {
 126           #include "insns/mov_fmt.h"
 127           break;
 128         }
 129         #include "insns/unimp.h"
 130       }
 131       case 0x7:
 132       {
 133         if((insn.bits & 0xfe0ffc00) == 0xd0007000)
 134         {
 135           #include "insns/neg_fmt.h"
 136           break;
 137         }
 138         #include "insns/unimp.h"
 139       }
 140       default:
 141       {
 142         #include "insns/unimp.h"
 143       }
 144     }
 145     break;
 146   }
 147   case 0x69:
 148   {
 149     switch((insn.bits >> 0xc) & 0x7)
 150     {
 151       case 0x0:
 152       {
 153         if((insn.bits & 0xfe0ffc00) == 0xd2000000)
 154         {
 155           #include "insns/round_l_fmt.h"
 156           break;
 157         }
 158         #include "insns/unimp.h"
 159       }
 160       case 0x1:
 161       {
 162         if((insn.bits & 0xfe0ffc00) == 0xd2001000)
 163         {
 164           #include "insns/trunc_l_fmt.h"
 165           break;
 166         }
 167         #include "insns/unimp.h"
 168       }
 169       case 0x2:
 170       {
 171         if((insn.bits & 0xfe0ffc00) == 0xd2002000)
 172         {
 173           #include "insns/ceil_l_fmt.h"
 174           break;
 175         }
 176         #include "insns/unimp.h"
 177       }
 178       case 0x3:
 179       {
 180         if((insn.bits & 0xfe0ffc00) == 0xd2003000)
 181         {
 182           #include "insns/floor_l_fmt.h"
 183           break;
 184         }
 185         #include "insns/unimp.h"
 186       }
 187       case 0x4:
 188       {
 189         if((insn.bits & 0xfe0ffc00) == 0xd2004000)
 190         {
 191           #include "insns/round_w_fmt.h"
 192           break;
 193         }
 194         #include "insns/unimp.h"
 195       }
 196       case 0x5:
 197       {
 198         if((insn.bits & 0xfe0ffc00) == 0xd2005000)
 199         {
 200           #include "insns/trunc_w_fmt.h"
 201           break;
 202         }
 203         #include "insns/unimp.h"
 204       }
 205       case 0x6:
 206       {
 207         if((insn.bits & 0xfe0ffc00) == 0xd2006000)
 208         {
 209           #include "insns/ceil_w_fmt.h"
 210           break;
 211         }
 212         #include "insns/unimp.h"
 213       }
 214       case 0x7:
 215       {
 216         if((insn.bits & 0xfe0ffc00) == 0xd2007000)
 217         {
 218           #include "insns/floor_w_fmt.h"
 219           break;
 220         }
 221         #include "insns/unimp.h"
 222       }
 223       default:
 224       {
 225         #include "insns/unimp.h"
 226       }
 227     }
 228     break;
 229   }
 230   case 0x6a:
 231   {
 232     switch((insn.bits >> 0xc) & 0x7)
 233     {
 234       case 0x0:
 235       {
 236         if((insn.bits & 0xfe007fff) == 0xd4000000)
 237         {
 238           #include "insns/mfc1.h"
 239           break;
 240         }
 241         #include "insns/unimp.h"
 242       }
 243       case 0x1:
 244       {
 245         if((insn.bits & 0xfe007fff) == 0xd4001000)
 246         {
 247           #include "insns/dmfc1.h"
 248           break;
 249         }
 250         #include "insns/unimp.h"
 251       }
 252       case 0x2:
 253       {
 254         if((insn.bits & 0xfe007fff) == 0xd4002000)
 255         {
 256           #include "insns/cfc1.h"
 257           break;
 258         }
 259         #include "insns/unimp.h"
 260       }
 261       case 0x3:
 262       {
 263         if((insn.bits & 0xfe007fff) == 0xd4003000)
 264         {
 265           #include "insns/mfhc1.h"
 266           break;
 267         }
 268         #include "insns/unimp.h"
 269       }
 270       case 0x4:
 271       {
 272         if((insn.bits & 0xfe007fff) == 0xd4004000)
 273         {
 274           #include "insns/mtc1.h"
 275           break;
 276         }
 277         #include "insns/unimp.h"
 278       }
 279       case 0x5:
 280       {
 281         if((insn.bits & 0xfe007fff) == 0xd4005000)
 282         {
 283           #include "insns/dmtc1.h"
 284           break;
 285         }
 286         #include "insns/unimp.h"
 287       }
 288       case 0x6:
 289       {
 290         if((insn.bits & 0xfe007fff) == 0xd4006000)
 291         {
 292           #include "insns/ctc1.h"
 293           break;
 294         }
 295         #include "insns/unimp.h"
 296       }
 297       case 0x7:
 298       {
 299         if((insn.bits & 0xfe007fff) == 0xd4007000)
 300         {
 301           #include "insns/mthc1.h"
 302           break;
 303         }
 304         #include "insns/unimp.h"
 305       }
 306       default:
 307       {
 308         #include "insns/unimp.h"
 309       }
 310     }
 311     break;
 312   }
 313   case 0x6b:
 314   {
 315     switch((insn.bits >> 0xc) & 0x7)
 316     {
 317       case 0x0:
 318       {
 319         if((insn.bits & 0xfe0ffc00) == 0xd6000000)
 320         {
 321           #include "insns/cvt_s_fmt.h"
 322           break;
 323         }
 324         #include "insns/unimp.h"
 325       }
 326       case 0x1:
 327       {
 328         if((insn.bits & 0xfe0ffc00) == 0xd6001000)
 329         {
 330           #include "insns/cvt_d_fmt.h"
 331           break;
 332         }
 333         #include "insns/unimp.h"
 334       }
 335       case 0x4:
 336       {
 337         if((insn.bits & 0xfe0ffc00) == 0xd6004000)
 338         {
 339           #include "insns/cvt_w_fmt.h"
 340           break;
 341         }
 342         #include "insns/unimp.h"
 343       }
 344       case 0x5:
 345       {
 346         if((insn.bits & 0xfe0ffc00) == 0xd6005000)
 347         {
 348           #include "insns/cvt_l_fmt.h"
 349           break;
 350         }
 351         #include "insns/unimp.h"
 352       }
 353       default:
 354       {
 355         #include "insns/unimp.h"
 356       }
 357     }
 358     break;
 359   }
 360   case 0x6c:
 361   {
 362     switch((insn.bits >> 0xc) & 0x7)
 363     {
 364       case 0x0:
 365       {
 366         if((insn.bits & 0xfe007c00) == 0xd8000000)
 367         {
 368           #include "insns/c_f_fmt.h"
 369           break;
 370         }
 371         #include "insns/unimp.h"
 372       }
 373       case 0x1:
 374       {
 375         if((insn.bits & 0xfe007c00) == 0xd8001000)
 376         {
 377           #include "insns/c_un_fmt.h"
 378           break;
 379         }
 380         #include "insns/unimp.h"
 381       }
 382       case 0x2:
 383       {
 384         if((insn.bits & 0xfe007c00) == 0xd8002000)
 385         {
 386           #include "insns/c_eq_fmt.h"
 387           break;
 388         }
 389         #include "insns/unimp.h"
 390       }
 391       case 0x3:
 392       {
 393         if((insn.bits & 0xfe007c00) == 0xd8003000)
 394         {
 395           #include "insns/c_ueq_fmt.h"
 396           break;
 397         }
 398         #include "insns/unimp.h"
 399       }
 400       case 0x4:
 401       {
 402         if((insn.bits & 0xfe007c00) == 0xd8004000)
 403         {
 404           #include "insns/c_olt_fmt.h"
 405           break;
 406         }
 407         #include "insns/unimp.h"
 408       }
 409       case 0x5:
 410       {
 411         if((insn.bits & 0xfe007c00) == 0xd8005000)
 412         {
 413           #include "insns/c_ult_fmt.h"
 414           break;
 415         }
 416         #include "insns/unimp.h"
 417       }
 418       case 0x6:
 419       {
 420         if((insn.bits & 0xfe007c00) == 0xd8006000)
 421         {
 422           #include "insns/c_ole_fmt.h"
 423           break;
 424         }
 425         #include "insns/unimp.h"
 426       }
 427       case 0x7:
 428       {
 429         if((insn.bits & 0xfe007c00) == 0xd8007000)
 430         {
 431           #include "insns/c_ule_fmt.h"
 432           break;
 433         }
 434         #include "insns/unimp.h"
 435       }
 436       default:
 437       {
 438         #include "insns/unimp.h"
 439       }
 440     }
 441     break;
 442   }
 443   case 0x6d:
 444   {
 445     switch((insn.bits >> 0xc) & 0x7)
 446     {
 447       case 0x0:
 448       {
 449         if((insn.bits & 0xfe007c00) == 0xda000000)
 450         {
 451           #include "insns/c_sf_fmt.h"
 452           break;
 453         }
 454         #include "insns/unimp.h"
 455       }
 456       case 0x1:
 457       {
 458         if((insn.bits & 0xfe007c00) == 0xda001000)
 459         {
 460           #include "insns/c_ngle_fmt.h"
 461           break;
 462         }
 463         #include "insns/unimp.h"
 464       }
 465       case 0x2:
 466       {
 467         if((insn.bits & 0xfe007c00) == 0xda002000)
 468         {
 469           #include "insns/c_seq_fmt.h"
 470           break;
 471         }
 472         #include "insns/unimp.h"
 473       }
 474       case 0x3:
 475       {
 476         if((insn.bits & 0xfe007c00) == 0xda003000)
 477         {
 478           #include "insns/c_ngl_fmt.h"
 479           break;
 480         }
 481         #include "insns/unimp.h"
 482       }
 483       case 0x4:
 484       {
 485         if((insn.bits & 0xfe007c00) == 0xda004000)
 486         {
 487           #include "insns/c_lt_fmt.h"
 488           break;
 489         }
 490         #include "insns/unimp.h"
 491       }
 492       case 0x5:
 493       {
 494         if((insn.bits & 0xfe007c00) == 0xda005000)
 495         {
 496           #include "insns/c_nge_fmt.h"
 497           break;
 498         }
 499         #include "insns/unimp.h"
 500       }
 501       case 0x6:
 502       {
 503         if((insn.bits & 0xfe007c00) == 0xda006000)
 504         {
 505           #include "insns/c_le_fmt.h"
 506           break;
 507         }
 508         #include "insns/unimp.h"
 509       }
 510       case 0x7:
 511       {
 512         if((insn.bits & 0xfe007c00) == 0xda007000)
 513         {
 514           #include "insns/c_ngt_fmt.h"
 515           break;
 516         }
 517         #include "insns/unimp.h"
 518       }
 519       default:
 520       {
 521         #include "insns/unimp.h"
 522       }
 523     }
 524     break;
 525   }
 526   case 0x71:
 527   {
 528     #include "insns/lui.h"
 529     break;
 530   }
 531   case 0x72:
 532   {
 533     #include "insns/slori.h"
 534     break;
 535   }
 536   case 0x73:
 537   {
 538     switch((insn.bits >> 0xc) & 0x7)
 539     {
 540       case 0x0:
 541       {
 542         #include "insns/beq.h"
 543         break;
 544       }
 545       case 0x1:
 546       {
 547         #include "insns/bne.h"
 548         break;
 549       }
 550       case 0x2:
 551       {
 552         #include "insns/blt.h"
 553         break;
 554       }
 555       case 0x3:
 556       {
 557         #include "insns/bltu.h"
 558         break;
 559       }
 560       case 0x4:
 561       {
 562         #include "insns/ble.h"
 563         break;
 564       }
 565       case 0x5:
 566       {
 567         #include "insns/bleu.h"
 568         break;
 569       }
 570       default:
 571       {
 572         #include "insns/unimp.h"
 573       }
 574     }
 575     break;
 576   }
 577   case 0x74:
 578   {
 579     switch((insn.bits >> 0xc) & 0x7)
 580     {
 581       case 0x0:
 582       {
 583         #include "insns/addi.h"
 584         break;
 585       }
 586       case 0x1:
 587       {
 588         #include "insns/daddi.h"
 589         break;
 590       }
 591       case 0x2:
 592       {
 593         #include "insns/slti.h"
 594         break;
 595       }
 596       case 0x3:
 597       {
 598         #include "insns/sltiu.h"
 599         break;
 600       }
 601       case 0x4:
 602       {
 603         #include "insns/andi.h"
 604         break;
 605       }
 606       case 0x5:
 607       {
 608         #include "insns/ori.h"
 609         break;
 610       }
 611       case 0x6:
 612       {
 613         #include "insns/xori.h"
 614         break;
 615       }
 616       default:
 617       {
 618         #include "insns/unimp.h"
 619       }
 620     }
 621     break;
 622   }
 623   case 0x75:
 624   {
 625     switch((insn.bits >> 0xc) & 0x7)
 626     {
 627       case 0x0:
 628       {
 629         if((insn.bits & 0xfe007fe0) == 0xea0000e0)
 630         {
 631           #include "insns/nor.h"
 632           break;
 633         }
 634         if((insn.bits & 0xfe007fe0) == 0xea000060)
 635         {
 636           #include "insns/sltu.h"
 637           break;
 638         }
 639         if((insn.bits & 0xfe007fe0) == 0xea0000c0)
 640         {
 641           #include "insns/xor.h"
 642           break;
 643         }
 644         if((insn.bits & 0xfe007fe0) == 0xea000020)
 645         {
 646           #include "insns/sub.h"
 647           break;
 648         }
 649         if((insn.bits & 0xfe007fe0) == 0xea0000a0)
 650         {
 651           #include "insns/or.h"
 652           break;
 653         }
 654         if((insn.bits & 0xfe007fe0) == 0xea000000)
 655         {
 656           #include "insns/add.h"
 657           break;
 658         }
 659         if((insn.bits & 0xfe007fe0) == 0xea000040)
 660         {
 661           #include "insns/slt.h"
 662           break;
 663         }
 664         if((insn.bits & 0xfe007fe0) == 0xea000080)
 665         {
 666           #include "insns/and.h"
 667           break;
 668         }
 669         #include "insns/unimp.h"
 670       }
 671       case 0x1:
 672       {
 673         if((insn.bits & 0xfe007fe0) == 0xea001000)
 674         {
 675           #include "insns/mul.h"
 676           break;
 677         }
 678         if((insn.bits & 0xfe007fe0) == 0xea001080)
 679         {
 680           #include "insns/div.h"
 681           break;
 682         }
 683         if((insn.bits & 0xfe007fe0) == 0xea0010c0)
 684         {
 685           #include "insns/rem.h"
 686           break;
 687         }
 688         if((insn.bits & 0xfe007fe0) == 0xea001040)
 689         {
 690           #include "insns/mulh.h"
 691           break;
 692         }
 693         if((insn.bits & 0xfe007fe0) == 0xea0010e0)
 694         {
 695           #include "insns/remu.h"
 696           break;
 697         }
 698         if((insn.bits & 0xfe007fe0) == 0xea001060)
 699         {
 700           #include "insns/mulhu.h"
 701           break;
 702         }
 703         if((insn.bits & 0xfe007fe0) == 0xea0010a0)
 704         {
 705           #include "insns/divu.h"
 706           break;
 707         }
 708         #include "insns/unimp.h"
 709       }
 710       case 0x4:
 711       {
 712         if((insn.bits & 0xfe007fe0) == 0xea004040)
 713         {
 714           #include "insns/srlv.h"
 715           break;
 716         }
 717         if((insn.bits & 0xfe007fe0) == 0xea004020)
 718         {
 719           #include "insns/sllv.h"
 720           break;
 721         }
 722         if((insn.bits & 0xfe007fe0) == 0xea004060)
 723         {
 724           #include "insns/srav.h"
 725           break;
 726         }
 727         #include "insns/unimp.h"
 728       }
 729       case 0x5:
 730       {
 731         if((insn.bits & 0xfff07c00) == 0xea005000)
 732         {
 733           #include "insns/sll.h"
 734           break;
 735         }
 736         #include "insns/unimp.h"
 737       }
 738       case 0x6:
 739       {
 740         if((insn.bits & 0xfff07c00) == 0xea006000)
 741         {
 742           #include "insns/srl.h"
 743           break;
 744         }
 745         #include "insns/unimp.h"
 746       }
 747       case 0x7:
 748       {
 749         if((insn.bits & 0xfff07c00) == 0xea007000)
 750         {
 751           #include "insns/sra.h"
 752           break;
 753         }
 754         #include "insns/unimp.h"
 755       }
 756       default:
 757       {
 758         #include "insns/unimp.h"
 759       }
 760     }
 761     break;
 762   }
 763   case 0x76:
 764   {
 765     switch((insn.bits >> 0xc) & 0x7)
 766     {
 767       case 0x0:
 768       {
 769         if((insn.bits & 0xfe007fe0) == 0xec000020)
 770         {
 771           #include "insns/dsub.h"
 772           break;
 773         }
 774         if((insn.bits & 0xfe007fe0) == 0xec000000)
 775         {
 776           #include "insns/dadd.h"
 777           break;
 778         }
 779         #include "insns/unimp.h"
 780       }
 781       case 0x1:
 782       {
 783         if((insn.bits & 0xfe007fe0) == 0xec0010e0)
 784         {
 785           #include "insns/dremu.h"
 786           break;
 787         }
 788         if((insn.bits & 0xfe007fe0) == 0xec001080)
 789         {
 790           #include "insns/ddiv.h"
 791           break;
 792         }
 793         if((insn.bits & 0xfe007fe0) == 0xec0010c0)
 794         {
 795           #include "insns/drem.h"
 796           break;
 797         }
 798         if((insn.bits & 0xfe007fe0) == 0xec001060)
 799         {
 800           #include "insns/dmulhu.h"
 801           break;
 802         }
 803         if((insn.bits & 0xfe007fe0) == 0xec001000)
 804         {
 805           #include "insns/dmul.h"
 806           break;
 807         }
 808         if((insn.bits & 0xfe007fe0) == 0xec001040)
 809         {
 810           #include "insns/dmulh.h"
 811           break;
 812         }
 813         if((insn.bits & 0xfe007fe0) == 0xec0010a0)
 814         {
 815           #include "insns/ddivu.h"
 816           break;
 817         }
 818         #include "insns/unimp.h"
 819       }
 820       case 0x4:
 821       {
 822         if((insn.bits & 0xfe007fe0) == 0xec004020)
 823         {
 824           #include "insns/dsllv.h"
 825           break;
 826         }
 827         if((insn.bits & 0xfe007fe0) == 0xec004060)
 828         {
 829           #include "insns/dsrav.h"
 830           break;
 831         }
 832         if((insn.bits & 0xfe007fe0) == 0xec004040)
 833         {
 834           #include "insns/dsrlv.h"
 835           break;
 836         }
 837         #include "insns/unimp.h"
 838       }
 839       case 0x5:
 840       {
 841         if((insn.bits & 0xfff07c00) == 0xec005000)
 842         {
 843           #include "insns/dsll.h"
 844           break;
 845         }
 846         if((insn.bits & 0xfff07c00) == 0xec005400)
 847         {
 848           #include "insns/dsll32.h"
 849           break;
 850         }
 851         #include "insns/unimp.h"
 852       }
 853       case 0x6:
 854       {
 855         if((insn.bits & 0xfff07c00) == 0xec006400)
 856         {
 857           #include "insns/dsrl32.h"
 858           break;
 859         }
 860         if((insn.bits & 0xfff07c00) == 0xec006000)
 861         {
 862           #include "insns/dsrl.h"
 863           break;
 864         }
 865         #include "insns/unimp.h"
 866       }
 867       case 0x7:
 868       {
 869         if((insn.bits & 0xfff07c00) == 0xec007400)
 870         {
 871           #include "insns/dsra32.h"
 872           break;
 873         }
 874         if((insn.bits & 0xfff07c00) == 0xec007000)
 875         {
 876           #include "insns/dsra.h"
 877           break;
 878         }
 879         #include "insns/unimp.h"
 880       }
 881       default:
 882       {
 883         #include "insns/unimp.h"
 884       }
 885     }
 886     break;
 887   }
 888   case 0x78:
 889   {
 890     switch((insn.bits >> 0xc) & 0x7)
 891     {
 892       case 0x0:
 893       {
 894         #include "insns/lb.h"
 895         break;
 896       }
 897       case 0x1:
 898       {
 899         #include "insns/lh.h"
 900         break;
 901       }
 902       case 0x2:
 903       {
 904         #include "insns/lw.h"
 905         break;
 906       }
 907       case 0x3:
 908       {
 909         #include "insns/ld.h"
 910         break;
 911       }
 912       case 0x4:
 913       {
 914         #include "insns/lbu.h"
 915         break;
 916       }
 917       case 0x5:
 918       {
 919         #include "insns/lhu.h"
 920         break;
 921       }
 922       case 0x6:
 923       {
 924         #include "insns/lwu.h"
 925         break;
 926       }
 927       case 0x7:
 928       {
 929         if((insn.bits & 0xfff07000) == 0xf0007000)
 930         {
 931           #include "insns/synci.h"
 932           break;
 933         }
 934         #include "insns/unimp.h"
 935       }
 936       default:
 937       {
 938         #include "insns/unimp.h"
 939       }
 940     }
 941     break;
 942   }
 943   case 0x79:
 944   {
 945     switch((insn.bits >> 0xc) & 0x7)
 946     {
 947       case 0x0:
 948       {
 949         #include "insns/sb.h"
 950         break;
 951       }
 952       case 0x1:
 953       {
 954         #include "insns/sh.h"
 955         break;
 956       }
 957       case 0x2:
 958       {
 959         #include "insns/sw.h"
 960         break;
 961       }
 962       case 0x3:
 963       {
 964         #include "insns/sd.h"
 965         break;
 966       }
 967       case 0x4:
 968       {
 969         #include "insns/l_s.h"
 970         break;
 971       }
 972       case 0x5:
 973       {
 974         #include "insns/l_d.h"
 975         break;
 976       }
 977       case 0x6:
 978       {
 979         #include "insns/s_s.h"
 980         break;
 981       }
 982       case 0x7:
 983       {
 984         #include "insns/s_d.h"
 985         break;
 986       }
 987       default:
 988       {
 989         #include "insns/unimp.h"
 990       }
 991     }
 992     break;
 993   }
 994   case 0x7b:
 995   {
 996     switch((insn.bits >> 0xc) & 0x7)
 997     {
 998       case 0x0:
 999       {
1000         if((insn.bits & 0xfe0fffe0) == 0xf6000000)
1001         {
1002           #include "insns/jalr_c.h"
1003           break;
1004         }
1005         if((insn.bits & 0xfe0fffe0) == 0xf6000040)
1006         {
1007           #include "insns/jalr_j.h"
1008           break;
1009         }
1010         if((insn.bits & 0xfe0fffe0) == 0xf6000020)
1011         {
1012           #include "insns/jalr_r.h"
1013           break;
1014         }
1015         #include "insns/unimp.h"
1016       }
1017       case 0x1:
1018       {
1019         if((insn.bits & 0xffffffe0) == 0xf6001000)
1020         {
1021           #include "insns/rdpc.h"
1022           break;
1023         }
1024         #include "insns/unimp.h"
1025       }
1026       case 0x2:
1027       {
1028         if((insn.bits & 0xfe0fffe0) == 0xf6002000)
1029         {
1030           #include "insns/rdhwr.h"
1031           break;
1032         }
1033         #include "insns/unimp.h"
1034       }
1035       case 0x3:
1036       {
1037         if((insn.bits & 0xffffffff) == 0xf6003000)
1038         {
1039           #include "insns/sync.h"
1040           break;
1041         }
1042         #include "insns/unimp.h"
1043       }
1044       case 0x4:
1045       {
1046         if((insn.bits & 0xffffffff) == 0xf6004000)
1047         {
1048           #include "insns/syscall.h"
1049           break;
1050         }
1051         #include "insns/unimp.h"
1052       }
1053       case 0x5:
1054       {
1055         if((insn.bits & 0xffffffff) == 0xf6005000)
1056         {
1057           #include "insns/break.h"
1058           break;
1059         }
1060         #include "insns/unimp.h"
1061       }
1062       default:
1063       {
1064         #include "insns/unimp.h"
1065       }
1066     }
1067     break;
1068   }
1069   case 0x7e:
1070   {
1071     switch((insn.bits >> 0xc) & 0x7)
1072     {
1073       case 0x0:
1074       {
1075         if((insn.bits & 0xfe0fffff) == 0xfc000000)
1076         {
1077           #include "insns/ei.h"
1078           break;
1079         }
1080         #include "insns/unimp.h"
1081       }
1082       case 0x1:
1083       {
1084         if((insn.bits & 0xfe0fffff) == 0xfc001000)
1085         {
1086           #include "insns/di.h"
1087           break;
1088         }
1089         #include "insns/unimp.h"
1090       }
1091       case 0x2:
1092       {
1093         if((insn.bits & 0xffffffff) == 0xfc002000)
1094         {
1095           #include "insns/eret.h"
1096           break;
1097         }
1098         #include "insns/unimp.h"
1099       }
1100       case 0x4:
1101       {
1102         if((insn.bits & 0xfe007fff) == 0xfc004000)
1103         {
1104           #include "insns/mfc0.h"
1105           break;
1106         }
1107         #include "insns/unimp.h"
1108       }
1109       case 0x5:
1110       {
1111         if((insn.bits & 0xfe007fff) == 0xfc005000)
1112         {
1113           #include "insns/dmfc0.h"
1114           break;
1115         }
1116         #include "insns/unimp.h"
1117       }
1118       case 0x6:
1119       {
1120         if((insn.bits & 0xfe007fff) == 0xfc006000)
1121         {
1122           #include "insns/mtc0.h"
1123           break;
1124         }
1125         #include "insns/unimp.h"
1126       }
1127       case 0x7:
1128       {
1129         if((insn.bits & 0xfe007fff) == 0xfc007000)
1130         {
1131           #include "insns/dmtc0.h"
1132           break;
1133         }
1134         #include "insns/unimp.h"
1135       }
1136       default:
1137       {
1138         #include "insns/unimp.h"
1139       }
1140     }
1141     break;
1142   }
1143   default:
1144   {
1145     #include "insns/unimp.h"
1146   }
1147 }