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