riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x0) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     switch((insn.bits >> 0x7) & 0x7)
   7     {
   8       case 0x0:
   9       {
  10         if((insn.bits & 0xffffffff) == 0x0)
  11         {
  12           #include "insns/unimp.h"
  13           break;
  14         }
  15         #include "insns/unimp.h"
  16       }
  17       default:
  18       {
  19         #include "insns/unimp.h"
  20       }
  21     }
  22     break;
  23   }
  24   case 0x60:
  25   {
  26     #include "insns/j.h"
  27     break;
  28   }
  29   case 0x61:
  30   {
  31     #include "insns/jal.h"
  32     break;
  33   }
  34   case 0x62:
  35   {
  36     switch((insn.bits >> 0x7) & 0x7)
  37     {
  38       case 0x0:
  39       {
  40         #include "insns/jalr_c.h"
  41         break;
  42       }
  43       case 0x1:
  44       {
  45         #include "insns/jalr_r.h"
  46         break;
  47       }
  48       case 0x2:
  49       {
  50         #include "insns/jalr_j.h"
  51         break;
  52       }
  53       default:
  54       {
  55         #include "insns/unimp.h"
  56       }
  57     }
  58     break;
  59   }
  60   case 0x63:
  61   {
  62     switch((insn.bits >> 0x7) & 0x7)
  63     {
  64       case 0x0:
  65       {
  66         #include "insns/beq.h"
  67         break;
  68       }
  69       case 0x1:
  70       {
  71         #include "insns/bne.h"
  72         break;
  73       }
  74       case 0x4:
  75       {
  76         #include "insns/blt.h"
  77         break;
  78       }
  79       case 0x5:
  80       {
  81         #include "insns/bge.h"
  82         break;
  83       }
  84       case 0x6:
  85       {
  86         #include "insns/bltu.h"
  87         break;
  88       }
  89       case 0x7:
  90       {
  91         #include "insns/bgeu.h"
  92         break;
  93       }
  94       default:
  95       {
  96         #include "insns/unimp.h"
  97       }
  98     }
  99     break;
 100   }
 101   case 0x68:
 102   {
 103     switch((insn.bits >> 0x7) & 0x7)
 104     {
 105       case 0x2:
 106       {
 107         #include "insns/l_s.h"
 108         break;
 109       }
 110       case 0x3:
 111       {
 112         #include "insns/l_d.h"
 113         break;
 114       }
 115       default:
 116       {
 117         #include "insns/unimp.h"
 118       }
 119     }
 120     break;
 121   }
 122   case 0x69:
 123   {
 124     switch((insn.bits >> 0x7) & 0x7)
 125     {
 126       case 0x2:
 127       {
 128         #include "insns/s_s.h"
 129         break;
 130       }
 131       case 0x3:
 132       {
 133         #include "insns/s_d.h"
 134         break;
 135       }
 136       default:
 137       {
 138         #include "insns/unimp.h"
 139       }
 140     }
 141     break;
 142   }
 143   case 0x6a:
 144   {
 145     switch((insn.bits >> 0x7) & 0x7)
 146     {
 147       case 0x0:
 148       {
 149         if((insn.bits & 0x1ffff) == 0x1506a)
 150         {
 151           #include "insns/c_eq_s.h"
 152           break;
 153         }
 154         if((insn.bits & 0x1ffff) == 0x506a)
 155         {
 156           #include "insns/sgninj_s.h"
 157           break;
 158         }
 159         if((insn.bits & 0x3ff1ff) == 0xa06a)
 160         {
 161           #include "insns/cvt_w_s.h"
 162           break;
 163         }
 164         if((insn.bits & 0x3ff1ff) == 0xe06a)
 165         {
 166           #include "insns/cvt_s_w.h"
 167           break;
 168         }
 169         if((insn.bits & 0x1f1ff) == 0x6a)
 170         {
 171           #include "insns/add_s.h"
 172           break;
 173         }
 174         if((insn.bits & 0x3ff1ff) == 0x906a)
 175         {
 176           #include "insns/cvtu_l_s.h"
 177           break;
 178         }
 179         if((insn.bits & 0x7c1ffff) == 0x1846a)
 180         {
 181           #include "insns/mff_s.h"
 182           break;
 183         }
 184         if((insn.bits & 0x3fffff) == 0x1c46a)
 185         {
 186           #include "insns/mtf_s.h"
 187           break;
 188         }
 189         if((insn.bits & 0x1ffff) == 0x606a)
 190         {
 191           #include "insns/sgninjn_s.h"
 192           break;
 193         }
 194         if((insn.bits & 0x3ff1ff) == 0x806a)
 195         {
 196           #include "insns/cvt_l_s.h"
 197           break;
 198         }
 199         if((insn.bits & 0x3ff1ff) == 0xf06a)
 200         {
 201           #include "insns/cvtu_s_w.h"
 202           break;
 203         }
 204         if((insn.bits & 0x3ff1ff) == 0xd06a)
 205         {
 206           #include "insns/cvtu_s_l.h"
 207           break;
 208         }
 209         if((insn.bits & 0x1f1ff) == 0x106a)
 210         {
 211           #include "insns/sub_s.h"
 212           break;
 213         }
 214         if((insn.bits & 0x3ff1ff) == 0x406a)
 215         {
 216           #include "insns/sqrt_s.h"
 217           break;
 218         }
 219         if((insn.bits & 0x1ffff) == 0x1606a)
 220         {
 221           #include "insns/c_lt_s.h"
 222           break;
 223         }
 224         if((insn.bits & 0x1ffff) == 0x706a)
 225         {
 226           #include "insns/sgnmul_s.h"
 227           break;
 228         }
 229         if((insn.bits & 0x3ff1ff) == 0xc06a)
 230         {
 231           #include "insns/cvt_s_l.h"
 232           break;
 233         }
 234         if((insn.bits & 0x1f1ff) == 0x306a)
 235         {
 236           #include "insns/div_s.h"
 237           break;
 238         }
 239         if((insn.bits & 0x3ff1ff) == 0x1306a)
 240         {
 241           #include "insns/cvt_s_d.h"
 242           break;
 243         }
 244         if((insn.bits & 0x1ffff) == 0x1706a)
 245         {
 246           #include "insns/c_le_s.h"
 247           break;
 248         }
 249         if((insn.bits & 0x1f1ff) == 0x206a)
 250         {
 251           #include "insns/mul_s.h"
 252           break;
 253         }
 254         if((insn.bits & 0x3ff1ff) == 0xb06a)
 255         {
 256           #include "insns/cvtu_w_s.h"
 257           break;
 258         }
 259         #include "insns/unimp.h"
 260       }
 261       case 0x3:
 262       {
 263         if((insn.bits & 0x3ff1ff) == 0xa1ea)
 264         {
 265           #include "insns/cvt_w_d.h"
 266           break;
 267         }
 268         if((insn.bits & 0x7c1ffff) == 0x185ea)
 269         {
 270           #include "insns/mff_d.h"
 271           break;
 272         }
 273         if((insn.bits & 0x1ffff) == 0x51ea)
 274         {
 275           #include "insns/sgninj_d.h"
 276           break;
 277         }
 278         if((insn.bits & 0x1f1ff) == 0x31ea)
 279         {
 280           #include "insns/div_d.h"
 281           break;
 282         }
 283         if((insn.bits & 0x1ffff) == 0x151ea)
 284         {
 285           #include "insns/c_eq_d.h"
 286           break;
 287         }
 288         if((insn.bits & 0x3ff1ff) == 0xd1ea)
 289         {
 290           #include "insns/cvtu_d_l.h"
 291           break;
 292         }
 293         if((insn.bits & 0x3fffff) == 0xf1ea)
 294         {
 295           #include "insns/cvtu_d_w.h"
 296           break;
 297         }
 298         if((insn.bits & 0x3ff1ff) == 0x91ea)
 299         {
 300           #include "insns/cvtu_l_d.h"
 301           break;
 302         }
 303         if((insn.bits & 0x7c1ffff) == 0x195ea)
 304         {
 305           #include "insns/mffl_d.h"
 306           break;
 307         }
 308         if((insn.bits & 0x1ffff) == 0x71ea)
 309         {
 310           #include "insns/sgnmul_d.h"
 311           break;
 312         }
 313         if((insn.bits & 0x1f1ff) == 0x1ea)
 314         {
 315           #include "insns/add_d.h"
 316           break;
 317         }
 318         if((insn.bits & 0x7c1ffff) == 0x1a5ea)
 319         {
 320           #include "insns/mffh_d.h"
 321           break;
 322         }
 323         if((insn.bits & 0x1ffff) == 0x171ea)
 324         {
 325           #include "insns/c_le_d.h"
 326           break;
 327         }
 328         if((insn.bits & 0x1ffff) == 0x61ea)
 329         {
 330           #include "insns/sgninjn_d.h"
 331           break;
 332         }
 333         if((insn.bits & 0x3ff1ff) == 0x81ea)
 334         {
 335           #include "insns/cvt_l_d.h"
 336           break;
 337         }
 338         if((insn.bits & 0x1f1ff) == 0x11ea)
 339         {
 340           #include "insns/sub_d.h"
 341           break;
 342         }
 343         if((insn.bits & 0x3fffff) == 0x1c5ea)
 344         {
 345           #include "insns/mtf_d.h"
 346           break;
 347         }
 348         if((insn.bits & 0x3ff1ff) == 0x41ea)
 349         {
 350           #include "insns/sqrt_d.h"
 351           break;
 352         }
 353         if((insn.bits & 0x3fffff) == 0x101ea)
 354         {
 355           #include "insns/cvt_d_s.h"
 356           break;
 357         }
 358         if((insn.bits & 0x3fffff) == 0xe1ea)
 359         {
 360           #include "insns/cvt_d_w.h"
 361           break;
 362         }
 363         if((insn.bits & 0x3ff1ff) == 0xc1ea)
 364         {
 365           #include "insns/cvt_d_l.h"
 366           break;
 367         }
 368         if((insn.bits & 0x1f1ff) == 0x21ea)
 369         {
 370           #include "insns/mul_d.h"
 371           break;
 372         }
 373         if((insn.bits & 0x3ff1ff) == 0xb1ea)
 374         {
 375           #include "insns/cvtu_w_d.h"
 376           break;
 377         }
 378         if((insn.bits & 0x1ffff) == 0x161ea)
 379         {
 380           #include "insns/c_lt_d.h"
 381           break;
 382         }
 383         #include "insns/unimp.h"
 384       }
 385       case 0x7:
 386       {
 387         if((insn.bits & 0x1ffff) == 0x1c7ea)
 388         {
 389           #include "insns/mtflh_d.h"
 390           break;
 391         }
 392         #include "insns/unimp.h"
 393       }
 394       default:
 395       {
 396         #include "insns/unimp.h"
 397       }
 398     }
 399     break;
 400   }
 401   case 0x6b:
 402   {
 403     switch((insn.bits >> 0x7) & 0x7)
 404     {
 405       case 0x0:
 406       {
 407         if((insn.bits & 0x7ffffff) == 0x46b)
 408         {
 409           #include "insns/di.h"
 410           break;
 411         }
 412         if((insn.bits & 0x7ffffff) == 0x6b)
 413         {
 414           #include "insns/ei.h"
 415           break;
 416         }
 417         #include "insns/unimp.h"
 418       }
 419       case 0x1:
 420       {
 421         if((insn.bits & 0x7c1ffff) == 0xeb)
 422         {
 423           #include "insns/mfpcr.h"
 424           break;
 425         }
 426         if((insn.bits & 0xf801ffff) == 0x4eb)
 427         {
 428           #include "insns/mtpcr.h"
 429           break;
 430         }
 431         #include "insns/unimp.h"
 432       }
 433       case 0x2:
 434       {
 435         if((insn.bits & 0xffffffff) == 0x16b)
 436         {
 437           #include "insns/eret.h"
 438           break;
 439         }
 440         #include "insns/unimp.h"
 441       }
 442       default:
 443       {
 444         #include "insns/unimp.h"
 445       }
 446     }
 447     break;
 448   }
 449   case 0x6c:
 450   {
 451     switch((insn.bits >> 0x7) & 0x7)
 452     {
 453       case 0x0:
 454       {
 455         #include "insns/madd_s.h"
 456         break;
 457       }
 458       case 0x3:
 459       {
 460         #include "insns/madd_d.h"
 461         break;
 462       }
 463       default:
 464       {
 465         #include "insns/unimp.h"
 466       }
 467     }
 468     break;
 469   }
 470   case 0x6d:
 471   {
 472     switch((insn.bits >> 0x7) & 0x7)
 473     {
 474       case 0x0:
 475       {
 476         #include "insns/msub_s.h"
 477         break;
 478       }
 479       case 0x3:
 480       {
 481         #include "insns/msub_d.h"
 482         break;
 483       }
 484       default:
 485       {
 486         #include "insns/unimp.h"
 487       }
 488     }
 489     break;
 490   }
 491   case 0x6e:
 492   {
 493     switch((insn.bits >> 0x7) & 0x7)
 494     {
 495       case 0x0:
 496       {
 497         #include "insns/nmsub_s.h"
 498         break;
 499       }
 500       case 0x3:
 501       {
 502         #include "insns/nmsub_d.h"
 503         break;
 504       }
 505       default:
 506       {
 507         #include "insns/unimp.h"
 508       }
 509     }
 510     break;
 511   }
 512   case 0x6f:
 513   {
 514     switch((insn.bits >> 0x7) & 0x7)
 515     {
 516       case 0x0:
 517       {
 518         #include "insns/nmadd_s.h"
 519         break;
 520       }
 521       case 0x3:
 522       {
 523         #include "insns/nmadd_d.h"
 524         break;
 525       }
 526       default:
 527       {
 528         #include "insns/unimp.h"
 529       }
 530     }
 531     break;
 532   }
 533   case 0x71:
 534   {
 535     #include "insns/lui.h"
 536     break;
 537   }
 538   case 0x74:
 539   {
 540     switch((insn.bits >> 0x7) & 0x7)
 541     {
 542       case 0x0:
 543       {
 544         #include "insns/addi.h"
 545         break;
 546       }
 547       case 0x2:
 548       {
 549         #include "insns/slti.h"
 550         break;
 551       }
 552       case 0x3:
 553       {
 554         #include "insns/sltiu.h"
 555         break;
 556       }
 557       case 0x4:
 558       {
 559         #include "insns/andi.h"
 560         break;
 561       }
 562       case 0x5:
 563       {
 564         #include "insns/ori.h"
 565         break;
 566       }
 567       case 0x6:
 568       {
 569         #include "insns/xori.h"
 570         break;
 571       }
 572       case 0x7:
 573       {
 574         if((insn.bits & 0xffff) == 0xbf4)
 575         {
 576           #include "insns/srli.h"
 577           break;
 578         }
 579         if((insn.bits & 0xffff) == 0xff4)
 580         {
 581           #include "insns/srai.h"
 582           break;
 583         }
 584         if((insn.bits & 0xffff) == 0x7f4)
 585         {
 586           #include "insns/slli.h"
 587           break;
 588         }
 589         #include "insns/unimp.h"
 590       }
 591       default:
 592       {
 593         #include "insns/unimp.h"
 594       }
 595     }
 596     break;
 597   }
 598   case 0x75:
 599   {
 600     switch((insn.bits >> 0x7) & 0x7)
 601     {
 602       case 0x0:
 603       {
 604         if((insn.bits & 0x1ffff) == 0x75)
 605         {
 606           #include "insns/add.h"
 607           break;
 608         }
 609         if((insn.bits & 0x1ffff) == 0xc75)
 610         {
 611           #include "insns/sltu.h"
 612           break;
 613         }
 614         if((insn.bits & 0x1ffff) == 0x1875)
 615         {
 616           #include "insns/xor.h"
 617           break;
 618         }
 619         if((insn.bits & 0x1ffff) == 0x475)
 620         {
 621           #include "insns/sub.h"
 622           break;
 623         }
 624         if((insn.bits & 0x1ffff) == 0x1475)
 625         {
 626           #include "insns/or.h"
 627           break;
 628         }
 629         if((insn.bits & 0x1ffff) == 0x875)
 630         {
 631           #include "insns/slt.h"
 632           break;
 633         }
 634         if((insn.bits & 0x1ffff) == 0x1075)
 635         {
 636           #include "insns/and.h"
 637           break;
 638         }
 639         #include "insns/unimp.h"
 640       }
 641       case 0x1:
 642       {
 643         if((insn.bits & 0x1ffff) == 0xf5)
 644         {
 645           #include "insns/mul.h"
 646           break;
 647         }
 648         if((insn.bits & 0x1ffff) == 0x10f5)
 649         {
 650           #include "insns/div.h"
 651           break;
 652         }
 653         if((insn.bits & 0x1ffff) == 0x18f5)
 654         {
 655           #include "insns/rem.h"
 656           break;
 657         }
 658         if((insn.bits & 0x1ffff) == 0x8f5)
 659         {
 660           #include "insns/mulh.h"
 661           break;
 662         }
 663         if((insn.bits & 0x1ffff) == 0x1cf5)
 664         {
 665           #include "insns/remu.h"
 666           break;
 667         }
 668         if((insn.bits & 0x1ffff) == 0xcf5)
 669         {
 670           #include "insns/mulhu.h"
 671           break;
 672         }
 673         if((insn.bits & 0x1ffff) == 0x14f5)
 674         {
 675           #include "insns/divu.h"
 676           break;
 677         }
 678         #include "insns/unimp.h"
 679       }
 680       case 0x7:
 681       {
 682         if((insn.bits & 0x1ffff) == 0xff5)
 683         {
 684           #include "insns/sra.h"
 685           break;
 686         }
 687         if((insn.bits & 0x1ffff) == 0xbf5)
 688         {
 689           #include "insns/srl.h"
 690           break;
 691         }
 692         if((insn.bits & 0x1ffff) == 0x7f5)
 693         {
 694           #include "insns/sll.h"
 695           break;
 696         }
 697         #include "insns/unimp.h"
 698       }
 699       default:
 700       {
 701         #include "insns/unimp.h"
 702       }
 703     }
 704     break;
 705   }
 706   case 0x76:
 707   {
 708     switch((insn.bits >> 0x7) & 0x7)
 709     {
 710       case 0x0:
 711       {
 712         #include "insns/addiw.h"
 713         break;
 714       }
 715       case 0x7:
 716       {
 717         if((insn.bits & 0x20ffff) == 0x7f6)
 718         {
 719           #include "insns/slliw.h"
 720           break;
 721         }
 722         if((insn.bits & 0x20ffff) == 0xbf6)
 723         {
 724           #include "insns/srliw.h"
 725           break;
 726         }
 727         if((insn.bits & 0x20ffff) == 0xff6)
 728         {
 729           #include "insns/sraiw.h"
 730           break;
 731         }
 732         #include "insns/unimp.h"
 733       }
 734       default:
 735       {
 736         #include "insns/unimp.h"
 737       }
 738     }
 739     break;
 740   }
 741   case 0x77:
 742   {
 743     switch((insn.bits >> 0x7) & 0x7)
 744     {
 745       case 0x0:
 746       {
 747         if((insn.bits & 0x1ffff) == 0x77)
 748         {
 749           #include "insns/addw.h"
 750           break;
 751         }
 752         if((insn.bits & 0x1ffff) == 0x477)
 753         {
 754           #include "insns/subw.h"
 755           break;
 756         }
 757         #include "insns/unimp.h"
 758       }
 759       case 0x1:
 760       {
 761         if((insn.bits & 0x1ffff) == 0x1cf7)
 762         {
 763           #include "insns/remuw.h"
 764           break;
 765         }
 766         if((insn.bits & 0x1ffff) == 0x14f7)
 767         {
 768           #include "insns/divuw.h"
 769           break;
 770         }
 771         if((insn.bits & 0x1ffff) == 0xf7)
 772         {
 773           #include "insns/mulw.h"
 774           break;
 775         }
 776         if((insn.bits & 0x1ffff) == 0x18f7)
 777         {
 778           #include "insns/remw.h"
 779           break;
 780         }
 781         if((insn.bits & 0x1ffff) == 0x10f7)
 782         {
 783           #include "insns/divw.h"
 784           break;
 785         }
 786         #include "insns/unimp.h"
 787       }
 788       case 0x7:
 789       {
 790         if((insn.bits & 0x1ffff) == 0xbf7)
 791         {
 792           #include "insns/srlw.h"
 793           break;
 794         }
 795         if((insn.bits & 0x1ffff) == 0xff7)
 796         {
 797           #include "insns/sraw.h"
 798           break;
 799         }
 800         if((insn.bits & 0x1ffff) == 0x7f7)
 801         {
 802           #include "insns/sllw.h"
 803           break;
 804         }
 805         #include "insns/unimp.h"
 806       }
 807       default:
 808       {
 809         #include "insns/unimp.h"
 810       }
 811     }
 812     break;
 813   }
 814   case 0x78:
 815   {
 816     switch((insn.bits >> 0x7) & 0x7)
 817     {
 818       case 0x0:
 819       {
 820         #include "insns/lb.h"
 821         break;
 822       }
 823       case 0x1:
 824       {
 825         #include "insns/lh.h"
 826         break;
 827       }
 828       case 0x2:
 829       {
 830         #include "insns/lw.h"
 831         break;
 832       }
 833       case 0x3:
 834       {
 835         #include "insns/ld.h"
 836         break;
 837       }
 838       case 0x4:
 839       {
 840         #include "insns/lbu.h"
 841         break;
 842       }
 843       case 0x5:
 844       {
 845         #include "insns/lhu.h"
 846         break;
 847       }
 848       case 0x6:
 849       {
 850         #include "insns/lwu.h"
 851         break;
 852       }
 853       case 0x7:
 854       {
 855         if((insn.bits & 0xf80003ff) == 0x3f8)
 856         {
 857           #include "insns/synci.h"
 858           break;
 859         }
 860         #include "insns/unimp.h"
 861       }
 862       default:
 863       {
 864         #include "insns/unimp.h"
 865       }
 866     }
 867     break;
 868   }
 869   case 0x79:
 870   {
 871     switch((insn.bits >> 0x7) & 0x7)
 872     {
 873       case 0x0:
 874       {
 875         #include "insns/sb.h"
 876         break;
 877       }
 878       case 0x1:
 879       {
 880         #include "insns/sh.h"
 881         break;
 882       }
 883       case 0x2:
 884       {
 885         #include "insns/sw.h"
 886         break;
 887       }
 888       case 0x3:
 889       {
 890         #include "insns/sd.h"
 891         break;
 892       }
 893       default:
 894       {
 895         #include "insns/unimp.h"
 896       }
 897     }
 898     break;
 899   }
 900   case 0x7a:
 901   {
 902     switch((insn.bits >> 0x7) & 0x7)
 903     {
 904       case 0x2:
 905       {
 906         if((insn.bits & 0x1ffff) == 0x157a)
 907         {
 908           #include "insns/amow_max.h"
 909           break;
 910         }
 911         if((insn.bits & 0x1ffff) == 0x97a)
 912         {
 913           #include "insns/amow_and.h"
 914           break;
 915         }
 916         if((insn.bits & 0x1ffff) == 0x117a)
 917         {
 918           #include "insns/amow_min.h"
 919           break;
 920         }
 921         if((insn.bits & 0x1ffff) == 0xd7a)
 922         {
 923           #include "insns/amow_or.h"
 924           break;
 925         }
 926         if((insn.bits & 0x1ffff) == 0x197a)
 927         {
 928           #include "insns/amow_minu.h"
 929           break;
 930         }
 931         if((insn.bits & 0x1ffff) == 0x17a)
 932         {
 933           #include "insns/amow_add.h"
 934           break;
 935         }
 936         if((insn.bits & 0x1ffff) == 0x57a)
 937         {
 938           #include "insns/amow_swap.h"
 939           break;
 940         }
 941         if((insn.bits & 0x1ffff) == 0x1d7a)
 942         {
 943           #include "insns/amow_maxu.h"
 944           break;
 945         }
 946         #include "insns/unimp.h"
 947       }
 948       case 0x3:
 949       {
 950         if((insn.bits & 0x1ffff) == 0x1fa)
 951         {
 952           #include "insns/amo_add.h"
 953           break;
 954         }
 955         if((insn.bits & 0x1ffff) == 0x5fa)
 956         {
 957           #include "insns/amo_swap.h"
 958           break;
 959         }
 960         if((insn.bits & 0x1ffff) == 0xdfa)
 961         {
 962           #include "insns/amo_or.h"
 963           break;
 964         }
 965         if((insn.bits & 0x1ffff) == 0x15fa)
 966         {
 967           #include "insns/amo_max.h"
 968           break;
 969         }
 970         if((insn.bits & 0x1ffff) == 0x11fa)
 971         {
 972           #include "insns/amo_min.h"
 973           break;
 974         }
 975         if((insn.bits & 0x1ffff) == 0x19fa)
 976         {
 977           #include "insns/amo_minu.h"
 978           break;
 979         }
 980         if((insn.bits & 0x1ffff) == 0x9fa)
 981         {
 982           #include "insns/amo_and.h"
 983           break;
 984         }
 985         if((insn.bits & 0x1ffff) == 0x1dfa)
 986         {
 987           #include "insns/amo_maxu.h"
 988           break;
 989         }
 990         #include "insns/unimp.h"
 991       }
 992       default:
 993       {
 994         #include "insns/unimp.h"
 995       }
 996     }
 997     break;
 998   }
 999   case 0x7b:
