riscv/dispatch_9.cc

   1 #include "insn_includes.h"
   2
   3 reg_t processor_t::opcode_func_009(insn_t insn, reg_t pc)
   4 {
   5     reg_t npc = pc + insn_length(0x00000009);
   6     #include "insns/c_ld.h"
   7     return npc;
   8 }
   9
  10 reg_t processor_t::opcode_func_013(insn_t insn, reg_t pc)
  11 {
  12     reg_t npc = pc + insn_length(0x00000013);
  13     #include "insns/addi.h"
  14     return npc;
  15 }
  16
  17 reg_t processor_t::opcode_func_01d(insn_t insn, reg_t pc)
  18 {
  19     reg_t npc = pc + insn_length(0x0000001d);
  20     #include "insns/c_addiw.h"
  21     return npc;
  22 }
  23
  24 reg_t processor_t::opcode_func_027(insn_t insn, reg_t pc)
  25 {
  26   throw trap_illegal_instruction;
  27 }
  28
  29 reg_t processor_t::opcode_func_031(insn_t insn, reg_t pc)
  30 {
  31     reg_t npc = pc + insn_length(0x00000011);
  32     #include "insns/c_bne.h"
  33     return npc;
  34 }
  35
  36 reg_t processor_t::opcode_func_03b(insn_t insn, reg_t pc)
  37 {
  38   if((insn.bits & 0x1ffff) == 0x43b)
  39   {
  40     reg_t npc = pc + insn_length(0x0000043b);
  41     #include "insns/mulw.h"
  42     return npc;
  43   }
  44   if((insn.bits & 0x1ffff) == 0x3b)
  45   {
  46     reg_t npc = pc + insn_length(0x0000003b);
  47     #include "insns/addw.h"
  48     return npc;
  49   }
  50   if((insn.bits & 0x1ffff) == 0x1003b)
  51   {
  52     reg_t npc = pc + insn_length(0x0001003b);
  53     #include "insns/subw.h"
  54     return npc;
  55   }
  56   throw trap_illegal_instruction;
  57 }
  58
  59 reg_t processor_t::opcode_func_045(insn_t insn, reg_t pc)
  60 {
  61     reg_t npc = pc + insn_length(0x00000005);
  62     #include "insns/c_lwsp.h"
  63     return npc;
  64 }
  65
  66 reg_t processor_t::opcode_func_04f(insn_t insn, reg_t pc)
  67 {
  68     reg_t npc = pc + insn_length(0x0000004f);
  69     #include "insns/fnmadd_s.h"
  70     return npc;
  71 }
  72
  73 reg_t processor_t::opcode_func_059(insn_t insn, reg_t pc)
  74 {
  75   if((insn.bits & 0x1c1f) == 0x19)
  76   {
  77     reg_t npc = pc + insn_length(0x00000019);
  78     #include "insns/c_slli.h"
  79     return npc;
  80   }
  81   if((insn.bits & 0x1c1f) == 0x819)
  82   {
  83     reg_t npc = pc + insn_length(0x00000819);
  84     #include "insns/c_srli.h"
  85     return npc;
  86   }
  87   if((insn.bits & 0x1c1f) == 0x1419)
  88   {
  89     reg_t npc = pc + insn_length(0x00001419);
  90     #include "insns/c_srai32.h"
  91     return npc;
  92   }
  93   if((insn.bits & 0x1c1f) == 0x1819)
  94   {
  95     reg_t npc = pc + insn_length(0x00001819);
  96     #include "insns/c_slliw.h"
  97     return npc;
  98   }
  99   if((insn.bits & 0x1c1f) == 0xc19)
 100   {
 101     reg_t npc = pc + insn_length(0x00000c19);
 102     #include "insns/c_srli32.h"
 103     return npc;
 104   }
 105   if((insn.bits & 0x1c1f) == 0x1019)
 106   {
 107     reg_t npc = pc + insn_length(0x00001019);
 108     #include "insns/c_srai.h"
 109     return npc;
 110   }
 111   if((insn.bits & 0x1c1f) == 0x419)
 112   {
 113     reg_t npc = pc + insn_length(0x00000419);
 114     #include "insns/c_slli32.h"
 115     return npc;
 116   }
 117   throw trap_illegal_instruction;
 118 }
 119
 120 reg_t processor_t::opcode_func_063(insn_t insn, reg_t pc)
 121 {
 122     reg_t npc = pc + insn_length(0x00000063);
 123     #include "insns/beq.h"
 124     return npc;
 125 }
 126
 127 reg_t processor_t::opcode_func_06d(insn_t insn, reg_t pc)
 128 {
 129     reg_t npc = pc + insn_length(0x0000000d);
 130     #include "insns/c_sw.h"
 131     return npc;
 132 }
 133
 134 reg_t processor_t::opcode_func_077(insn_t insn, reg_t pc)
 135 {
 136   if((insn.bits & 0xffffffff) == 0x77)
 137   {
 138     reg_t npc = pc + insn_length(0x00000077);
 139     #include "insns/syscall.h"
 140     return npc;
 141   }
 142   throw trap_illegal_instruction;
 143 }
 144
 145 reg_t processor_t::opcode_func_081(insn_t insn, reg_t pc)
 146 {
 147     reg_t npc = pc + insn_length(0x00000001);
 148     #include "insns/c_addi.h"
 149     return npc;
 150 }
 151
 152 reg_t processor_t::opcode_func_08b(insn_t insn, reg_t pc)
 153 {
 154   if((insn.bits & 0x3fffff) == 0x8b)
 155   {
 156     reg_t npc = pc + insn_length(0x0000008b);
 157     #include "insns/vlh.h"
 158     return npc;
 159   }
 160   if((insn.bits & 0x1ffff) == 0x108b)
 161   {
 162     reg_t npc = pc + insn_length(0x0000108b);
 163     #include "insns/vlsth.h"
 164     return npc;
 165   }
 166   if((insn.bits & 0xfff) == 0x88b)
 167   {
 168     reg_t npc = pc + insn_length(0x0000088b);
 169     #include "insns/vlsegsth.h"
 170     return npc;
 171   }
 172   if((insn.bits & 0x1ffff) == 0x208b)
 173   {
 174     reg_t npc = pc + insn_length(0x0000208b);
 175     #include "insns/vlsegh.h"
 176     return npc;
 177   }
 178   throw trap_illegal_instruction;
 179 }
 180
 181 reg_t processor_t::opcode_func_095(insn_t insn, reg_t pc)
 182 {
 183     reg_t npc = pc + insn_length(0x00000015);
 184     #include "insns/c_fld.h"
 185     return npc;
 186 }
 187
 188 reg_t processor_t::opcode_func_09f(insn_t insn, reg_t pc)
 189 {
 190   throw trap_illegal_instruction;
 191 }
 192
 193 reg_t processor_t::opcode_func_0a9(insn_t insn, reg_t pc)
 194 {
 195     reg_t npc = pc + insn_length(0x00000009);
 196     #include "insns/c_ld.h"
 197     return npc;
 198 }
 199
 200 reg_t processor_t::opcode_func_0b3(insn_t insn, reg_t pc)
 201 {
 202   if((insn.bits & 0x1ffff) == 0xb3)
 203   {
 204     reg_t npc = pc + insn_length(0x000000b3);
 205     #include "insns/sll.h"
 206     return npc;
 207   }
 208   if((insn.bits & 0x1ffff) == 0x4b3)
 209   {
 210     reg_t npc = pc + insn_length(0x000004b3);
 211     #include "insns/mulh.h"
 212     return npc;
 213   }
 214   throw trap_illegal_instruction;
 215 }
 216
 217 reg_t processor_t::opcode_func_0bd(insn_t insn, reg_t pc)
 218 {
 219     reg_t npc = pc + insn_length(0x0000001d);
 220     #include "insns/c_addiw.h"
 221     return npc;
 222 }
 223
 224 reg_t processor_t::opcode_func_0c7(insn_t insn, reg_t pc)
 225 {
 226     reg_t npc = pc + insn_length(0x000000c7);
 227     #include "insns/fmsub_d.h"
 228     return npc;
 229 }
 230
 231 reg_t processor_t::opcode_func_0d1(insn_t insn, reg_t pc)
 232 {
 233     reg_t npc = pc + insn_length(0x00000011);
 234     #include "insns/c_bne.h"
 235     return npc;
 236 }
 237
 238 reg_t processor_t::opcode_func_0db(insn_t insn, reg_t pc)
 239 {
 240   throw trap_illegal_instruction;
 241 }
 242
 243 reg_t processor_t::opcode_func_0e5(insn_t insn, reg_t pc)
 244 {
 245     reg_t npc = pc + insn_length(0x00000005);
 246     #include "insns/c_lwsp.h"
 247     return npc;
 248 }
 249
 250 reg_t processor_t::opcode_func_0ef(insn_t insn, reg_t pc)
 251 {
 252     reg_t npc = pc + insn_length(0x0000006f);
 253     #include "insns/jal.h"
 254     return npc;
 255 }
 256
 257 reg_t processor_t::opcode_func_0f9(insn_t insn, reg_t pc)
 258 {
 259   if((insn.bits & 0x1c1f) == 0x19)
 260   {
 261     reg_t npc = pc + insn_length(0x00000019);
 262     #include "insns/c_slli.h"
 263     return npc;
 264   }
 265   if((insn.bits & 0x1c1f) == 0x819)
 266   {
 267     reg_t npc = pc + insn_length(0x00000819);
 268     #include "insns/c_srli.h"
 269     return npc;
 270   }
 271   if((insn.bits & 0x1c1f) == 0x1419)
 272   {
 273     reg_t npc = pc + insn_length(0x00001419);
 274     #include "insns/c_srai32.h"
 275     return npc;
 276   }
 277   if((insn.bits & 0x1c1f) == 0x1819)
 278   {
 279     reg_t npc = pc + insn_length(0x00001819);
 280     #include "insns/c_slliw.h"
 281     return npc;
 282   }
 283   if((insn.bits & 0x1c1f) == 0xc19)
 284   {
 285     reg_t npc = pc + insn_length(0x00000c19);
 286     #include "insns/c_srli32.h"
 287     return npc;
 288   }
 289   if((insn.bits & 0x1c1f) == 0x1019)
 290   {
 291     reg_t npc = pc + insn_length(0x00001019);
 292     #include "insns/c_srai.h"
 293     return npc;
 294   }
 295   if((insn.bits & 0x1c1f) == 0x419)
 296   {
 297     reg_t npc = pc + insn_length(0x00000419);
 298     #include "insns/c_slli32.h"
 299     return npc;
 300   }
 301   throw trap_illegal_instruction;
 302 }
 303
 304 reg_t processor_t::opcode_func_103(insn_t insn, reg_t pc)
 305 {
 306     reg_t npc = pc + insn_length(0x00000103);
 307     #include "insns/lw.h"
 308     return npc;
 309 }
 310
 311 reg_t processor_t::opcode_func_10d(insn_t insn, reg_t pc)
 312 {
 313     reg_t npc = pc + insn_length(0x0000000d);
 314     #include "insns/c_sw.h"
 315     return npc;
 316 }
 317
 318 reg_t processor_t::opcode_func_117(insn_t insn, reg_t pc)
 319 {
 320   throw trap_illegal_instruction;
 321 }
 322
 323 reg_t processor_t::opcode_func_121(insn_t insn, reg_t pc)
 324 {
 325     reg_t npc = pc + insn_length(0x00000001);
 326     #include "insns/c_addi.h"
 327     return npc;
 328 }
 329
 330 reg_t processor_t::opcode_func_12b(insn_t insn, reg_t pc)
 331 {
 332   if((insn.bits & 0x1ffff) == 0x192b)
 333   {
 334     reg_t npc = pc + insn_length(0x0000192b);
 335     #include "insns/amominu_w.h"
 336     return npc;
 337   }
 338   if((insn.bits & 0x1ffff) == 0x92b)
 339   {
 340     reg_t npc = pc + insn_length(0x0000092b);
 341     #include "insns/amoand_w.h"
 342     return npc;
 343   }
 344   if((insn.bits & 0x1ffff) == 0x1d2b)
 345   {
 346     reg_t npc = pc + insn_length(0x00001d2b);
 347     #include "insns/amomaxu_w.h"
 348     return npc;
 349   }
 350   if((insn.bits & 0x1ffff) == 0x152b)
 351   {
 352     reg_t npc = pc + insn_length(0x0000152b);
 353     #include "insns/amomax_w.h"
 354     return npc;
 355   }
 356   if((insn.bits & 0x1ffff) == 0x12b)
 357   {
 358     reg_t npc = pc + insn_length(0x0000012b);
 359     #include "insns/amoadd_w.h"
 360     return npc;
 361   }
 362   if((insn.bits & 0x1ffff) == 0xd2b)
 363   {
 364     reg_t npc = pc + insn_length(0x00000d2b);
 365     #include "insns/amoor_w.h"
 366     return npc;
 367   }
 368   if((insn.bits & 0x1ffff) == 0x112b)
 369   {
 370     reg_t npc = pc + insn_length(0x0000112b);
 371     #include "insns/amomin_w.h"
 372     return npc;
 373   }
 374   if((insn.bits & 0x1ffff) == 0x52b)
 375   {
 376     reg_t npc = pc + insn_length(0x0000052b);
 377     #include "insns/amoswap_w.h"
 378     return npc;
 379   }
 380   throw trap_illegal_instruction;
 381 }
 382
 383 reg_t processor_t::opcode_func_135(insn_t insn, reg_t pc)
 384 {
 385     reg_t npc = pc + insn_length(0x00000015);
 386     #include "insns/c_fld.h"
 387     return npc;
 388 }
 389
 390 reg_t processor_t::opcode_func_13f(insn_t insn, reg_t pc)
 391 {
 392   throw trap_illegal_instruction;
 393 }
 394
 395 reg_t processor_t::opcode_func_149(insn_t insn, reg_t pc)
 396 {
 397     reg_t npc = pc + insn_length(0x00000009);
 398     #include "insns/c_ld.h"
 399     return npc;
 400 }
 401
 402 reg_t processor_t::opcode_func_153(insn_t insn, reg_t pc)
 403 {
 404   throw trap_illegal_instruction;
 405 }
 406
 407 reg_t processor_t::opcode_func_15d(insn_t insn, reg_t pc)
 408 {
 409     reg_t npc = pc + insn_length(0x0000001d);
 410     #include "insns/c_addiw.h"
 411     return npc;
 412 }
 413
 414 reg_t processor_t::opcode_func_167(insn_t insn, reg_t pc)
 415 {
 416     reg_t npc = pc + insn_length(0x00000067);
 417     #include "insns/j.h"
 418     return npc;
 419 }
 420
 421 reg_t processor_t::opcode_func_171(insn_t insn, reg_t pc)
 422 {
 423     reg_t npc = pc + insn_length(0x00000011);
 424     #include "insns/c_bne.h"
 425     return npc;
 426 }
 427
 428 reg_t processor_t::opcode_func_17b(insn_t insn, reg_t pc)
 429 {
 430   if((insn.bits & 0x7c1ffff) == 0x17b)
 431   {
 432     reg_t npc = pc + insn_length(0x0000017b);
 433     #include "insns/mfpcr.h"
 434     return npc;
 435   }
 436   throw trap_illegal_instruction;
 437 }
 438
 439 reg_t processor_t::opcode_func_185(insn_t insn, reg_t pc)
 440 {
 441     reg_t npc = pc + insn_length(0x00000005);
 442     #include "insns/c_lwsp.h"
 443     return npc;
 444 }
 445
 446 reg_t processor_t::opcode_func_18f(insn_t insn, reg_t pc)
 447 {
 448   if((insn.bits & 0xfff) == 0x98f)
 449   {
 450     reg_t npc = pc + insn_length(0x0000098f);
 451     #include "insns/vssegstd.h"
 452     return npc;
 453   }
 454   if((insn.bits & 0xfff) == 0xd8f)
 455   {
 456     reg_t npc = pc + insn_length(0x00000d8f);
 457     #include "insns/vfssegstd.h"
 458     return npc;
 459   }
 460   if((insn.bits & 0x1ffff) == 0x118f)
 461   {
 462     reg_t npc = pc + insn_length(0x0000118f);
 463     #include "insns/vsstd.h"
 464     return npc;
 465   }
 466   if((insn.bits & 0x1ffff) == 0x218f)
 467   {
 468     reg_t npc = pc + insn_length(0x0000218f);
 469     #include "insns/vssegd.h"
 470     return npc;
 471   }
 472   if((insn.bits & 0x1ffff) == 0x158f)
 473   {
 474     reg_t npc = pc + insn_length(0x0000158f);
 475     #include "insns/vfsstd.h"
 476     return npc;
 477   }
 478   if((insn.bits & 0x3fffff) == 0x18f)
 479   {
 480     reg_t npc = pc + insn_length(0x0000018f);
 481     #include "insns/vsd.h"
 482     return npc;
 483   }
 484   if((insn.bits & 0x3fffff) == 0x58f)
 485   {
 486     reg_t npc = pc + insn_length(0x0000058f);
 487     #include "insns/vfsd.h"
 488     return npc;
 489   }
 490   if((insn.bits & 0x1ffff) == 0x258f)
 491   {
 492     reg_t npc = pc + insn_length(0x0000258f);
 493     #include "insns/vfssegd.h"
 494     return npc;
 495   }
 496   throw trap_illegal_instruction;
 497 }
 498
 499 reg_t processor_t::opcode_func_199(insn_t insn, reg_t pc)
 500 {
 501   if((insn.bits & 0x1c1f) == 0x19)
 502   {
 503     reg_t npc = pc + insn_length(0x00000019);
 504     #include "insns/c_slli.h"
 505     return npc;
 506   }
 507   if((insn.bits & 0x1c1f) == 0x819)
 508   {
 509     reg_t npc = pc + insn_length(0x00000819);
 510     #include "insns/c_srli.h"
 511     return npc;
 512   }
 513   if((insn.bits & 0x1c1f) == 0x1419)
 514   {
 515     reg_t npc = pc + insn_length(0x00001419);
 516     #include "insns/c_srai32.h"
 517     return npc;
 518   }
 519   if((insn.bits & 0x1c1f) == 0x1819)
 520   {
 521     reg_t npc = pc + insn_length(0x00001819);
 522     #include "insns/c_slliw.h"
 523     return npc;
 524   }
 525   if((insn.bits & 0x1c1f) == 0xc19)
 526   {
 527     reg_t npc = pc + insn_length(0x00000c19);
 528     #include "insns/c_srli32.h"
 529     return npc;
 530   }
 531   if((insn.bits & 0x1c1f) == 0x1019)
 532   {
 533     reg_t npc = pc + insn_length(0x00001019);
 534     #include "insns/c_srai.h"
 535     return npc;
 536   }
 537   if((insn.bits & 0x1c1f) == 0x419)
 538   {
 539     reg_t npc = pc + insn_length(0x00000419);
 540     #include "insns/c_slli32.h"
 541     return npc;
 542   }
 543   throw trap_illegal_instruction;
 544 }
 545
 546 reg_t processor_t::opcode_func_1a3(insn_t insn, reg_t pc)
 547 {
 548     reg_t npc = pc + insn_length(0x000001a3);
 549     #include "insns/sd.h"
 550     return npc;
 551 }
 552
 553 reg_t processor_t::opcode_func_1ad(insn_t insn, reg_t pc)
 554 {
 555     reg_t npc = pc + insn_length(0x0000000d);
 556     #include "insns/c_sw.h"
 557     return npc;
 558 }
 559
 560 reg_t processor_t::opcode_func_1b7(insn_t insn, reg_t pc)
 561 {
 562     reg_t npc = pc + insn_length(0x00000037);
 563     #include "insns/lui.h"
 564     return npc;
 565 }
 566
 567 reg_t processor_t::opcode_func_1c1(insn_t insn, reg_t pc)
 568 {
 569     reg_t npc = pc + insn_length(0x00000001);
 570     #include "insns/c_addi.h"
 571     return npc;
 572 }
 573
 574 reg_t processor_t::opcode_func_1cb(insn_t insn, reg_t pc)
 575 {
 576   throw trap_illegal_instruction;
 577 }
 578
 579 reg_t processor_t::opcode_func_1d5(insn_t insn, reg_t pc)
 580 {
 581     reg_t npc = pc + insn_length(0x00000015);
 582     #include "insns/c_fld.h"
 583     return npc;
 584 }
 585
 586 reg_t processor_t::opcode_func_1df(insn_t insn, reg_t pc)
 587 {
 588   throw trap_illegal_instruction;
 589 }
 590
 591 reg_t processor_t::opcode_func_1e9(insn_t insn, reg_t pc)
 592 {
 593     reg_t npc = pc + insn_length(0x00000009);
 594     #include "insns/c_ld.h"
 595     return npc;
 596 }
 597
 598 reg_t processor_t::opcode_func_1f3(insn_t insn, reg_t pc)
 599 {
 600     reg_t npc = pc + insn_length(0x000001f3);
 601     #include "insns/vtcfgivl.h"
 602     return npc;
 603 }
 604
 605 reg_t processor_t::opcode_func_1fd(insn_t insn, reg_t pc)
 606 {
 607     reg_t npc = pc + insn_length(0x0000001d);
 608     #include "insns/c_addiw.h"
 609     return npc;
 610 }
 611
 612 reg_t processor_t::opcode_func_207(insn_t insn, reg_t pc)
 613 {
 614   throw trap_illegal_instruction;
 615 }
 616
 617 reg_t processor_t::opcode_func_211(insn_t insn, reg_t pc)
 618 {
 619     reg_t npc = pc + insn_length(0x00000011);
 620     #include "insns/c_bne.h"
 621     return npc;
 622 }
 623
 624 reg_t processor_t::opcode_func_21b(insn_t insn, reg_t pc)
 625 {
 626   throw trap_illegal_instruction;
 627 }
 628
 629 reg_t processor_t::opcode_func_225(insn_t insn, reg_t pc)
 630 {
 631     reg_t npc = pc + insn_length(0x00000005);
 632     #include "insns/c_lwsp.h"
 633     return npc;
 634 }
 635
 636 reg_t processor_t::opcode_func_22f(insn_t insn, reg_t pc)
 637 {
 638     reg_t npc = pc + insn_length(0x0000022f);
 639     #include "insns/fence_l_v.h"
 640     return npc;
 641 }
 642
 643 reg_t processor_t::opcode_func_239(insn_t insn, reg_t pc)
 644 {
 645   if((insn.bits & 0x1c1f) == 0x19)
 646   {
 647     reg_t npc = pc + insn_length(0x00000019);
 648     #include "insns/c_slli.h"
 649     return npc;
 650   }
 651   if((insn.bits & 0x1c1f) == 0x819)
 652   {
 653     reg_t npc = pc + insn_length(0x00000819);
 654     #include "insns/c_srli.h"
 655     return npc;
 656   }
 657   if((insn.bits & 0x1c1f) == 0x1419)
 658   {
 659     reg_t npc = pc + insn_length(0x00001419);
 660     #include "insns/c_srai32.h"
 661     return npc;
 662   }
 663   if((insn.bits & 0x1c1f) == 0x1819)
 664   {
 665     reg_t npc = pc + insn_length(0x00001819);
 666     #include "insns/c_slliw.h"
 667     return npc;
 668   }
 669   if((insn.bits & 0x1c1f) == 0xc19)
 670   {
 671     reg_t npc = pc + insn_length(0x00000c19);
 672     #include "insns/c_srli32.h"
 673     return npc;
 674   }
 675   if((insn.bits & 0x1c1f) == 0x1019)
 676   {
 677     reg_t npc = pc + insn_length(0x00001019);
 678     #include "insns/c_srai.h"
 679     return npc;
 680   }
 681   if((insn.bits & 0x1c1f) == 0x419)
 682   {
 683     reg_t npc = pc + insn_length(0x00000419);
 684     #include "insns/c_slli32.h"
 685     return npc;
 686   }
 687   throw trap_illegal_instruction;
 688 }
 689
 690 reg_t processor_t::opcode_func_243(insn_t insn, reg_t pc)
 691 {
 692     reg_t npc = pc + insn_length(0x00000043);
 693     #include "insns/fmadd_s.h"
 694     return npc;
 695 }
 696
 697 reg_t processor_t::opcode_func_24d(insn_t insn, reg_t pc)
 698 {
 699     reg_t npc = pc + insn_length(0x0000000d);
 700     #include "insns/c_sw.h"
 701     return npc;
 702 }
 703
 704 reg_t processor_t::opcode_func_257(insn_t insn, reg_t pc)
 705 {
 706   throw trap_illegal_instruction;
 707 }
 708
 709 reg_t processor_t::opcode_func_261(insn_t insn, reg_t pc)
 710 {
 711     reg_t npc = pc + insn_length(0x00000001);
 712     #include "insns/c_addi.h"
 713     return npc;
 714 }
 715
 716 reg_t processor_t::opcode_func_26b(insn_t insn, reg_t pc)
 717 {
 718   if((insn.bits & 0x7ffffff) == 0x26b)
 719   {
 720     reg_t npc = pc + insn_length(0x0000026b);
 721     #include "insns/rdnpc.h"
 722     return npc;
 723   }
 724   throw trap_illegal_instruction;
 725 }
 726
 727 reg_t processor_t::opcode_func_275(insn_t insn, reg_t pc)
 728 {
 729     reg_t npc = pc + insn_length(0x00000015);
 730     #include "insns/c_fld.h"
 731     return npc;
 732 }
 733
 734 reg_t processor_t::opcode_func_27f(insn_t insn, reg_t pc)
 735 {
 736   throw trap_illegal_instruction;
 737 }
 738
 739 reg_t processor_t::opcode_func_289(insn_t insn, reg_t pc)
 740 {
 741     reg_t npc = pc + insn_length(0x00000009);
 742     #include "insns/c_ld.h"
 743     return npc;
 744 }
 745
 746 reg_t processor_t::opcode_func_293(insn_t insn, reg_t pc)
 747 {
 748   if((insn.bits & 0x3f03ff) == 0x293)
 749   {
 750     reg_t npc = pc + insn_length(0x00000293);
 751     #include "insns/srli.h"
 752     return npc;
 753   }
 754   if((insn.bits & 0x3f03ff) == 0x10293)
 755   {
 756     reg_t npc = pc + insn_length(0x00010293);
 757     #include "insns/srai.h"
 758     return npc;
 759   }
 760   throw trap_illegal_instruction;
 761 }
 762
 763 reg_t processor_t::opcode_func_29d(insn_t insn, reg_t pc)
 764 {
 765     reg_t npc = pc + insn_length(0x0000001d);
 766     #include "insns/c_addiw.h"
 767     return npc;
 768 }
 769
 770 reg_t processor_t::opcode_func_2a7(insn_t insn, reg_t pc)
 771 {
 772   throw trap_illegal_instruction;
 773 }
 774
 775 reg_t processor_t::opcode_func_2b1(insn_t insn, reg_t pc)
 776 {
 777     reg_t npc = pc + insn_length(0x00000011);
 778     #include "insns/c_bne.h"
 779     return npc;
 780 }
 781
 782 reg_t processor_t::opcode_func_2bb(insn_t insn, reg_t pc)
 783 {
 784   if((insn.bits & 0x1ffff) == 0x6bb)
 785   {
 786     reg_t npc = pc + insn_length(0x000006bb);
 787     #include "insns/divuw.h"
 788     return npc;
 789   }
 790   if((insn.bits & 0x1ffff) == 0x2bb)
 791   {
 792     reg_t npc = pc + insn_length(0x000002bb);
 793     #include "insns/srlw.h"
 794     return npc;
 795   }
 796   if((insn.bits & 0x1ffff) == 0x102bb)
 797   {
 798     reg_t npc = pc + insn_length(0x000102bb);
 799     #include "insns/sraw.h"
 800     return npc;
 801   }
 802   throw trap_illegal_instruction;
 803 }
 804
 805 reg_t processor_t::opcode_func_2c5(insn_t insn, reg_t pc)
 806 {
 807     reg_t npc = pc + insn_length(0x00000005);
 808     #include "insns/c_lwsp.h"
 809     return npc;
 810 }
 811
 812 reg_t processor_t::opcode_func_2cf(insn_t insn, reg_t pc)
 813 {
 814     reg_t npc = pc + insn_length(0x000000cf);
 815     #include "insns/fnmadd_d.h"
 816     return npc;
 817 }
 818
 819 reg_t processor_t::opcode_func_2d9(insn_t insn, reg_t pc)
 820 {
 821   if((insn.bits & 0x1c1f) == 0x19)
 822   {
 823     reg_t npc = pc + insn_length(0x00000019);
 824     #include "insns/c_slli.h"
 825     return npc;
 826   }
 827   if((insn.bits & 0x1c1f) == 0x819)
 828   {
 829     reg_t npc = pc + insn_length(0x00000819);
 830     #include "insns/c_srli.h"
 831     return npc;
 832   }
 833   if((insn.bits & 0x1c1f) == 0x1419)
 834   {
 835     reg_t npc = pc + insn_length(0x00001419);
 836     #include "insns/c_srai32.h"
 837     return npc;
 838   }
 839   if((insn.bits & 0x1c1f) == 0x1819)
 840   {
 841     reg_t npc = pc + insn_length(0x00001819);
 842     #include "insns/c_slliw.h"
 843     return npc;
 844   }
 845   if((insn.bits & 0x1c1f) == 0xc19)
 846   {
 847     reg_t npc = pc + insn_length(0x00000c19);
 848     #include "insns/c_srli32.h"
 849     return npc;
 850   }
 851   if((insn.bits & 0x1c1f) == 0x1019)
 852   {
 853     reg_t npc = pc + insn_length(0x00001019);
 854     #include "insns/c_srai.h"
 855     return npc;
 856   }
 857   if((insn.bits & 0x1c1f) == 0x419)
 858   {
 859     reg_t npc = pc + insn_length(0x00000419);
 860     #include "insns/c_slli32.h"
 861     return npc;
 862   }
 863   throw trap_illegal_instruction;
 864 }
 865
 866 reg_t processor_t::opcode_func_2e3(insn_t insn, reg_t pc)
 867 {
 868     reg_t npc = pc + insn_length(0x000002e3);
 869     #include "insns/bge.h"
 870     return npc;
 871 }
 872
 873 reg_t processor_t::opcode_func_2ed(insn_t insn, reg_t pc)
 874 {
 875     reg_t npc = pc + insn_length(0x0000000d);
 876     #include "insns/c_sw.h"
 877     return npc;
 878 }
 879
 880 reg_t processor_t::opcode_func_2f7(insn_t insn, reg_t pc)
 881 {
 882   if((insn.bits & 0x1ffff) == 0x6f7)
 883   {
 884     reg_t npc = pc + insn_length(0x000006f7);
 885     #include "insns/movn.h"
 886     return npc;
 887   }
 888   if((insn.bits & 0x1ffff) == 0x2f7)
 889   {
 890     reg_t npc = pc + insn_length(0x000002f7);
 891     #include "insns/movz.h"
 892     return npc;
 893   }
 894   if((insn.bits & 0x1ffff) == 0xef7)
 895   {
 896     reg_t npc = pc + insn_length(0x00000ef7);
 897     #include "insns/fmovn.h"
 898     return npc;
 899   }
 900   if((insn.bits & 0x1ffff) == 0xaf7)
 901   {
 902     reg_t npc = pc + insn_length(0x00000af7);
 903     #include "insns/fmovz.h"
 904     return npc;
 905   }
 906   throw trap_illegal_instruction;
 907 }
 908
 909 reg_t processor_t::opcode_func_301(insn_t insn, reg_t pc)
 910 {
 911     reg_t npc = pc + insn_length(0x00000001);
 912     #include "insns/c_addi.h"
 913     return npc;
 914 }
 915
 916 reg_t processor_t::opcode_func_30b(insn_t insn, reg_t pc)
 917 {
 918   if((insn.bits & 0xfff) == 0xb0b)
 919   {
 920     reg_t npc = pc + insn_length(0x00000b0b);
 921     #include "insns/vlsegstwu.h"
 922     return npc;
 923   }
 924   if((insn.bits & 0x3fffff) == 0x30b)
 925   {
 926     reg_t npc = pc + insn_length(0x0000030b);
 927     #include "insns/vlwu.h"
 928     return npc;
 929   }
 930   if((insn.bits & 0x1ffff) == 0x130b)
 931   {
 932     reg_t npc = pc + insn_length(0x0000130b);
 933     #include "insns/vlstwu.h"
 934     return npc;
 935   }
 936   if((insn.bits & 0x1ffff) == 0x230b)
 937   {
 938     reg_t npc = pc + insn_length(0x0000230b);
 939     #include "insns/vlsegwu.h"
 940     return npc;
 941   }
 942   throw trap_illegal_instruction;
 943 }
 944
 945 reg_t processor_t::opcode_func_315(insn_t insn, reg_t pc)
 946 {
 947     reg_t npc = pc + insn_length(0x00000015);
 948     #include "insns/c_fld.h"
 949     return npc;
 950 }
 951
 952 reg_t processor_t::opcode_func_31f(insn_t insn, reg_t pc)
 953 {
 954   throw trap_illegal_instruction;
 955 }
 956
 957 reg_t processor_t::opcode_func_329(insn_t insn, reg_t pc)
 958 {
 959     reg_t npc = pc + insn_length(0x00000009);
 960     #include "insns/c_ld.h"
 961     return npc;
 962 }
 963
 964 reg_t processor_t::opcode_func_333(insn_t insn, reg_t pc)
 965 {
 966   if((insn.bits & 0x1ffff) == 0x733)
 967   {
 968     reg_t npc = pc + insn_length(0x00000733);
 969     #include "insns/rem.h"
 970     return npc;
 971   }
 972   if((insn.bits & 0x1ffff) == 0x333)
 973   {
 974     reg_t npc = pc + insn_length(0x00000333);
 975     #include "insns/or.h"
 976     return npc;
 977   }
 978   throw trap_illegal_instruction;
 979 }
 980
 981 reg_t processor_t::opcode_func_33d(insn_t insn, reg_t pc)
 982 {
 983     reg_t npc = pc + insn_length(0x0000001d);
 984     #include "insns/c_addiw.h"
 985     return npc;
 986 }
 987
 988 reg_t processor_t::opcode_func_347(insn_t insn, reg_t pc)
 989 {
 990   throw trap_illegal_instruction;
 991 }
 992
 993 reg_t processor_t::opcode_func_351(insn_t insn, reg_t pc)
 994 {
 995     reg_t npc = pc + insn_length(0x00000011);
 996     #include "insns/c_bne.h"
 997     return npc;
 998 }
 999
