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