1000   {
1001     switch((insn.bits >> 0x7) & 0x7)
1002     {
1003       case 0x0:
1004       {
1005         if((insn.bits & 0x7ffffff) == 0x7b)
1006         {
1007           #include "insns/rdnpc.h"
1008           break;
1009         }
1010         #include "insns/unimp.h"
1011       }
1012       case 0x1:
1013       {
1014         if((insn.bits & 0x7c1ffff) == 0xfb)
1015         {
1016           #include "insns/mfcr.h"
1017           break;
1018         }
1019         if((insn.bits & 0xf801ffff) == 0x4fb)
1020         {
1021           #include "insns/mtcr.h"
1022           break;
1023         }
1024         #include "insns/unimp.h"
1025       }
1026       case 0x2:
1027       {
1028         if((insn.bits & 0xffffffff) == 0x17b)
1029         {
1030           #include "insns/sync.h"
1031           break;
1032         }
1033         #include "insns/unimp.h"
1034       }
1035       case 0x3:
1036       {
1037         if((insn.bits & 0xffc003ff) == 0x1fb)
1038         {
1039           #include "insns/syscall.h"
1040           break;
1041         }
1042         #include "insns/unimp.h"
1043       }
1044       default:
1045       {
1046         #include "insns/unimp.h"
1047       }
1048     }
1049     break;
1050   }
1051   default:
1052   {
1053     #include "insns/unimp.h"
1054   }
1055 }