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 & 0xfe007fe0) == 0xd0000ca0)
  71         {
  72           #include "insns/sgninj_d.h"
  73           break;
  74         }
  75         if((insn.bits & 0xfe007fe0) == 0xd00000a0)
  76         {
  77           #include "insns/sgninj_s.h"
  78           break;
  79         }
  80         if((insn.bits & 0xfe007fe0) == 0xd0000000)
  81         {
  82           #include "insns/add_s.h"
  83           break;
  84         }
  85         if((insn.bits & 0xfe007fe0) == 0xd0000c00)
  86         {
  87           #include "insns/add_d.h"
  88           break;
  89         }
  90         if((insn.bits & 0xfe007fe0) == 0xd0000ce0)
  91         {
  92           #include "insns/sgnmul_d.h"
  93           break;
  94         }
  95         if((insn.bits & 0xfe007fe0) == 0xd0000cc0)
  96         {
  97           #include "insns/sgninjn_d.h"
  98           break;
  99         }
 100         if((insn.bits & 0xfe007fe0) == 0xd00000c0)
 101         {
 102           #include "insns/sgninjn_s.h"
 103           break;
 104         }
 105         if((insn.bits & 0xfe007fe0) == 0xd0000c40)
 106         {
 107           #include "insns/mul_d.h"
 108           break;
 109         }
 110         if((insn.bits & 0xfe007fe0) == 0xd0000020)
 111         {
 112           #include "insns/sub_s.h"
 113           break;
 114         }
 115         if((insn.bits & 0xfe007fe0) == 0xd0000c20)
 116         {
 117           #include "insns/sub_d.h"
 118           break;
 119         }
 120         if((insn.bits & 0xfe0fffe0) == 0xd0000080)
 121         {
 122           #include "insns/sqrt_s.h"
 123           break;
 124         }
 125         if((insn.bits & 0xfe0fffe0) == 0xd0000c80)
 126         {
 127           #include "insns/sqrt_d.h"
 128           break;
 129         }
 130         if((insn.bits & 0xfe007fe0) == 0xd00000e0)
 131         {
 132           #include "insns/sgnmul_s.h"
 133           break;
 134         }
 135         if((insn.bits & 0xfe007fe0) == 0xd0000c60)
 136         {
 137           #include "insns/div_d.h"
 138           break;
 139         }
 140         if((insn.bits & 0xfe007fe0) == 0xd0000060)
 141         {
 142           #include "insns/div_s.h"
 143           break;
 144         }
 145         if((insn.bits & 0xfe007fe0) == 0xd0000040)
 146         {
 147           #include "insns/mul_s.h"
 148           break;
 149         }
 150         #include "insns/unimp.h"
 151       }
 152       case 0x1:
 153       {
 154         if((insn.bits & 0xfe0fffe0) == 0xd00010c0)
 155         {
 156           #include "insns/cvt_s_w.h"
 157           break;
 158         }
 159         if((insn.bits & 0xfe0fffe0) == 0xd0001ca0)
 160         {
 161           #include "insns/cvtu_d_l.h"
 162           break;
 163         }
 164         if((insn.bits & 0xfe0fffe0) == 0xd0001c40)
 165         {
 166           #include "insns/trunc_w_d.h"
 167           break;
 168         }
 169         if((insn.bits & 0xfe0fffe0) == 0xd0001040)
 170         {
 171           #include "insns/trunc_w_s.h"
 172           break;
 173         }
 174         if((insn.bits & 0xfe0fffe0) == 0xd0001ce0)
 175         {
 176           #include "insns/cvtu_d_w.h"
 177           break;
 178         }
 179         if((insn.bits & 0xfe0fffe0) == 0xd0001e00)
 180         {
 181           #include "insns/cvt_d_s.h"
 182           break;
 183         }
 184         if((insn.bits & 0xfe0fffe0) == 0xd0001000)
 185         {
 186           #include "insns/trunc_l_s.h"
 187           break;
 188         }
 189         if((insn.bits & 0xfe0fffe0) == 0xd0001c00)
 190         {
 191           #include "insns/trunc_l_d.h"
 192           break;
 193         }
 194         if((insn.bits & 0xfe0fffe0) == 0xd00010e0)
 195         {
 196           #include "insns/cvtu_s_w.h"
 197           break;
 198         }
 199         if((insn.bits & 0xfe0fffe0) == 0xd0001020)
 200         {
 201           #include "insns/truncu_l_s.h"
 202           break;
 203         }
 204         if((insn.bits & 0xfe0fffe0) == 0xd0001c20)
 205         {
 206           #include "insns/truncu_l_d.h"
 207           break;
 208         }
 209         if((insn.bits & 0xfe0fffe0) == 0xd00010a0)
 210         {
 211           #include "insns/cvtu_s_l.h"
 212           break;
 213         }
 214         if((insn.bits & 0xfe0fffe0) == 0xd0001080)
 215         {
 216           #include "insns/cvt_s_l.h"
 217           break;
 218         }
 219         if((insn.bits & 0xfe0fffe0) == 0xd0001260)
 220         {
 221           #include "insns/cvt_s_d.h"
 222           break;
 223         }
 224         if((insn.bits & 0xfe0fffe0) == 0xd0001060)
 225         {
 226           #include "insns/truncu_w_s.h"
 227           break;
 228         }
 229         if((insn.bits & 0xfe0fffe0) == 0xd0001cc0)
 230         {
 231           #include "insns/cvt_d_w.h"
 232           break;
 233         }
 234         if((insn.bits & 0xfe0fffe0) == 0xd0001c80)
 235         {
 236           #include "insns/cvt_d_l.h"
 237           break;
 238         }
 239         if((insn.bits & 0xfe0fffe0) == 0xd0001c60)
 240         {
 241           #include "insns/truncu_w_d.h"
 242           break;
 243         }
 244         #include "insns/unimp.h"
 245       }
 246       case 0x2:
 247       {
 248         if((insn.bits & 0xfe007fe0) == 0xd0002020)
 249         {
 250           #include "insns/c_eq_s.h"
 251           break;
 252         }
 253         if((insn.bits & 0xfe007fe0) == 0xd0002c20)
 254         {
 255           #include "insns/c_eq_d.h"
 256           break;
 257         }
 258         if((insn.bits & 0xfe007fe0) == 0xd0002c60)
 259         {
 260           #include "insns/c_le_d.h"
 261           break;
 262         }
 263         if((insn.bits & 0xfe007fe0) == 0xd0002040)
 264         {
 265           #include "insns/c_lt_s.h"
 266           break;
 267         }
 268         if((insn.bits & 0xfe007fe0) == 0xd0002060)
 269         {
 270           #include "insns/c_le_s.h"
 271           break;
 272         }
 273         if((insn.bits & 0xfe007fe0) == 0xd0002c40)
 274         {
 275           #include "insns/c_lt_d.h"
 276           break;
 277         }
 278         #include "insns/unimp.h"
 279       }
 280       case 0x4:
 281       {
 282         if((insn.bits & 0xfe007c00) == 0xd0004000)
 283         {
 284           #include "insns/madd_s.h"
 285           break;
 286         }
 287         if((insn.bits & 0xfe007c00) == 0xd0004c00)
 288         {
 289           #include "insns/madd_d.h"
 290           break;
 291         }
 292         #include "insns/unimp.h"
 293       }
 294       case 0x5:
 295       {
 296         if((insn.bits & 0xfe007c00) == 0xd0005000)
 297         {
 298           #include "insns/msub_s.h"
 299           break;
 300         }
 301         if((insn.bits & 0xfe007c00) == 0xd0005c00)
 302         {
 303           #include "insns/msub_d.h"
 304           break;
 305         }
 306         #include "insns/unimp.h"
 307       }
 308       case 0x6:
 309       {
 310         if((insn.bits & 0xfe007c00) == 0xd0006000)
 311         {
 312           #include "insns/nmadd_s.h"
 313           break;
 314         }
 315         if((insn.bits & 0xfe007c00) == 0xd0006c00)
 316         {
 317           #include "insns/nmadd_d.h"
 318           break;
 319         }
 320         #include "insns/unimp.h"
 321       }
 322       case 0x7:
 323       {
 324         if((insn.bits & 0xfe007c00) == 0xd0007c00)
 325         {
 326           #include "insns/nmsub_d.h"
 327           break;
 328         }
 329         if((insn.bits & 0xfe007c00) == 0xd0007000)
 330         {
 331           #include "insns/nmsub_s.h"
 332           break;
 333         }
 334         #include "insns/unimp.h"
 335       }
 336       default:
 337       {
 338         #include "insns/unimp.h"
 339       }
 340     }
 341     break;
 342   }
 343   case 0x69:
 344   {
 345     switch((insn.bits >> 0xc) & 0x7)
 346     {
 347       case 0x2:
 348       {
 349         #include "insns/l_s.h"
 350         break;
 351       }
 352       case 0x3:
 353       {
 354         #include "insns/l_d.h"
 355         break;
 356       }
 357       case 0x6:
 358       {
 359         #include "insns/s_s.h"
 360         break;
 361       }
 362       case 0x7:
 363       {
 364         #include "insns/s_d.h"
 365         break;
 366       }
 367       default:
 368       {
 369         #include "insns/unimp.h"
 370       }
 371     }
 372     break;
 373   }
 374   case 0x6a:
 375   {
 376     switch((insn.bits >> 0xc) & 0x7)
 377     {
 378       case 0x0:
 379       {
 380         if((insn.bits & 0xfe007fff) == 0xd4000000)
 381         {
 382           #include "insns/mff_s.h"
 383           break;
 384         }
 385         #include "insns/unimp.h"
 386       }
 387       case 0x1:
 388       {
 389         if((insn.bits & 0xfe007fff) == 0xd4001000)
 390         {
 391           #include "insns/mff_d.h"
 392           break;
 393         }
 394         #include "insns/unimp.h"
 395       }
 396       case 0x4:
 397       {
 398         if((insn.bits & 0xfe007fff) == 0xd4004000)
 399         {
 400           #include "insns/mtf_s.h"
 401           break;
 402         }
 403         #include "insns/unimp.h"
 404       }
 405       case 0x5:
 406       {
 407         if((insn.bits & 0xfe007fff) == 0xd4005000)
 408         {
 409           #include "insns/mtf_d.h"
 410           break;
 411         }
 412         #include "insns/unimp.h"
 413       }
 414       default:
 415       {
 416         #include "insns/unimp.h"
 417       }
 418     }
 419     break;
 420   }
 421   case 0x71:
 422   {
 423     #include "insns/lui.h"
 424     break;
 425   }
 426   case 0x73:
 427   {
 428     switch((insn.bits >> 0xc) & 0x7)
 429     {
 430       case 0x0:
 431       {
 432         #include "insns/beq.h"
 433         break;
 434       }
 435       case 0x1:
 436       {
 437         #include "insns/bne.h"
 438         break;
 439       }
 440       case 0x2:
 441       {
 442         #include "insns/blt.h"
 443         break;
 444       }
 445       case 0x3:
 446       {
 447         #include "insns/bltu.h"
 448         break;
 449       }
 450       case 0x4:
 451       {
 452         #include "insns/ble.h"
 453         break;
 454       }
 455       case 0x5:
 456       {
 457         #include "insns/bleu.h"
 458         break;
 459       }
 460       default:
 461       {
 462         #include "insns/unimp.h"
 463       }
 464     }
 465     break;
 466   }
 467   case 0x74:
 468   {
 469     switch((insn.bits >> 0xc) & 0x7)
 470     {
 471       case 0x0:
 472       {
 473         #include "insns/addi.h"
 474         break;
 475       }
 476       case 0x1:
 477       {
 478         #include "insns/addiw.h"
 479         break;
 480       }
 481       case 0x2:
 482       {
 483         #include "insns/slti.h"
 484         break;
 485       }
 486       case 0x3:
 487       {
 488         #include "insns/sltiu.h"
 489         break;
 490       }
 491       case 0x4:
 492       {
 493         #include "insns/andi.h"
 494         break;
 495       }
 496       case 0x5:
 497       {
 498         #include "insns/ori.h"
 499         break;
 500       }
 501       case 0x6:
 502       {
 503         #include "insns/xori.h"
 504         break;
 505       }
 506       default:
 507       {
 508         #include "insns/unimp.h"
 509       }
 510     }
 511     break;
 512   }
 513   case 0x75:
 514   {
 515     switch((insn.bits >> 0xc) & 0x7)
 516     {
 517       case 0x0:
 518       {
 519         if((insn.bits & 0xfe007fe0) == 0xea0000e0)
 520         {
 521           #include "insns/nor.h"
 522           break;
 523         }
 524         if((insn.bits & 0xfe007fe0) == 0xea000060)
 525         {
 526           #include "insns/sltu.h"
 527           break;
 528         }
 529         if((insn.bits & 0xfe007fe0) == 0xea0000c0)
 530         {
 531           #include "insns/xor.h"
 532           break;
 533         }
 534         if((insn.bits & 0xfe007fe0) == 0xea000020)
 535         {
 536           #include "insns/sub.h"
 537           break;
 538         }
 539         if((insn.bits & 0xfe007fe0) == 0xea0000a0)
 540         {
 541           #include "insns/or.h"
 542           break;
 543         }
 544         if((insn.bits & 0xfe007fe0) == 0xea000000)
 545         {
 546           #include "insns/add.h"
 547           break;
 548         }
 549         if((insn.bits & 0xfe007fe0) == 0xea000040)
 550         {
 551           #include "insns/slt.h"
 552           break;
 553         }
 554         if((insn.bits & 0xfe007fe0) == 0xea000080)
 555         {
 556           #include "insns/and.h"
 557           break;
 558         }
 559         #include "insns/unimp.h"
 560       }
 561       case 0x1:
 562       {
 563         if((insn.bits & 0xfe007fe0) == 0xea001000)
 564         {
 565           #include "insns/mul.h"
 566           break;
 567         }
 568         if((insn.bits & 0xfe007fe0) == 0xea001080)
 569         {
 570           #include "insns/div.h"
 571           break;
 572         }
 573         if((insn.bits & 0xfe007fe0) == 0xea0010c0)
 574         {
 575           #include "insns/rem.h"
 576           break;
 577         }
 578         if((insn.bits & 0xfe007fe0) == 0xea001040)
 579         {
 580           #include "insns/mulh.h"
 581           break;
 582         }
 583         if((insn.bits & 0xfe007fe0) == 0xea0010e0)
 584         {
 585           #include "insns/remu.h"
 586           break;
 587         }
 588         if((insn.bits & 0xfe007fe0) == 0xea001060)
 589         {
 590           #include "insns/mulhu.h"
 591           break;
 592         }
 593         if((insn.bits & 0xfe007fe0) == 0xea0010a0)
 594         {
 595           #include "insns/divu.h"
 596           break;
 597         }
 598         #include "insns/unimp.h"
 599       }
 600       case 0x4:
 601       {
 602         if((insn.bits & 0xfe007fe0) == 0xea004040)
 603         {
 604           #include "insns/srlv.h"
 605           break;
 606         }
 607         if((insn.bits & 0xfe007fe0) == 0xea004060)
 608         {
 609           #include "insns/srav.h"
 610           break;
 611         }
 612         if((insn.bits & 0xfe007fe0) == 0xea004020)
 613         {
 614           #include "insns/sllv.h"
 615           break;
 616         }
 617         #include "insns/unimp.h"
 618       }
 619       case 0x5:
 620       {
 621         if((insn.bits & 0xfff07800) == 0xea005000)
 622         {
 623           #include "insns/sll.h"
 624           break;
 625         }
 626         #include "insns/unimp.h"
 627       }
 628       case 0x6:
 629       {
 630         if((insn.bits & 0xfff07800) == 0xea006000)
 631         {
 632           #include "insns/srl.h"
 633           break;
 634         }
 635         #include "insns/unimp.h"
 636       }
 637       case 0x7:
 638       {
 639         if((insn.bits & 0xfff07800) == 0xea007000)
 640         {
 641           #include "insns/sra.h"
 642           break;
 643         }
 644         #include "insns/unimp.h"
 645       }
 646       default:
 647       {
 648         #include "insns/unimp.h"
 649       }
 650     }
 651     break;
 652   }
 653   case 0x76:
 654   {
 655     switch((insn.bits >> 0xc) & 0x7)
 656     {
 657       case 0x0:
 658       {
 659         if((insn.bits & 0xfe007fe0) == 0xec000000)
 660         {
 661           #include "insns/addw.h"
 662           break;
 663         }
 664         if((insn.bits & 0xfe007fe0) == 0xec000020)
 665         {
 666           #include "insns/subw.h"
 667           break;
 668         }
 669         #include "insns/unimp.h"
 670       }
 671       case 0x1:
 672       {
 673         if((insn.bits & 0xfe007fe0) == 0xec0010e0)
 674         {
 675           #include "insns/remuw.h"
 676           break;
 677         }
 678         if((insn.bits & 0xfe007fe0) == 0xec0010a0)
 679         {
 680           #include "insns/divuw.h"
 681           break;
 682         }
 683         if((insn.bits & 0xfe007fe0) == 0xec001060)
 684         {
 685           #include "insns/mulhuw.h"
 686           break;
 687         }
 688         if((insn.bits & 0xfe007fe0) == 0xec001000)
 689         {
 690           #include "insns/mulw.h"
 691           break;
 692         }
 693         if((insn.bits & 0xfe007fe0) == 0xec0010c0)
 694         {
 695           #include "insns/remw.h"
 696           break;
 697         }
 698         if((insn.bits & 0xfe007fe0) == 0xec001040)
 699         {
 700           #include "insns/mulhw.h"
 701           break;
 702         }
 703         if((insn.bits & 0xfe007fe0) == 0xec001080)
 704         {
 705           #include "insns/divw.h"
 706           break;
 707         }
 708         #include "insns/unimp.h"
 709       }
 710       case 0x4:
 711       {
 712         if((insn.bits & 0xfe007fe0) == 0xec004060)
 713         {
 714           #include "insns/sravw.h"
 715           break;
 716         }
 717         if((insn.bits & 0xfe007fe0) == 0xec004020)
 718         {
 719           #include "insns/sllvw.h"
 720           break;
 721         }
 722         if((insn.bits & 0xfe007fe0) == 0xec004040)
 723         {
 724           #include "insns/srlvw.h"
 725           break;
 726         }
 727         #include "insns/unimp.h"
 728       }
 729       case 0x5:
 730       {
 731         if((insn.bits & 0xfff07c00) == 0xec005000)
 732         {
 733           #include "insns/sllw.h"
 734           break;
 735         }
 736         #include "insns/unimp.h"
 737       }
 738       case 0x6:
 739       {
 740         if((insn.bits & 0xfff07c00) == 0xec006000)
 741         {
 742           #include "insns/srlw.h"
 743           break;
 744         }
 745         #include "insns/unimp.h"
 746       }
 747       case 0x7:
 748       {
 749         if((insn.bits & 0xfff07c00) == 0xec007000)
 750         {
 751           #include "insns/sraw.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 0x78:
 764   {
 765     switch((insn.bits >> 0xc) & 0x7)
 766     {
 767       case 0x0:
 768       {
 769         #include "insns/lb.h"
 770         break;
 771       }
 772       case 0x1:
 773       {
 774         #include "insns/lh.h"
 775         break;
 776       }
 777       case 0x2:
 778       {
 779         #include "insns/lw.h"
 780         break;
 781       }
 782       case 0x3:
 783       {
 784         #include "insns/ld.h"
 785         break;
 786       }
 787       case 0x4:
 788       {
 789         #include "insns/lbu.h"
 790         break;
 791       }
 792       case 0x5:
 793       {
 794         #include "insns/lhu.h"
 795         break;
 796       }
 797       case 0x6:
 798       {
 799         #include "insns/lwu.h"
 800         break;
 801       }
 802       case 0x7:
 803       {
 804         if((insn.bits & 0xfff07000) == 0xf0007000)
 805         {
 806           #include "insns/synci.h"
 807           break;
 808         }
 809         #include "insns/unimp.h"
 810       }
 811       default:
 812       {
 813         #include "insns/unimp.h"
 814       }
 815     }
 816     break;
 817   }
 818   case 0x79:
 819   {
 820     switch((insn.bits >> 0xc) & 0x7)
 821     {
 822       case 0x0:
 823       {
 824         #include "insns/sb.h"
 825         break;
 826       }
 827       case 0x1:
 828       {
 829         #include "insns/sh.h"
 830         break;
 831       }
 832       case 0x2:
 833       {
 834         #include "insns/sw.h"
 835         break;
 836       }
 837       case 0x3:
 838       {
 839         #include "insns/sd.h"
 840         break;
 841       }
 842       default:
 843       {
 844         #include "insns/unimp.h"
 845       }
 846     }
 847     break;
 848   }
 849   case 0x7a:
 850   {
 851     switch((insn.bits >> 0xc) & 0x7)
 852     {
 853       case 0x2:
 854       {
 855         if((insn.bits & 0xfe007fe0) == 0xf4002040)
 856         {
 857           #include "insns/amow_and.h"
 858           break;
 859         }
 860         if((insn.bits & 0xfe007fe0) == 0xf4002080)
 861         {
 862           #include "insns/amow_min.h"
 863           break;
 864         }
 865         if((insn.bits & 0xfe007fe0) == 0xf4002060)
 866         {
 867           #include "insns/amow_or.h"
 868           break;
 869         }
 870         if((insn.bits & 0xfe007fe0) == 0xf40020a0)
 871         {
 872           #include "insns/amow_max.h"
 873           break;
 874         }
 875         if((insn.bits & 0xfe007fe0) == 0xf40020c0)
 876         {
 877           #include "insns/amow_minu.h"
 878           break;
 879         }
 880         if((insn.bits & 0xfe007fe0) == 0xf4002000)
 881         {
 882           #include "insns/amow_add.h"
 883           break;
 884         }
 885         if((insn.bits & 0xfe007fe0) == 0xf4002020)
 886         {
 887           #include "insns/amow_swap.h"
 888           break;
 889         }
 890         if((insn.bits & 0xfe007fe0) == 0xf40020e0)
 891         {
 892           #include "insns/amow_maxu.h"
 893           break;
 894         }
 895         #include "insns/unimp.h"
 896       }
 897       case 0x3:
 898       {
 899         if((insn.bits & 0xfe007fe0) == 0xf4003000)
 900         {
 901           #include "insns/amo_add.h"
 902           break;
 903         }
 904         if((insn.bits & 0xfe007fe0) == 0xf4003020)
 905         {
 906           #include "insns/amo_swap.h"
 907           break;
 908         }
 909         if((insn.bits & 0xfe007fe0) == 0xf4003060)
 910         {
 911           #include "insns/amo_or.h"
 912           break;
 913         }
 914         if((insn.bits & 0xfe007fe0) == 0xf40030a0)
 915         {
 916           #include "insns/amo_max.h"
 917           break;
 918         }
 919         if((insn.bits & 0xfe007fe0) == 0xf4003080)
 920         {
 921           #include "insns/amo_min.h"
 922           break;
 923         }
 924         if((insn.bits & 0xfe007fe0) == 0xf40030c0)
 925         {
 926           #include "insns/amo_minu.h"
 927           break;
 928         }
 929         if((insn.bits & 0xfe007fe0) == 0xf4003040)
 930         {
 931           #include "insns/amo_and.h"
 932           break;
 933         }
 934         if((insn.bits & 0xfe007fe0) == 0xf40030e0)
 935         {
 936           #include "insns/amo_maxu.h"
 937           break;
 938         }
 939         #include "insns/unimp.h"
 940       }
 941       default:
 942       {
 943         #include "insns/unimp.h"
 944       }
 945     }
 946     break;
 947   }
 948   case 0x7b:
 949   {
 950     switch((insn.bits >> 0xc) & 0x7)
 951     {
 952       case 0x0:
 953       {
 954         if((insn.bits & 0xfe0fffe0) == 0xf6000000)
 955         {
 956           #include "insns/jalr_c.h"
 957           break;
 958         }
 959         if((insn.bits & 0xfe0fffe0) == 0xf6000040)
 960         {
 961           #include "insns/jalr_j.h"
 962           break;
 963         }
 964         if((insn.bits & 0xfe0fffe0) == 0xf6000020)
 965         {
 966           #include "insns/jalr_r.h"
 967           break;
 968         }
 969         #include "insns/unimp.h"
 970       }
 971       case 0x1:
 972       {
 973         if((insn.bits & 0xffffffe0) == 0xf6001000)
 974         {
 975           #include "insns/rdpc.h"
 976           break;
 977         }
 978         #include "insns/unimp.h"
 979       }
 980       case 0x2:
 981       {
 982         if((insn.bits & 0xfe0fffe0) == 0xf6002000)
 983         {
 984           #include "insns/rdhwr.h"
 985           break;
 986         }
 987         #include "insns/unimp.h"
 988       }
 989       case 0x3:
 990       {
 991         if((insn.bits & 0xffffffff) == 0xf6003000)
 992         {
 993           #include "insns/sync.h"
 994           break;
 995         }
 996         #include "insns/unimp.h"
 997       }
 998       case 0x4:
 999       {
1000         if((insn.bits & 0xffffffff) == 0xf6004000)
1001         {
1002           #include "insns/syscall.h"
1003           break;
1004         }
1005         #include "insns/unimp.h"
1006       }
1007       case 0x5:
1008       {
1009         if((insn.bits & 0xffffffff) == 0xf6005000)
1010         {
1011           #include "insns/break.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 0x7e:
1024   {
1025     switch((insn.bits >> 0xc) & 0x7)
1026     {
1027       case 0x0:
1028       {
1029         if((insn.bits & 0xfe0fffff) == 0xfc000000)
1030         {
1031           #include "insns/ei.h"
1032           break;
1033         }
1034         #include "insns/unimp.h"
1035       }
1036       case 0x1:
1037       {
1038         if((insn.bits & 0xfe0fffff) == 0xfc001000)
1039         {
1040           #include "insns/di.h"
1041           break;
1042         }
1043         #include "insns/unimp.h"
1044       }
1045       case 0x2:
1046       {
1047         if((insn.bits & 0xffffffff) == 0xfc002000)
1048         {
1049           #include "insns/eret.h"
1050           break;
1051         }
1052         #include "insns/unimp.h"
1053       }
1054       case 0x4:
1055       {
1056         if((insn.bits & 0xfe007fff) == 0xfc004000)
1057         {
1058           #include "insns/mfpcr.h"
1059           break;
1060         }
1061         #include "insns/unimp.h"
1062       }
1063       case 0x5:
1064       {
1065         if((insn.bits & 0xfe007fff) == 0xfc005000)
1066         {
1067           #include "insns/mwfpcr.h"
1068           break;
1069         }
1070         #include "insns/unimp.h"
1071       }
1072       case 0x6:
1073       {
1074         if((insn.bits & 0xfe007fff) == 0xfc006000)
1075         {
1076           #include "insns/mtpcr.h"
1077           break;
1078         }
1079         #include "insns/unimp.h"
1080       }
1081       case 0x7:
1082       {
1083         if((insn.bits & 0xfe007fff) == 0xfc007000)
1084         {
1085           #include "insns/mwtpcr.h"
1086           break;
1087         }
1088         #include "insns/unimp.h"
1089       }
1090       default:
1091       {
1092         #include "insns/unimp.h"
1093       }
1094     }
1095     break;
1096   }
1097   default:
1098   {
1099     #include "insns/unimp.h"
1100   }
1101 }