riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x19) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     switch((insn.bits >> 0x16) & 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 >> 0x16) & 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 >> 0x16) & 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 >> 0x16) & 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 >> 0x16) & 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 >> 0x16) & 0x7)
 146     {
 147       case 0x0:
 148       {
 149         if((insn.bits & 0xffff8000) == 0xd40a8000)
 150         {
 151           #include "insns/c_eq_s.h"
 152           break;
 153         }
 154         if((insn.bits & 0xffff8000) == 0xd4028000)
 155         {
 156           #include "insns/sgninj_s.h"
 157           break;
 158         }
 159         if((insn.bits & 0xff8ffc00) == 0xd4050000)
 160         {
 161           #include "insns/cvt_w_s.h"
 162           break;
 163         }
 164         if((insn.bits & 0xff8ffc00) == 0xd4070000)
 165         {
 166           #include "insns/cvt_s_w.h"
 167           break;
 168         }
 169         if((insn.bits & 0xff8f8000) == 0xd4000000)
 170         {
 171           #include "insns/add_s.h"
 172           break;
 173         }
 174         if((insn.bits & 0xff8ffc00) == 0xd4048000)
 175         {
 176           #include "insns/cvtu_l_s.h"
 177           break;
 178         }
 179         if((insn.bits & 0xffff83e0) == 0xd42c0000)
 180         {
 181           #include "insns/mff_s.h"
 182           break;
 183         }
 184         if((insn.bits & 0xfffffc00) == 0xd42e0000)
 185         {
 186           #include "insns/mtf_s.h"
 187           break;
 188         }
 189         if((insn.bits & 0xffff8000) == 0xd4030000)
 190         {
 191           #include "insns/sgninjn_s.h"
 192           break;
 193         }
 194         if((insn.bits & 0xff8ffc00) == 0xd4040000)
 195         {
 196           #include "insns/cvt_l_s.h"
 197           break;
 198         }
 199         if((insn.bits & 0xff8ffc00) == 0xd4078000)
 200         {
 201           #include "insns/cvtu_s_w.h"
 202           break;
 203         }
 204         if((insn.bits & 0xff8ffc00) == 0xd4068000)
 205         {
 206           #include "insns/cvtu_s_l.h"
 207           break;
 208         }
 209         if((insn.bits & 0xff8f8000) == 0xd4008000)
 210         {
 211           #include "insns/sub_s.h"
 212           break;
 213         }
 214         if((insn.bits & 0xff8ffc00) == 0xd4020000)
 215         {
 216           #include "insns/sqrt_s.h"
 217           break;
 218         }
 219         if((insn.bits & 0xffff8000) == 0xd40b0000)
 220         {
 221           #include "insns/c_lt_s.h"
 222           break;
 223         }
 224         if((insn.bits & 0xffff8000) == 0xd4038000)
 225         {
 226           #include "insns/sgnmul_s.h"
 227           break;
 228         }
 229         if((insn.bits & 0xff8ffc00) == 0xd4060000)
 230         {
 231           #include "insns/cvt_s_l.h"
 232           break;
 233         }
 234         if((insn.bits & 0xff8f8000) == 0xd4018000)
 235         {
 236           #include "insns/div_s.h"
 237           break;
 238         }
 239         if((insn.bits & 0xff8ffc00) == 0xd4098000)
 240         {
 241           #include "insns/cvt_s_d.h"
 242           break;
 243         }
 244         if((insn.bits & 0xffff8000) == 0xd40b8000)
 245         {
 246           #include "insns/c_le_s.h"
 247           break;
 248         }
 249         if((insn.bits & 0xff8f8000) == 0xd4010000)
 250         {
 251           #include "insns/mul_s.h"
 252           break;
 253         }
 254         if((insn.bits & 0xff8ffc00) == 0xd4058000)
 255         {
 256           #include "insns/cvtu_w_s.h"
 257           break;
 258         }
 259         #include "insns/unimp.h"
 260       }
 261       case 0x6:
 262       {
 263         if((insn.bits & 0xff8ffc00) == 0xd5850000)
 264         {
 265           #include "insns/cvt_w_d.h"
 266           break;
 267         }
 268         if((insn.bits & 0xffff83e0) == 0xd5ac0000)
 269         {
 270           #include "insns/mff_d.h"
 271           break;
 272         }
 273         if((insn.bits & 0xffff8000) == 0xd5828000)
 274         {
 275           #include "insns/sgninj_d.h"
 276           break;
 277         }
 278         if((insn.bits & 0xff8f8000) == 0xd5818000)
 279         {
 280           #include "insns/div_d.h"
 281           break;
 282         }
 283         if((insn.bits & 0xffff8000) == 0xd58a8000)
 284         {
 285           #include "insns/c_eq_d.h"
 286           break;
 287         }
 288         if((insn.bits & 0xff8ffc00) == 0xd5868000)
 289         {
 290           #include "insns/cvtu_d_l.h"
 291           break;
 292         }
 293         if((insn.bits & 0xfffffc00) == 0xd5878000)
 294         {
 295           #include "insns/cvtu_d_w.h"
 296           break;
 297         }
 298         if((insn.bits & 0xff8ffc00) == 0xd5848000)
 299         {
 300           #include "insns/cvtu_l_d.h"
 301           break;
 302         }
 303         if((insn.bits & 0xffff83e0) == 0xd5ac8000)
 304         {
 305           #include "insns/mffl_d.h"
 306           break;
 307         }
 308         if((insn.bits & 0xffff8000) == 0xd5838000)
 309         {
 310           #include "insns/sgnmul_d.h"
 311           break;
 312         }
 313         if((insn.bits & 0xff8f8000) == 0xd5800000)
 314         {
 315           #include "insns/add_d.h"
 316           break;
 317         }
 318         if((insn.bits & 0xffff83e0) == 0xd5ad0000)
 319         {
 320           #include "insns/mffh_d.h"
 321           break;
 322         }
 323         if((insn.bits & 0xffff8000) == 0xd58b8000)
 324         {
 325           #include "insns/c_le_d.h"
 326           break;
 327         }
 328         if((insn.bits & 0xffff8000) == 0xd5830000)
 329         {
 330           #include "insns/sgninjn_d.h"
 331           break;
 332         }
 333         if((insn.bits & 0xffff8000) == 0xd5be0000)
 334         {
 335           #include "insns/mtflh_d.h"
 336           break;
 337         }
 338         if((insn.bits & 0xff8ffc00) == 0xd5840000)
 339         {
 340           #include "insns/cvt_l_d.h"
 341           break;
 342         }
 343         if((insn.bits & 0xff8f8000) == 0xd5808000)
 344         {
 345           #include "insns/sub_d.h"
 346           break;
 347         }
 348         if((insn.bits & 0xfffffc00) == 0xd5ae0000)
 349         {
 350           #include "insns/mtf_d.h"
 351           break;
 352         }
 353         if((insn.bits & 0xff8ffc00) == 0xd5820000)
 354         {
 355           #include "insns/sqrt_d.h"
 356           break;
 357         }
 358         if((insn.bits & 0xfffffc00) == 0xd5880000)
 359         {
 360           #include "insns/cvt_d_s.h"
 361           break;
 362         }
 363         if((insn.bits & 0xfffffc00) == 0xd5870000)
 364         {
 365           #include "insns/cvt_d_w.h"
 366           break;
 367         }
 368         if((insn.bits & 0xff8ffc00) == 0xd5860000)
 369         {
 370           #include "insns/cvt_d_l.h"
 371           break;
 372         }
 373         if((insn.bits & 0xff8f8000) == 0xd5810000)
 374         {
 375           #include "insns/mul_d.h"
 376           break;
 377         }
 378         if((insn.bits & 0xff8ffc00) == 0xd5858000)
 379         {
 380           #include "insns/cvtu_w_d.h"
 381           break;
 382         }
 383         if((insn.bits & 0xffff8000) == 0xd58b0000)
 384         {
 385           #include "insns/c_lt_d.h"
 386           break;
 387         }
 388         #include "insns/unimp.h"
 389       }
 390       default:
 391       {
 392         #include "insns/unimp.h"
 393       }
 394     }
 395     break;
 396   }
 397   case 0x6b:
 398   {
 399     switch((insn.bits >> 0x16) & 0x7)
 400     {
 401       case 0x0:
 402       {
 403         if((insn.bits & 0xffffffe0) == 0xd6008000)
 404         {
 405           #include "insns/di.h"
 406           break;
 407         }
 408         if((insn.bits & 0xffffffe0) == 0xd6000000)
 409         {
 410           #include "insns/ei.h"
 411           break;
 412         }
 413         #include "insns/unimp.h"
 414       }
 415       case 0x1:
 416       {
 417         if((insn.bits & 0xffff83e0) == 0xd6400000)
 418         {
 419           #include "insns/mfpcr.h"
 420           break;
 421         }
 422         if((insn.bits & 0xffff801f) == 0xd6408000)
 423         {
 424           #include "insns/mtpcr.h"
 425           break;
 426         }
 427         #include "insns/unimp.h"
 428       }
 429       case 0x2:
 430       {
 431         if((insn.bits & 0xffffffff) == 0xd6800000)
 432         {
 433           #include "insns/eret.h"
 434           break;
 435         }
 436         #include "insns/unimp.h"
 437       }
 438       default:
 439       {
 440         #include "insns/unimp.h"
 441       }
 442     }
 443     break;
 444   }
 445   case 0x6c:
 446   {
 447     switch((insn.bits >> 0x16) & 0x7)
 448     {
 449       case 0x0:
 450       {
 451         #include "insns/madd_s.h"
 452         break;
 453       }
 454       case 0x6:
 455       {
 456         #include "insns/madd_d.h"
 457         break;
 458       }
 459       default:
 460       {
 461         #include "insns/unimp.h"
 462       }
 463     }
 464     break;
 465   }
 466   case 0x6d:
 467   {
 468     switch((insn.bits >> 0x16) & 0x7)
 469     {
 470       case 0x0:
 471       {
 472         #include "insns/msub_s.h"
 473         break;
 474       }
 475       case 0x6:
 476       {
 477         #include "insns/msub_d.h"
 478         break;
 479       }
 480       default:
 481       {
 482         #include "insns/unimp.h"
 483       }
 484     }
 485     break;
 486   }
 487   case 0x6e:
 488   {
 489     switch((insn.bits >> 0x16) & 0x7)
 490     {
 491       case 0x0:
 492       {
 493         #include "insns/nmsub_s.h"
 494         break;
 495       }
 496       case 0x6:
 497       {
 498         #include "insns/nmsub_d.h"
 499         break;
 500       }
 501       default:
 502       {
 503         #include "insns/unimp.h"
 504       }
 505     }
 506     break;
 507   }
 508   case 0x6f:
 509   {
 510     switch((insn.bits >> 0x16) & 0x7)
 511     {
 512       case 0x0:
 513       {
 514         #include "insns/nmadd_s.h"
 515         break;
 516       }
 517       case 0x6:
 518       {
 519         #include "insns/nmadd_d.h"
 520         break;
 521       }
 522       default:
 523       {
 524         #include "insns/unimp.h"
 525       }
 526     }
 527     break;
 528   }
 529   case 0x71:
 530   {
 531     #include "insns/lui.h"
 532     break;
 533   }
 534   case 0x74:
 535   {
 536     switch((insn.bits >> 0x16) & 0x7)
 537     {
 538       case 0x0:
 539       {
 540         #include "insns/addi.h"
 541         break;
 542       }
 543       case 0x2:
 544       {
 545         #include "insns/slti.h"
 546         break;
 547       }
 548       case 0x3:
 549       {
 550         #include "insns/sltiu.h"
 551         break;
 552       }
 553       case 0x4:
 554       {
 555         #include "insns/andi.h"
 556         break;
 557       }
 558       case 0x5:
 559       {
 560         #include "insns/ori.h"
 561         break;
 562       }
 563       case 0x6:
 564       {
 565         #include "insns/xori.h"
 566         break;
 567       }
 568       case 0x7:
 569       {
 570         if((insn.bits & 0xffff0000) == 0xe9c20000)
 571         {
 572           #include "insns/srli.h"
 573           break;
 574         }
 575         if((insn.bits & 0xffff0000) == 0xe9c30000)
 576         {
 577           #include "insns/srai.h"
 578           break;
 579         }
 580         if((insn.bits & 0xffff0000) == 0xe9c10000)
 581         {
 582           #include "insns/slli.h"
 583           break;
 584         }
 585         #include "insns/unimp.h"
 586       }
 587       default:
 588       {
 589         #include "insns/unimp.h"
 590       }
 591     }
 592     break;
 593   }
 594   case 0x75:
 595   {
 596     switch((insn.bits >> 0x16) & 0x7)
 597     {
 598       case 0x0:
 599       {
 600         if((insn.bits & 0xffff8000) == 0xea000000)
 601         {
 602           #include "insns/add.h"
 603           break;
 604         }
 605         if((insn.bits & 0xffff8000) == 0xea038000)
 606         {
 607           #include "insns/nor.h"
 608           break;
 609         }
 610         if((insn.bits & 0xffff8000) == 0xea018000)
 611         {
 612           #include "insns/sltu.h"
 613           break;
 614         }
 615         if((insn.bits & 0xffff8000) == 0xea030000)
 616         {
 617           #include "insns/xor.h"
 618           break;
 619         }
 620         if((insn.bits & 0xffff8000) == 0xea008000)
 621         {
 622           #include "insns/sub.h"
 623           break;
 624         }
 625         if((insn.bits & 0xffff8000) == 0xea028000)
 626         {
 627           #include "insns/or.h"
 628           break;
 629         }
 630         if((insn.bits & 0xffff8000) == 0xea010000)
 631         {
 632           #include "insns/slt.h"
 633           break;
 634         }
 635         if((insn.bits & 0xffff8000) == 0xea020000)
 636         {
 637           #include "insns/and.h"
 638           break;
 639         }
 640         #include "insns/unimp.h"
 641       }
 642       case 0x1:
 643       {
 644         if((insn.bits & 0xffff8000) == 0xea400000)
 645         {
 646           #include "insns/mul.h"
 647           break;
 648         }
 649         if((insn.bits & 0xffff8000) == 0xea420000)
 650         {
 651           #include "insns/div.h"
 652           break;
 653         }
 654         if((insn.bits & 0xffff8000) == 0xea430000)
 655         {
 656           #include "insns/rem.h"
 657           break;
 658         }
 659         if((insn.bits & 0xffff8000) == 0xea410000)
 660         {
 661           #include "insns/mulh.h"
 662           break;
 663         }
 664         if((insn.bits & 0xffff8000) == 0xea438000)
 665         {
 666           #include "insns/remu.h"
 667           break;
 668         }
 669         if((insn.bits & 0xffff8000) == 0xea418000)
 670         {
 671           #include "insns/mulhu.h"
 672           break;
 673         }
 674         if((insn.bits & 0xffff8000) == 0xea428000)
 675         {
 676           #include "insns/divu.h"
 677           break;
 678         }
 679         #include "insns/unimp.h"
 680       }
 681       case 0x7:
 682       {
 683         if((insn.bits & 0xffff8000) == 0xebc30000)
 684         {
 685           #include "insns/sra.h"
 686           break;
 687         }
 688         if((insn.bits & 0xffff8000) == 0xebc20000)
 689         {
 690           #include "insns/srl.h"
 691           break;
 692         }
 693         if((insn.bits & 0xffff8000) == 0xebc10000)
 694         {
 695           #include "insns/sll.h"
 696           break;
 697         }
 698         #include "insns/unimp.h"
 699       }
 700       default:
 701       {
 702         #include "insns/unimp.h"
 703       }
 704     }
 705     break;
 706   }
 707   case 0x76:
 708   {
 709     switch((insn.bits >> 0x16) & 0x7)
 710     {
 711       case 0x0:
 712       {
 713         #include "insns/addiw.h"
 714         break;
 715       }
 716       case 0x7:
 717       {
 718         if((insn.bits & 0xffff8000) == 0xedc10000)
 719         {
 720           #include "insns/slliw.h"
 721           break;
 722         }
 723         if((insn.bits & 0xffff8000) == 0xedc20000)
 724         {
 725           #include "insns/srliw.h"
 726           break;
 727         }
 728         if((insn.bits & 0xffff8000) == 0xedc30000)
 729         {
 730           #include "insns/sraiw.h"
 731           break;
 732         }
 733         #include "insns/unimp.h"
 734       }
 735       default:
 736       {
 737         #include "insns/unimp.h"
 738       }
 739     }
 740     break;
 741   }
 742   case 0x77:
 743   {
 744     switch((insn.bits >> 0x16) & 0x7)
 745     {
 746       case 0x0:
 747       {
 748         if((insn.bits & 0xffff8000) == 0xee000000)
 749         {
 750           #include "insns/addw.h"
 751           break;
 752         }
 753         if((insn.bits & 0xffff8000) == 0xee008000)
 754         {
 755           #include "insns/subw.h"
 756           break;
 757         }
 758         #include "insns/unimp.h"
 759       }
 760       case 0x1:
 761       {
 762         if((insn.bits & 0xffff8000) == 0xee438000)
 763         {
 764           #include "insns/remuw.h"
 765           break;
 766         }
 767         if((insn.bits & 0xffff8000) == 0xee428000)
 768         {
 769           #include "insns/divuw.h"
 770           break;
 771         }
 772         if((insn.bits & 0xffff8000) == 0xee418000)
 773         {
 774           #include "insns/mulhuw.h"
 775           break;
 776         }
 777         if((insn.bits & 0xffff8000) == 0xee400000)
 778         {
 779           #include "insns/mulw.h"
 780           break;
 781         }
 782         if((insn.bits & 0xffff8000) == 0xee430000)
 783         {
 784           #include "insns/remw.h"
 785           break;
 786         }
 787         if((insn.bits & 0xffff8000) == 0xee410000)
 788         {
 789           #include "insns/mulhw.h"
 790           break;
 791         }
 792         if((insn.bits & 0xffff8000) == 0xee420000)
 793         {
 794           #include "insns/divw.h"
 795           break;
 796         }
 797         #include "insns/unimp.h"
 798       }
 799       case 0x7:
 800       {
 801         if((insn.bits & 0xffff8000) == 0xefc20000)
 802         {
 803           #include "insns/srlw.h"
 804           break;
 805         }
 806         if((insn.bits & 0xffff8000) == 0xefc30000)
 807         {
 808           #include "insns/sraw.h"
 809           break;
 810         }
 811         if((insn.bits & 0xffff8000) == 0xefc10000)
 812         {
 813           #include "insns/sllw.h"
 814           break;
 815         }
 816         #include "insns/unimp.h"
 817       }
 818       default:
 819       {
 820         #include "insns/unimp.h"
 821       }
 822     }
 823     break;
 824   }
 825   case 0x78:
 826   {
 827     switch((insn.bits >> 0x16) & 0x7)
 828     {
 829       case 0x0:
 830       {
 831         #include "insns/lb.h"
 832         break;
 833       }
 834       case 0x1:
 835       {
 836         #include "insns/lh.h"
 837         break;
 838       }
 839       case 0x2:
 840       {
 841         #include "insns/lw.h"
 842         break;
 843       }
 844       case 0x3:
 845       {
 846         #include "insns/ld.h"
 847         break;
 848       }
 849       case 0x4:
 850       {
 851         #include "insns/lbu.h"
 852         break;
 853       }
 854       case 0x5:
 855       {
 856         #include "insns/lhu.h"
 857         break;
 858       }
 859       case 0x6:
 860       {
 861         #include "insns/lwu.h"
 862         break;
 863       }
 864       case 0x7:
 865       {
 866         if((insn.bits & 0xffc0001f) == 0xf1c00000)
 867         {
 868           #include "insns/synci.h"
 869           break;
 870         }
 871         #include "insns/unimp.h"
 872       }
 873       default:
 874       {
 875         #include "insns/unimp.h"
 876       }
 877     }
 878     break;
 879   }
 880   case 0x79:
 881   {
 882     switch((insn.bits >> 0x16) & 0x7)
 883     {
 884       case 0x0:
 885       {
 886         #include "insns/sb.h"
 887         break;
 888       }
 889       case 0x1:
 890       {
 891         #include "insns/sh.h"
 892         break;
 893       }
 894       case 0x2:
 895       {
 896         #include "insns/sw.h"
 897         break;
 898       }
 899       case 0x3:
 900       {
 901         #include "insns/sd.h"
 902         break;
 903       }
 904       default:
 905       {
 906         #include "insns/unimp.h"
 907       }
 908     }
 909     break;
 910   }
 911   case 0x7a:
 912   {
 913     switch((insn.bits >> 0x16) & 0x7)
 914     {
 915       case 0x2:
 916       {
 917         if((insn.bits & 0xffff8000) == 0xf4828000)
 918         {
 919           #include "insns/amow_max.h"
 920           break;
 921         }
 922         if((insn.bits & 0xffff8000) == 0xf4810000)
 923         {
 924           #include "insns/amow_and.h"
 925           break;
 926         }
 927         if((insn.bits & 0xffff8000) == 0xf4820000)
 928         {
 929           #include "insns/amow_min.h"
 930           break;
 931         }
 932         if((insn.bits & 0xffff8000) == 0xf4818000)
 933         {
 934           #include "insns/amow_or.h"
 935           break;
 936         }
 937         if((insn.bits & 0xffff8000) == 0xf4830000)
 938         {
 939           #include "insns/amow_minu.h"
 940           break;
 941         }
 942         if((insn.bits & 0xffff8000) == 0xf4800000)
 943         {
 944           #include "insns/amow_add.h"
 945           break;
 946         }
 947         if((insn.bits & 0xffff8000) == 0xf4808000)
 948         {
 949           #include "insns/amow_swap.h"
 950           break;
 951         }
 952         if((insn.bits & 0xffff8000) == 0xf4838000)
 953         {
 954           #include "insns/amow_maxu.h"
 955           break;
 956         }
 957         #include "insns/unimp.h"
 958       }
 959       case 0x3:
 960       {
 961         if((insn.bits & 0xffff8000) == 0xf4c00000)
 962         {
 963           #include "insns/amo_add.h"
 964           break;
 965         }
 966         if((insn.bits & 0xffff8000) == 0xf4c08000)
 967         {
 968           #include "insns/amo_swap.h"
 969           break;
 970         }
 971         if((insn.bits & 0xffff8000) == 0xf4c18000)
 972         {
 973           #include "insns/amo_or.h"
 974           break;
 975         }
 976         if((insn.bits & 0xffff8000) == 0xf4c28000)
 977         {
 978           #include "insns/amo_max.h"
 979           break;
 980         }
 981         if((insn.bits & 0xffff8000) == 0xf4c20000)
 982         {
 983           #include "insns/amo_min.h"
 984           break;
 985         }
 986         if((insn.bits & 0xffff8000) == 0xf4c30000)
 987         {
 988           #include "insns/amo_minu.h"
 989           break;
 990         }
 991         if((insn.bits & 0xffff8000) == 0xf4c10000)
 992         {
 993           #include "insns/amo_and.h"
 994           break;
 995         }
 996         if((insn.bits & 0xffff8000) == 0xf4c38000)
 997         {
 998           #include "insns/amo_maxu.h"
 999           break;
1000         }
1001         #include "insns/unimp.h"
1002       }
1003       default:
1004       {
1005         #include "insns/unimp.h"
1006       }
1007     }
1008     break;
1009   }
1010   case 0x7b:
1011   {
1012     switch((insn.bits >> 0x16) & 0x7)
1013     {
1014       case 0x0:
1015       {
1016         if((insn.bits & 0xffffffe0) == 0xf6000000)
1017         {
1018           #include "insns/rdnpc.h"
1019           break;
1020         }
1021         #include "insns/unimp.h"
1022       }
1023       case 0x1:
1024       {
1025         if((insn.bits & 0xffff83e0) == 0xf6400000)
1026         {
1027           #include "insns/mfcr.h"
1028           break;
1029         }
1030         if((insn.bits & 0xffff801f) == 0xf6408000)
1031         {
1032           #include "insns/mtcr.h"
1033           break;
1034         }
1035         #include "insns/unimp.h"
1036       }
1037       case 0x2:
1038       {
1039         if((insn.bits & 0xffffffff) == 0xf6800000)
1040         {
1041           #include "insns/sync.h"
1042           break;
1043         }
1044         #include "insns/unimp.h"
1045       }
1046       case 0x3:
1047       {
1048         if((insn.bits & 0xffc003ff) == 0xf6c00000)
1049         {
1050           #include "insns/syscall.h"
1051           break;
1052         }
1053         #include "insns/unimp.h"
1054       }
1055       default:
1056       {
1057         #include "insns/unimp.h"
1058       }
1059     }
1060     break;
1061   }
1062   default:
1063   {
1064     #include "insns/unimp.h"
1065   }
1066 }