1000 reg_t processor_t::opcode_func_35b(insn_t insn, reg_t pc)
1001 {
1002   throw trap_illegal_instruction;
1003 }
1004
1005 reg_t processor_t::opcode_func_365(insn_t insn, reg_t pc)
1006 {
1007     reg_t npc = pc + insn_length(0x00000005);
1008     #include "insns/c_lwsp.h"
1009     return npc;
1010 }
1011
1012 reg_t processor_t::opcode_func_36f(insn_t insn, reg_t pc)
1013 {
1014     reg_t npc = pc + insn_length(0x0000006f);
1015     #include "insns/jal.h"
1016     return npc;
1017 }
1018
1019 reg_t processor_t::opcode_func_379(insn_t insn, reg_t pc)
1020 {
1021   if((insn.bits & 0x1c1f) == 0x19)
1022   {
1023     reg_t npc = pc + insn_length(0x00000019);
1024     #include "insns/c_slli.h"
1025     return npc;
1026   }
1027   if((insn.bits & 0x1c1f) == 0x819)
1028   {
1029     reg_t npc = pc + insn_length(0x00000819);
1030     #include "insns/c_srli.h"
1031     return npc;
1032   }
1033   if((insn.bits & 0x1c1f) == 0x1419)
1034   {
1035     reg_t npc = pc + insn_length(0x00001419);
1036     #include "insns/c_srai32.h"
1037     return npc;
1038   }
1039   if((insn.bits & 0x1c1f) == 0x1819)
1040   {
1041     reg_t npc = pc + insn_length(0x00001819);
1042     #include "insns/c_slliw.h"
1043     return npc;
1044   }
1045   if((insn.bits & 0x1c1f) == 0xc19)
1046   {
1047     reg_t npc = pc + insn_length(0x00000c19);
1048     #include "insns/c_srli32.h"
1049     return npc;
1050   }
1051   if((insn.bits & 0x1c1f) == 0x1019)
1052   {
1053     reg_t npc = pc + insn_length(0x00001019);
1054     #include "insns/c_srai.h"
1055     return npc;
1056   }
1057   if((insn.bits & 0x1c1f) == 0x419)
1058   {
1059     reg_t npc = pc + insn_length(0x00000419);
1060     #include "insns/c_slli32.h"
1061     return npc;
1062   }
1063   throw trap_illegal_instruction;
1064 }
1065
1066 reg_t processor_t::opcode_func_383(insn_t insn, reg_t pc)
1067 {
1068   throw trap_illegal_instruction;
1069 }
1070
1071 reg_t processor_t::opcode_func_38d(insn_t insn, reg_t pc)
1072 {
1073     reg_t npc = pc + insn_length(0x0000000d);
1074     #include "insns/c_sw.h"
1075     return npc;
1076 }
1077
1078 reg_t processor_t::opcode_func_397(insn_t insn, reg_t pc)
1079 {
1080   throw trap_illegal_instruction;
1081 }
1082
1083 reg_t processor_t::opcode_func_3a1(insn_t insn, reg_t pc)
1084 {
1085     reg_t npc = pc + insn_length(0x00000001);
1086     #include "insns/c_addi.h"
1087     return npc;
1088 }
1089
1090 reg_t processor_t::opcode_func_3ab(insn_t insn, reg_t pc)
1091 {
1092   throw trap_illegal_instruction;
1093 }
1094
1095 reg_t processor_t::opcode_func_3b5(insn_t insn, reg_t pc)
1096 {
1097     reg_t npc = pc + insn_length(0x00000015);
1098     #include "insns/c_fld.h"
1099     return npc;
1100 }
1101
1102 reg_t processor_t::opcode_func_3bf(insn_t insn, reg_t pc)
1103 {
1104   throw trap_illegal_instruction;
1105 }
1106
1107 reg_t processor_t::opcode_func_3c9(insn_t insn, reg_t pc)
1108 {
1109     reg_t npc = pc + insn_length(0x00000009);
1110     #include "insns/c_ld.h"
1111     return npc;
1112 }
1113
1114 reg_t processor_t::opcode_func_3d3(insn_t insn, reg_t pc)
1115 {
1116   throw trap_illegal_instruction;
1117 }
1118
1119 reg_t processor_t::opcode_func_3dd(insn_t insn, reg_t pc)
1120 {
1121     reg_t npc = pc + insn_length(0x0000001d);
1122     #include "insns/c_addiw.h"
1123     return npc;
1124 }
1125
1126 reg_t processor_t::opcode_func_3e7(insn_t insn, reg_t pc)
1127 {
1128     reg_t npc = pc + insn_length(0x00000067);
1129     #include "insns/j.h"
1130     return npc;
1131 }
1132
1133 reg_t processor_t::opcode_func_3f1(insn_t insn, reg_t pc)
1134 {
1135     reg_t npc = pc + insn_length(0x00000011);
1136     #include "insns/c_bne.h"
1137     return npc;
1138 }
1139
1140 reg_t processor_t::opcode_func_3fb(insn_t insn, reg_t pc)
1141 {
1142   throw trap_illegal_instruction;
1143 }
1144