riscv/execute.h

   1 /* Automatically generated by parse-opcodes */
   2 switch((insn.bits >> 0x19) & 0x7f)
   3 {
   4   case 0x0:
   5   {
   6     switch((insn.bits >> 0xc) & 0x7)
   7     {
   8       case 0x0:
   9       {
  10         if((insn.bits & 0xffffffff) == 0x0)
  11         {
  12           #include "insns/unimp.h"
  13           break;
  14         }
  15         #include "insns/unimp.h"
  16       }
  17       default:
  18       {
  19         #include "insns/unimp.h"
  20       }
  21     }
  22     break;
  23   }
  24   case 0x60:
  25   {
  26     #include "insns/j.h"
  27     break;
  28   }
  29   case 0x61:
  30   {
  31     #include "insns/j.h"
  32     break;
  33   }
  34   case 0x62:
  35   {
  36     #include "insns/j.h"
  37     break;
  38   }
  39   case 0x63:
  40   {
  41     #include "insns/j.h"
  42     break;
  43   }
  44   case 0x64:
  45   {
  46     #include "insns/jal.h"
  47     break;
  48   }
  49   case 0x65:
  50   {
  51     #include "insns/jal.h"
  52     break;
  53   }
  54   case 0x66:
  55   {
  56     #include "insns/jal.h"
  57     break;
  58   }
  59   case 0x67:
  60   {
  61     #include "insns/jal.h"
  62     break;
  63   }
  64   case 0x68:
  65   {
  66     switch((insn.bits >> 0xc) & 0x7)
  67     {
  68       case 0x0:
  69       {
  70         if((insn.bits & 0xfe007fe0) == 0xd0000ca0)
  71         {
  72           #include "insns/sgninj_d.h"
  73           break;
  74         }
  75         if((insn.bits & 0xfe007fe0) == 0xd00000a0)
  76         {
  77           #include "insns/sgninj_s.h"
  78           break;
  79         }
  80         if((insn.bits & 0xfe007fe0) == 0xd0000000)
  81         {
  82           #include "insns/add_s.h"
  83           break;
  84         }
  85         if((insn.bits & 0xfe007fe0) == 0xd0000c00)
  86         {
  87           #include "insns/add_d.h"
  88           break;
  89         }
  90         if((insn.bits & 0xfe007fe0) == 0xd0000ce0)
  91         {
  92           #include "insns/sgnmul_d.h"
  93           break;
  94         }
  95         if((insn.bits & 0xfe007fe0) == 0xd0000cc0)
  96         {
  97           #include "insns/sgninjn_d.h"
  98           break;
  99         }
 100         if((insn.bits & 0xfe007fe0) == 0xd00000c0)
 101         {
 102           #include "insns/sgninjn_s.h"
 103           break;
 104         }
 105         if((insn.bits & 0xfe007fe0) == 0xd0000c40)
 106         {
 107           #include "insns/mul_d.h"
 108           break;
 109         }
 110         if((insn.bits & 0xfe007fe0) == 0xd0000020)
 111         {
 112           #include "insns/sub_s.h"
 113           break;
 114         }
 115         if((insn.bits & 0xfe007fe0) == 0xd0000c20)
 116         {
 117           #include "insns/sub_d.h"
 118           break;
 119         }
 120         if((insn.bits & 0xfe0fffe0) == 0xd0000080)
 121         {
 122           #include "insns/sqrt_s.h"
 123           break;
 124         }
 125         if((insn.bits & 0xfe0fffe0) == 0xd0000c80)
 126         {
 127           #include "insns/sqrt_d.h"
 128           break;
 129         }
 130         if((insn.bits & 0xfe007fe0) == 0xd00000e0)
 131         {
 132           #include "insns/sgnmul_s.h"
 133           break;
 134         }
 135         if((insn.bits & 0xfe007fe0) == 0xd0000c60)
 136         {
 137           #include "insns/div_d.h"
 138           break;
 139         }
 140         if((insn.bits & 0xfe007fe0) == 0xd0000060)
 141         {
 142           #include "insns/div_s.h"
 143           break;
 144         }
 145         if((insn.bits & 0xfe007fe0) == 0xd0000040)
 146         {
 147           #include "insns/mul_s.h"
 148           break;
 149         }
 150         #include "insns/unimp.h"
 151       }
 152       case 0x1:
 153       {
 154         if((insn.bits & 0xfe0fffe0) == 0xd00010c0)
 155         {
 156           #include "insns/cvt_s_w.h"
 157           break;
 158         }
 159         if((insn.bits & 0xfe0fffe0) == 0xd0001ca0)
 160         {
 161           #include "insns/cvtu_d_l.h"
 162           break;
 163         }
 164         if((insn.bits & 0xfe0fffe0) == 0xd0001c40)
 165         {
 166           #include "insns/trunc_w_d.h"
 167           break;
 168         }
 169         if((insn.bits & 0xfe0fffe0) == 0xd0001040)
 170         {
 171           #include "insns/trunc_w_s.h"
 172           break;
 173         }
 174         if((insn.bits & 0xfe0fffe0) == 0xd0001ce0)
 175         {
 176           #include "insns/cvtu_d_w.h"
 177           break;
 178         }
 179         if((insn.bits & 0xfe0fffe0) == 0xd0001e00)
 180         {
 181           #include "insns/cvt_d_s.h"
 182           break;
 183         }
 184         if((insn.bits & 0xfe0fffe0) == 0xd0001000)
 185         {
 186           #include "insns/trunc_l_s.h"
 187           break;
 188         }
 189         if((insn.bits & 0xfe0fffe0) == 0xd0001c00)
 190         {
 191           #include "insns/trunc_l_d.h"
 192           break;
 193         }
 194         if((insn.bits & 0xfe0fffe0) == 0xd00010e0)
 195         {
 196           #include "insns/cvtu_s_w.h"
 197           break;
 198         }
 199         if((insn.bits & 0xfe0fffe0) == 0xd0001020)
 200         {
 201           #include "insns/truncu_l_s.h"
 202           break;
 203         }
 204         if((insn.bits & 0xfe0fffe0) == 0xd0001c20)
 205         {
 206           #include "insns/truncu_l_d.h"
 207           break;
 208         }
 209         if((insn.bits & 0xfe0fffe0) == 0xd00010a0)
 210         {
 211           #include "insns/cvtu_s_l.h"
 212           break;
 213         }
 214         if((insn.bits & 0xfe0fffe0) == 0xd0001080)
 215         {
 216           #include "insns/cvt_s_l.h"
 217           break;
 218         }
 219         if((insn.bits & 0xfe0fffe0) == 0xd0001260)
 220         {
 221           #include "insns/cvt_s_d.h"
 222           break;
 223         }
 224         if((insn.bits & 0xfe0fffe0) == 0xd0001060)
 225         {
 226           #include "insns/truncu_w_s.h"
 227           break;
 228         }
 229         if((insn.bits & 0xfe0fffe0) == 0xd0001cc0)
 230         {
 231           #include "insns/cvt_d_w.h"
 232           break;
 233         }
 234         if((insn.bits & 0xfe0fffe0) == 0xd0001c80)
 235         {
 236           #include "insns/cvt_d_l.h"
 237           break;
 238         }
 239         if((insn.bits & 0xfe0fffe0) == 0xd0001c60)
 240         {
 241           #include "insns/truncu_w_d.h"
 242           break;
 243         }
 244         #include "insns/unimp.h"
 245       }
 246       case 0x2:
 247       {
 248         if((insn.bits & 0xfe007fe0) == 0xd0002c20)
 249         {
 250           #include "insns/c_eq_d.h"
 251           break;
 252         }
 253         if((insn.bits & 0xfe007fe0) == 0xd0002020)
 254         {
 255           #include "insns/c_eq_s.h"
 256           break;
 257         }
 258         if((insn.bits & 0xfe007fe0) == 0xd0002c60)
 259         {
 260           #include "insns/c_le_d.h"
 261           break;
 262         }
 263         if((insn.bits & 0xfe007fe0) == 0xd0002040)
 264         {
 265           #include "insns/c_lt_s.h"
 266           break;
 267         }
 268         if((insn.bits & 0xfe007fe0) == 0xd0002060)
 269         {
 270           #include "insns/c_le_s.h"
 271           break;
 272         }
 273         if((insn.bits & 0xfe007fe0) == 0xd0002c40)
 274         {
 275           #include "insns/c_lt_d.h"
 276           break;
 277         }
 278         #include "insns/unimp.h"
 279       }
 280       default:
 281       {
 282         #include "insns/unimp.h"
 283       }
 284     }
 285     break;
 286   }
 287   case 0x6a:
 288   {
 289     switch((insn.bits >> 0xc) & 0x7)
 290     {
 291       case 0x0:
 292       {
 293         if((insn.bits & 0xfe007fff) == 0xd4000000)
 294         {
 295           #include "insns/mff_s.h"
 296           break;
 297         }
 298         #include "insns/unimp.h"
 299       }
 300       case 0x1:
 301       {
 302         if((insn.bits & 0xfe007fff) == 0xd4001000)
 303         {
 304           #include "insns/mff_d.h"
 305           break;
 306         }
 307         #include "insns/unimp.h"
 308       }
 309       case 0x4:
 310       {
 311         if((insn.bits & 0xfe007fff) == 0xd4004000)
 312         {
 313           #include "insns/mtf_s.h"
 314           break;
 315         }
 316         #include "insns/unimp.h"
 317       }
 318       case 0x5:
 319       {
 320         if((insn.bits & 0xfe007fff) == 0xd4005000)
 321         {
 322           #include "insns/mtf_d.h"
 323           break;
 324         }
 325         #include "insns/unimp.h"
 326       }
 327       default:
 328       {
 329         #include "insns/unimp.h"
 330       }
 331     }
 332     break;
 333   }
 334   case 0x71:
 335   {
 336     #include "insns/lui.h"
 337     break;
 338   }
 339   case 0x72:
 340   {
 341     #include "insns/slori.h"
 342     break;
 343   }
 344   case 0x73:
 345   {
 346     switch((insn.bits >> 0xc) & 0x7)
 347     {
 348       case 0x0:
 349       {
 350         #include "insns/beq.h"
 351         break;
 352       }
 353       case 0x1:
 354       {
 355         #include "insns/bne.h"
 356         break;
 357       }
 358       case 0x2:
 359       {
 360         #include "insns/blt.h"
 361         break;
 362       }
 363       case 0x3:
 364       {
 365         #include "insns/bltu.h"
 366         break;
 367       }
 368       case 0x4:
 369       {
 370         #include "insns/ble.h"
 371         break;
 372       }
 373       case 0x5:
 374       {
 375         #include "insns/bleu.h"
 376         break;
 377       }
 378       default:
 379       {
 380         #include "insns/unimp.h"
 381       }
 382     }
 383     break;
 384   }
 385   case 0x74:
 386   {
 387     switch((insn.bits >> 0xc) & 0x7)
 388     {
 389       case 0x0:
 390       {
 391         #include "insns/addi.h"
 392         break;
 393       }
 394       case 0x1:
 395       {
 396         #include "insns/addiw.h"
 397         break;
 398       }
 399       case 0x2:
 400       {
 401         #include "insns/slti.h"
 402         break;
 403       }
 404       case 0x3:
 405       {
 406         #include "insns/sltiu.h"
 407         break;
 408       }
 409       case 0x4:
 410       {
 411         #include "insns/andi.h"
 412         break;
 413       }
 414       case 0x5:
 415       {
 416         #include "insns/ori.h"
 417         break;
 418       }
 419       case 0x6:
 420       {
 421         #include "insns/xori.h"
 422         break;
 423       }
 424       default:
 425       {
 426         #include "insns/unimp.h"
 427       }
 428     }
 429     break;
 430   }
 431   case 0x75:
 432   {
 433     switch((insn.bits >> 0xc) & 0x7)
 434     {
 435       case 0x0:
 436       {
 437         if((insn.bits & 0xfe007fe0) == 0xea0000e0)
 438         {
 439           #include "insns/nor.h"
 440           break;
 441         }
 442         if((insn.bits & 0xfe007fe0) == 0xea000060)
 443         {
 444           #include "insns/sltu.h"
 445           break;
 446         }
 447         if((insn.bits & 0xfe007fe0) == 0xea0000c0)
 448         {
 449           #include "insns/xor.h"
 450           break;
 451         }
 452         if((insn.bits & 0xfe007fe0) == 0xea000020)
 453         {
 454           #include "insns/sub.h"
 455           break;
 456         }
 457         if((insn.bits & 0xfe007fe0) == 0xea0000a0)
 458         {
 459           #include "insns/or.h"
 460           break;
 461         }
 462         if((insn.bits & 0xfe007fe0) == 0xea000000)
 463         {
 464           #include "insns/add.h"
 465           break;
 466         }
 467         if((insn.bits & 0xfe007fe0) == 0xea000040)
 468         {
 469           #include "insns/slt.h"
 470           break;
 471         }
 472         if((insn.bits & 0xfe007fe0) == 0xea000080)
 473         {
 474           #include "insns/and.h"
 475           break;
 476         }
 477         #include "insns/unimp.h"
 478       }
 479       case 0x1:
 480       {
 481         if((insn.bits & 0xfe007fe0) == 0xea001000)
 482         {
 483           #include "insns/mul.h"
 484           break;
 485         }
 486         if((insn.bits & 0xfe007fe0) == 0xea001080)
 487         {
 488           #include "insns/div.h"
 489           break;
 490         }
 491         if((insn.bits & 0xfe007fe0) == 0xea0010c0)
 492         {
 493           #include "insns/rem.h"
 494           break;
 495         }
 496         if((insn.bits & 0xfe007fe0) == 0xea001040)
 497         {
 498           #include "insns/mulh.h"
 499           break;
 500         }
 501         if((insn.bits & 0xfe007fe0) == 0xea0010e0)
 502         {
 503           #include "insns/remu.h"
 504           break;
 505         }
 506         if((insn.bits & 0xfe007fe0) == 0xea001060)
 507         {
 508           #include "insns/mulhu.h"
 509           break;
 510         }
 511         if((insn.bits & 0xfe007fe0) == 0xea0010a0)
 512         {
 513           #include "insns/divu.h"
 514           break;
 515         }
 516         #include "insns/unimp.h"
 517       }
 518       case 0x4:
 519       {
 520         if((insn.bits & 0xfe007fe0) == 0xea004040)
 521         {
 522           #include "insns/srlv.h"
 523           break;
 524         }
 525         if((insn.bits & 0xfe007fe0) == 0xea004060)
 526         {
 527           #include "insns/srav.h"
 528           break;
 529         }
 530         if((insn.bits & 0xfe007fe0) == 0xea004020)
 531         {
 532           #include "insns/sllv.h"
 533           break;
 534         }
 535         #include "insns/unimp.h"
 536       }
 537       case 0x5:
 538       {
 539         if((insn.bits & 0xfff07800) == 0xea005000)
 540         {
 541           #include "insns/sll.h"
 542           break;
 543         }
 544         #include "insns/unimp.h"
 545       }
 546       case 0x6:
 547       {
 548         if((insn.bits & 0xfff07800) == 0xea006000)
 549         {
 550           #include "insns/srl.h"
 551           break;
 552         }
 553         #include "insns/unimp.h"
 554       }
 555       case 0x7:
 556       {
 557         if((insn.bits & 0xfff07800) == 0xea007000)
 558         {
 559           #include "insns/sra.h"
 560           break;
 561         }
 562         #include "insns/unimp.h"
 563       }
 564       default:
 565       {
 566         #include "insns/unimp.h"
 567       }
 568     }
 569     break;
 570   }
 571   case 0x76:
 572   {
 573     switch((insn.bits >> 0xc) & 0x7)
 574     {
 575       case 0x0:
 576       {
 577         if((insn.bits & 0xfe007fe0) == 0xec000000)
 578         {
 579           #include "insns/addw.h"
 580           break;
 581         }
 582         if((insn.bits & 0xfe007fe0) == 0xec000020)
 583         {
 584           #include "insns/subw.h"
 585           break;
 586         }
 587         #include "insns/unimp.h"
 588       }
 589       case 0x1:
 590       {
 591         if((insn.bits & 0xfe007fe0) == 0xec0010e0)
 592         {
 593           #include "insns/remuw.h"
 594           break;
 595         }
 596         if((insn.bits & 0xfe007fe0) == 0xec0010a0)
 597         {
 598           #include "insns/divuw.h"
 599           break;
 600         }
 601         if((insn.bits & 0xfe007fe0) == 0xec001060)
 602         {
 603           #include "insns/mulhuw.h"
 604           break;
 605         }
 606         if((insn.bits & 0xfe007fe0) == 0xec001000)
 607         {
 608           #include "insns/mulw.h"
 609           break;
 610         }
 611         if((insn.bits & 0xfe007fe0) == 0xec0010c0)
 612         {
 613           #include "insns/remw.h"
 614           break;
 615         }
 616         if((insn.bits & 0xfe007fe0) == 0xec001040)
 617         {
 618           #include "insns/mulhw.h"
 619           break;
 620         }
 621         if((insn.bits & 0xfe007fe0) == 0xec001080)
 622         {
 623           #include "insns/divw.h"
 624           break;
 625         }
 626         #include "insns/unimp.h"
 627       }
 628       case 0x4:
 629       {
 630         if((insn.bits & 0xfe007fe0) == 0xec004060)
 631         {
 632           #include "insns/sravw.h"
 633           break;
 634         }
 635         if((insn.bits & 0xfe007fe0) == 0xec004020)
 636         {
 637           #include "insns/sllvw.h"
 638           break;
 639         }
 640         if((insn.bits & 0xfe007fe0) == 0xec004040)
 641         {
 642           #include "insns/srlvw.h"
 643           break;
 644         }
 645         #include "insns/unimp.h"
 646       }
 647       case 0x5:
 648       {
 649         if((insn.bits & 0xfff07c00) == 0xec005000)
 650         {
 651           #include "insns/sllw.h"
 652           break;
 653         }
 654         #include "insns/unimp.h"
 655       }
 656       case 0x6:
 657       {
 658         if((insn.bits & 0xfff07c00) == 0xec006000)
 659         {
 660           #include "insns/srlw.h"
 661           break;
 662         }
 663         #include "insns/unimp.h"
 664       }
 665       case 0x7:
 666       {
 667         if((insn.bits & 0xfff07c00) == 0xec007000)
 668         {
 669           #include "insns/sraw.h"
 670           break;
 671         }
 672         #include "insns/unimp.h"
 673       }
 674       default:
 675       {
 676         #include "insns/unimp.h"
 677       }
 678     }
 679     break;
 680   }
 681   case 0x78:
 682   {
 683     switch((insn.bits >> 0xc) & 0x7)
 684     {
 685       case 0x0:
 686       {
 687         #include "insns/lb.h"
 688         break;
 689       }
 690       case 0x1:
 691       {
 692         #include "insns/lh.h"
 693         break;
 694       }
 695       case 0x2:
 696       {
 697         #include "insns/lw.h"
 698         break;
 699       }
 700       case 0x3:
 701       {
 702         #include "insns/ld.h"
 703         break;
 704       }
 705       case 0x4:
 706       {
 707         #include "insns/lbu.h"
 708         break;
 709       }
 710       case 0x5:
 711       {
 712         #include "insns/lhu.h"
 713         break;
 714       }
 715       case 0x6:
 716       {
 717         #include "insns/lwu.h"
 718         break;
 719       }
 720       case 0x7:
 721       {
 722         if((insn.bits & 0xfff07000) == 0xf0007000)
 723         {
 724           #include "insns/synci.h"
 725           break;
 726         }
 727         #include "insns/unimp.h"
 728       }
 729       default:
 730       {
 731         #include "insns/unimp.h"
 732       }
 733     }
 734     break;
 735   }
 736   case 0x79:
 737   {
 738     switch((insn.bits >> 0xc) & 0x7)
 739     {
 740       case 0x0:
 741       {
 742         #include "insns/sb.h"
 743         break;
 744       }
 745       case 0x1:
 746       {
 747         #include "insns/sh.h"
 748         break;
 749       }
 750       case 0x2:
 751       {
 752         #include "insns/sw.h"
 753         break;
 754       }
 755       case 0x3:
 756       {
 757         #include "insns/sd.h"
 758         break;
 759       }
 760       case 0x4:
 761       {
 762         #include "insns/l_s.h"
 763         break;
 764       }
 765       case 0x5:
 766       {
 767         #include "insns/l_d.h"
 768         break;
 769       }
 770       case 0x6:
 771       {
 772         #include "insns/s_s.h"
 773         break;
 774       }
 775       case 0x7:
 776       {
 777         #include "insns/s_d.h"
 778         break;
 779       }
 780       default:
 781       {
 782         #include "insns/unimp.h"
 783       }
 784     }
 785     break;
 786   }
 787   case 0x7b:
 788   {
 789     switch((insn.bits >> 0xc) & 0x7)
 790     {
 791       case 0x0:
 792       {
 793         if((insn.bits & 0xfe0fffe0) == 0xf6000000)
 794         {
 795           #include "insns/jalr_c.h"
 796           break;
 797         }
 798         if((insn.bits & 0xfe0fffe0) == 0xf6000040)
 799         {
 800           #include "insns/jalr_j.h"
 801           break;
 802         }
 803         if((insn.bits & 0xfe0fffe0) == 0xf6000020)
 804         {
 805           #include "insns/jalr_r.h"
 806           break;
 807         }
 808         #include "insns/unimp.h"
 809       }
 810       case 0x1:
 811       {
 812         if((insn.bits & 0xffffffe0) == 0xf6001000)
 813         {
 814           #include "insns/rdpc.h"
 815           break;
 816         }
 817         #include "insns/unimp.h"
 818       }
 819       case 0x2:
 820       {
 821         if((insn.bits & 0xfe0fffe0) == 0xf6002000)
 822         {
 823           #include "insns/rdhwr.h"
 824           break;
 825         }
 826         #include "insns/unimp.h"
 827       }
 828       case 0x3:
 829       {
 830         if((insn.bits & 0xffffffff) == 0xf6003000)
 831         {
 832           #include "insns/sync.h"
 833           break;
 834         }
 835         #include "insns/unimp.h"
 836       }
 837       case 0x4:
 838       {
 839         if((insn.bits & 0xffffffff) == 0xf6004000)
 840         {
 841           #include "insns/syscall.h"
 842           break;
 843         }
 844         #include "insns/unimp.h"
 845       }
 846       case 0x5:
 847       {
 848         if((insn.bits & 0xffffffff) == 0xf6005000)
 849         {
 850           #include "insns/break.h"
 851           break;
 852         }
 853         #include "insns/unimp.h"
 854       }
 855       default:
 856       {
 857         #include "insns/unimp.h"
 858       }
 859     }
 860     break;
 861   }
 862   case 0x7e:
 863   {
 864     switch((insn.bits >> 0xc) & 0x7)
 865     {
 866       case 0x0:
 867       {
 868         if((insn.bits & 0xfe0fffff) == 0xfc000000)
 869         {
 870           #include "insns/ei.h"
 871           break;
 872         }
 873         #include "insns/unimp.h"
 874       }
 875       case 0x1:
 876       {
 877         if((insn.bits & 0xfe0fffff) == 0xfc001000)
 878         {
 879           #include "insns/di.h"
 880           break;
 881         }
 882         #include "insns/unimp.h"
 883       }
 884       case 0x2:
 885       {
 886         if((insn.bits & 0xffffffff) == 0xfc002000)
 887         {
 888           #include "insns/eret.h"
 889           break;
 890         }
 891         #include "insns/unimp.h"
 892       }
 893       case 0x4:
 894       {
 895         if((insn.bits & 0xfe007fff) == 0xfc004000)
 896         {
 897           #include "insns/mfpcr.h"
 898           break;
 899         }
 900         #include "insns/unimp.h"
 901       }
 902       case 0x5:
 903       {
 904         if((insn.bits & 0xfe007fff) == 0xfc005000)
 905         {
 906           #include "insns/mwfpcr.h"
 907           break;
 908         }
 909         #include "insns/unimp.h"
 910       }
 911       case 0x6:
 912       {
 913         if((insn.bits & 0xfe007fff) == 0xfc006000)
 914         {
 915           #include "insns/mtpcr.h"
 916           break;
 917         }
 918         #include "insns/unimp.h"
 919       }
 920       case 0x7:
 921       {
 922         if((insn.bits & 0xfe007fff) == 0xfc007000)
 923         {
 924           #include "insns/mwtpcr.h"
 925           break;
 926         }
 927         #include "insns/unimp.h"
 928       }
 929       default:
 930       {
 931         #include "insns/unimp.h"
 932       }
 933     }
 934     break;
 935   }
 936   default:
 937   {
 938     #include "insns/unimp.h"
 939   }
 940 }