ext/ByteLoader/byterun.c

   1 /*
   2  *      Copyright (c) 1996-1999 Malcolm Beattie
   3  *
   4  *      You may distribute under the terms of either the GNU General Public
   5  *      License or the Artistic License, as specified in the README file.
   6  *
   7  */
   8 /*
   9  * This file is autogenerated from bytecode.pl. Changes made here will be lost.
  10  */
  11
  12 #define PERL_NO_GET_CONTEXT
  13 #include "EXTERN.h"
  14 #include "perl.h"
  15 #define NO_XSLOCKS
  16 #include "XSUB.h"
  17
  18 #include "byterun.h"
  19 #include "bytecode.h"
  20
  21
  22 static const int optype_size[] = {
  23     sizeof(OP),
  24     sizeof(UNOP),
  25     sizeof(BINOP),
  26     sizeof(LOGOP),
  27     sizeof(LISTOP),
  28     sizeof(PMOP),
  29     sizeof(SVOP),
  30     sizeof(PADOP),
  31     sizeof(PVOP),
  32     sizeof(LOOP),
  33     sizeof(COP)
  34 };
  35
  36 void *
  37 bset_obj_store(pTHX_ struct byteloader_state *bstate, void *obj, I32 ix)
  38 {
  39     if (ix > bstate->bs_obj_list_fill) {
  40         Renew(bstate->bs_obj_list, ix + 32, void*);
  41         bstate->bs_obj_list_fill = ix + 31;
  42     }
  43     bstate->bs_obj_list[ix] = obj;
  44     return obj;
  45 }
  46
  47 void
  48 byterun(pTHX_ register struct byteloader_state *bstate)
  49 {
  50     register int insn;
  51     U32 ix;
  52     SV *specialsv_list[6];
  53
  54     BYTECODE_HEADER_CHECK;      /* croak if incorrect platform */
  55     New(666, bstate->bs_obj_list, 32, void*); /* set op objlist */
  56     bstate->bs_obj_list_fill = 31;
  57
  58     specialsv_list[0] = Nullsv;
  59     specialsv_list[1] = &PL_sv_undef;
  60     specialsv_list[2] = &PL_sv_yes;
  61     specialsv_list[3] = &PL_sv_no;
  62     specialsv_list[4] = pWARN_ALL;
  63     specialsv_list[5] = pWARN_NONE;
  64
  65     while ((insn = BGET_FGETC()) != EOF) {
  66         switch (insn) {
  67           case INSN_COMMENT:            /* 35 */
  68             {
  69                 comment_t arg;
  70                 BGET_comment_t(arg);
  71                 arg = arg;
  72                 break;
  73             }
  74           case INSN_NOP:                /* 10 */
  75             {
  76                 break;
  77             }
  78           case INSN_RET:                /* 0 */
  79             {
  80                 BSET_ret(none);
  81                 break;
  82             }
  83           case INSN_LDSV:               /* 1 */
  84             {
  85                 svindex arg;
  86                 BGET_svindex(arg);
  87                 bstate->bs_sv = arg;
  88                 break;
  89             }
  90           case INSN_LDOP:               /* 2 */
  91             {
  92                 opindex arg;
  93                 BGET_opindex(arg);
  94                 PL_op = arg;
  95                 break;
  96             }
  97           case INSN_STSV:               /* 3 */
  98             {
  99                 U32 arg;
 100                 BGET_U32(arg);
 101                 BSET_OBJ_STORE(bstate->bs_sv, arg);
 102                 break;
 103             }
 104           case INSN_STOP:               /* 4 */
 105             {
 106                 U32 arg;
 107                 BGET_U32(arg);
 108                 BSET_OBJ_STORE(PL_op, arg);
 109                 break;
 110             }
 111           case INSN_STPV:               /* 5 */
 112             {
 113                 U32 arg;
 114                 BGET_U32(arg);
 115                 BSET_stpv(bstate->bs_pv.xpv_pv, arg);
 116                 break;
 117             }
 118           case INSN_LDSPECSV:           /* 6 */
 119             {
 120                 U8 arg;
 121                 BGET_U8(arg);
 122                 BSET_ldspecsv(bstate->bs_sv, arg);
 123                 break;
 124             }
 125           case INSN_NEWSV:              /* 7 */
 126             {
 127                 U8 arg;
 128                 BGET_U8(arg);
 129                 BSET_newsv(bstate->bs_sv, arg);
 130                 break;
 131             }
 132           case INSN_NEWOP:              /* 8 */
 133             {
 134                 U8 arg;
 135                 BGET_U8(arg);
 136                 BSET_newop(PL_op, arg);
 137                 break;
 138             }
 139           case INSN_NEWOPN:             /* 9 */
 140             {
 141                 U8 arg;
 142                 BGET_U8(arg);
 143                 BSET_newopn(PL_op, arg);
 144                 break;
 145             }
 146           case INSN_NEWPV:              /* 11 */
 147             {
 148                 PV arg;
 149                 BGET_PV(arg);
 150                 break;
 151             }
 152           case INSN_PV_CUR:             /* 12 */
 153             {
 154                 STRLEN arg;
 155                 BGET_U32(arg);
 156                 bstate->bs_pv.xpv_cur = arg;
 157                 break;
 158             }
 159           case INSN_PV_FREE:            /* 13 */
 160             {
 161                 BSET_pv_free(bstate->bs_pv);
 162                 break;
 163             }
 164           case INSN_SV_UPGRADE:         /* 14 */
 165             {
 166                 U8 arg;
 167                 BGET_U8(arg);
 168                 BSET_sv_upgrade(bstate->bs_sv, arg);
 169                 break;
 170             }
 171           case INSN_SV_REFCNT:          /* 15 */
 172             {
 173                 U32 arg;
 174                 BGET_U32(arg);
 175                 SvREFCNT(bstate->bs_sv) = arg;
 176                 break;
 177             }
 178           case INSN_SV_REFCNT_ADD:              /* 16 */
 179             {
 180                 I32 arg;
 181                 BGET_I32(arg);
 182                 BSET_sv_refcnt_add(SvREFCNT(bstate->bs_sv), arg);
 183                 break;
 184             }
 185           case INSN_SV_FLAGS:           /* 17 */
 186             {
 187                 U32 arg;
 188                 BGET_U32(arg);
 189                 SvFLAGS(bstate->bs_sv) = arg;
 190                 break;
 191             }
 192           case INSN_XRV:                /* 18 */
 193             {
 194                 svindex arg;
 195                 BGET_svindex(arg);
 196                 SvRV(bstate->bs_sv) = arg;
 197                 break;
 198             }
 199           case INSN_XPV:                /* 19 */
 200             {
 201                 BSET_xpv(bstate->bs_sv);
 202                 break;
 203             }
 204           case INSN_XIV32:              /* 20 */
 205             {
 206                 I32 arg;
 207                 BGET_I32(arg);
 208                 SvIVX(bstate->bs_sv) = arg;
 209                 break;
 210             }
 211           case INSN_XIV64:              /* 21 */
 212             {
 213                 IV64 arg;
 214                 BGET_IV64(arg);
 215                 SvIVX(bstate->bs_sv) = arg;
 216                 break;
 217             }
 218           case INSN_XNV:                /* 22 */
 219             {
 220                 NV arg;
 221                 BGET_NV(arg);
 222                 SvNVX(bstate->bs_sv) = arg;
 223                 break;
 224             }
 225           case INSN_XLV_TARGOFF:                /* 23 */
 226             {
 227                 STRLEN arg;
 228                 BGET_U32(arg);
 229                 LvTARGOFF(bstate->bs_sv) = arg;
 230                 break;
 231             }
 232           case INSN_XLV_TARGLEN:                /* 24 */
 233             {
 234                 STRLEN arg;
 235                 BGET_U32(arg);
 236                 LvTARGLEN(bstate->bs_sv) = arg;
 237                 break;
 238             }
 239           case INSN_XLV_TARG:           /* 25 */
 240             {
 241                 svindex arg;
 242                 BGET_svindex(arg);
 243                 LvTARG(bstate->bs_sv) = arg;
 244                 break;
 245             }
 246           case INSN_XLV_TYPE:           /* 26 */
 247             {
 248                 char arg;
 249                 BGET_U8(arg);
 250                 LvTYPE(bstate->bs_sv) = arg;
 251                 break;
 252             }
 253           case INSN_XBM_USEFUL:         /* 27 */
 254             {
 255                 I32 arg;
 256                 BGET_I32(arg);
 257                 BmUSEFUL(bstate->bs_sv) = arg;
 258                 break;
 259             }
 260           case INSN_XBM_PREVIOUS:               /* 28 */
 261             {
 262                 U16 arg;
 263                 BGET_U16(arg);
 264                 BmPREVIOUS(bstate->bs_sv) = arg;
 265                 break;
 266             }
 267           case INSN_XBM_RARE:           /* 29 */
 268             {
 269                 U8 arg;
 270                 BGET_U8(arg);
 271                 BmRARE(bstate->bs_sv) = arg;
 272                 break;
 273             }
 274           case INSN_XFM_LINES:          /* 30 */
 275             {
 276                 IV arg;
 277                 BGET_IV(arg);
 278                 FmLINES(bstate->bs_sv) = arg;
 279                 break;
 280             }
 281           case INSN_XIO_LINES:          /* 31 */
 282             {
 283                 IV arg;
 284                 BGET_IV(arg);
 285                 IoLINES(bstate->bs_sv) = arg;
 286                 break;
 287             }
 288           case INSN_XIO_PAGE:           /* 32 */
 289             {
 290                 IV arg;
 291                 BGET_IV(arg);
 292                 IoPAGE(bstate->bs_sv) = arg;
 293                 break;
 294             }
 295           case INSN_XIO_PAGE_LEN:               /* 33 */
 296             {
 297                 IV arg;
 298                 BGET_IV(arg);
 299                 IoPAGE_LEN(bstate->bs_sv) = arg;
 300                 break;
 301             }
 302           case INSN_XIO_LINES_LEFT:             /* 34 */
 303             {
 304                 IV arg;
 305                 BGET_IV(arg);
 306                 IoLINES_LEFT(bstate->bs_sv) = arg;
 307                 break;
 308             }
 309           case INSN_XIO_TOP_NAME:               /* 36 */
 310             {
 311                 pvcontents arg;
 312                 BGET_pvcontents(arg);
 313                 IoTOP_NAME(bstate->bs_sv) = arg;
 314                 break;
 315             }
 316           case INSN_XIO_TOP_GV:         /* 37 */
 317             {
 318                 svindex arg;
 319                 BGET_svindex(arg);
 320                 *(SV**)&IoTOP_GV(bstate->bs_sv) = arg;
 321                 break;
 322             }
 323           case INSN_XIO_FMT_NAME:               /* 38 */
 324             {
 325                 pvcontents arg;
 326                 BGET_pvcontents(arg);
 327                 IoFMT_NAME(bstate->bs_sv) = arg;
 328                 break;
 329             }
 330           case INSN_XIO_FMT_GV:         /* 39 */
 331             {
 332                 svindex arg;
 333                 BGET_svindex(arg);
 334                 *(SV**)&IoFMT_GV(bstate->bs_sv) = arg;
 335                 break;
 336             }
 337           case INSN_XIO_BOTTOM_NAME:            /* 40 */
 338             {
 339                 pvcontents arg;
 340                 BGET_pvcontents(arg);
 341                 IoBOTTOM_NAME(bstate->bs_sv) = arg;
 342                 break;
 343             }
 344           case INSN_XIO_BOTTOM_GV:              /* 41 */
 345             {
 346                 svindex arg;
 347                 BGET_svindex(arg);
 348                 *(SV**)&IoBOTTOM_GV(bstate->bs_sv) = arg;
 349                 break;
 350             }
 351           case INSN_XIO_SUBPROCESS:             /* 42 */
 352             {
 353                 short arg;
 354                 BGET_U16(arg);
 355                 IoSUBPROCESS(bstate->bs_sv) = arg;
 356                 break;
 357             }
 358           case INSN_XIO_TYPE:           /* 43 */
 359             {
 360                 char arg;
 361                 BGET_U8(arg);
 362                 IoTYPE(bstate->bs_sv) = arg;
 363                 break;
 364             }
 365           case INSN_XIO_FLAGS:          /* 44 */
 366             {
 367                 char arg;
 368                 BGET_U8(arg);
 369                 IoFLAGS(bstate->bs_sv) = arg;
 370                 break;
 371             }
 372           case INSN_XCV_STASH:          /* 45 */
 373             {
 374                 svindex arg;
 375                 BGET_svindex(arg);
 376                 *(SV**)&CvSTASH(bstate->bs_sv) = arg;
 377                 break;
 378             }
 379           case INSN_XCV_START:          /* 46 */
 380             {
 381                 opindex arg;
 382                 BGET_opindex(arg);
 383                 CvSTART(bstate->bs_sv) = arg;
 384                 break;
 385             }
 386           case INSN_XCV_ROOT:           /* 47 */
 387             {
 388                 opindex arg;
 389                 BGET_opindex(arg);
 390                 CvROOT(bstate->bs_sv) = arg;
 391                 break;
 392             }
 393           case INSN_XCV_GV:             /* 48 */
 394             {
 395                 svindex arg;
 396                 BGET_svindex(arg);
 397                 *(SV**)&CvGV(bstate->bs_sv) = arg;
 398                 break;
 399             }
 400           case INSN_XCV_FILE:           /* 49 */
 401             {
 402                 pvindex arg;
 403                 BGET_pvindex(arg);
 404                 CvFILE(bstate->bs_sv) = arg;
 405                 break;
 406             }
 407           case INSN_XCV_DEPTH:          /* 50 */
 408             {
 409                 long arg;
 410                 BGET_I32(arg);
 411                 CvDEPTH(bstate->bs_sv) = arg;
 412                 break;
 413             }
 414           case INSN_XCV_PADLIST:                /* 51 */
 415             {
 416                 svindex arg;
 417                 BGET_svindex(arg);
 418                 *(SV**)&CvPADLIST(bstate->bs_sv) = arg;
 419                 break;
 420             }
 421           case INSN_XCV_OUTSIDE:                /* 52 */
 422             {
 423                 svindex arg;
 424                 BGET_svindex(arg);
 425                 *(SV**)&CvOUTSIDE(bstate->bs_sv) = arg;
 426                 break;
 427             }
 428           case INSN_XCV_OUTSIDE_SEQ:            /* 53 */
 429             {
 430                 U32 arg;
 431                 BGET_U32(arg);
 432                 CvOUTSIDE_SEQ(bstate->bs_sv) = arg;
 433                 break;
 434             }
 435           case INSN_XCV_FLAGS:          /* 54 */
 436             {
 437                 U16 arg;
 438                 BGET_U16(arg);
 439                 CvFLAGS(bstate->bs_sv) = arg;
 440                 break;
 441             }
 442           case INSN_AV_EXTEND:          /* 55 */
 443             {
 444                 SSize_t arg;
 445                 BGET_I32(arg);
 446                 BSET_av_extend(bstate->bs_sv, arg);
 447                 break;
 448             }
 449           case INSN_AV_PUSH:            /* 56 */
 450             {
 451                 svindex arg;
 452                 BGET_svindex(arg);
 453                 BSET_av_push(bstate->bs_sv, arg);
 454                 break;
 455             }
 456           case INSN_XAV_FILL:           /* 57 */
 457             {
 458                 SSize_t arg;
 459                 BGET_I32(arg);
 460                 AvFILLp(bstate->bs_sv) = arg;
 461                 break;
 462             }
 463           case INSN_XAV_MAX:            /* 58 */
 464             {
 465                 SSize_t arg;
 466                 BGET_I32(arg);
 467                 AvMAX(bstate->bs_sv) = arg;
 468                 break;
 469             }
 470           case INSN_XAV_FLAGS:          /* 59 */
 471             {
 472                 U8 arg;
 473                 BGET_U8(arg);
 474                 AvFLAGS(bstate->bs_sv) = arg;
 475                 break;
 476             }
 477           case INSN_XHV_RITER:          /* 60 */
 478             {
 479                 I32 arg;
 480                 BGET_I32(arg);
 481                 HvRITER(bstate->bs_sv) = arg;
 482                 break;
 483             }
 484           case INSN_XHV_NAME:           /* 61 */
 485             {
 486                 pvcontents arg;
 487                 BGET_pvcontents(arg);
 488                 HvNAME(bstate->bs_sv) = arg;
 489                 break;
 490             }
 491           case INSN_HV_STORE:           /* 62 */
 492             {
 493                 svindex arg;
 494                 BGET_svindex(arg);
 495                 BSET_hv_store(bstate->bs_sv, arg);
 496                 break;
 497             }
 498           case INSN_SV_MAGIC:           /* 63 */
 499             {
 500                 char arg;
 501                 BGET_U8(arg);
 502                 BSET_sv_magic(bstate->bs_sv, arg);
 503                 break;
 504             }
 505           case INSN_MG_OBJ:             /* 64 */
 506             {
 507                 svindex arg;
 508                 BGET_svindex(arg);
 509                 SvMAGIC(bstate->bs_sv)->mg_obj = arg;
 510                 break;
 511             }
 512           case INSN_MG_PRIVATE:         /* 65 */
 513             {
 514                 U16 arg;
 515                 BGET_U16(arg);
 516                 SvMAGIC(bstate->bs_sv)->mg_private = arg;
 517                 break;
 518             }
 519           case INSN_MG_FLAGS:           /* 66 */
 520             {
 521                 U8 arg;
 522                 BGET_U8(arg);
 523                 SvMAGIC(bstate->bs_sv)->mg_flags = arg;
 524                 break;
 525             }
 526           case INSN_MG_PV:              /* 67 */
 527             {
 528                 pvcontents arg;
 529                 BGET_pvcontents(arg);
 530                 BSET_mg_pv(SvMAGIC(bstate->bs_sv), arg);
 531                 break;
 532             }
 533           case INSN_XMG_STASH:          /* 68 */
 534             {
 535                 svindex arg;
 536                 BGET_svindex(arg);
 537                 *(SV**)&SvSTASH(bstate->bs_sv) = arg;
 538                 break;
 539             }
 540           case INSN_GV_FETCHPV:         /* 69 */
 541             {
 542                 strconst arg;
 543                 BGET_strconst(arg);
 544                 BSET_gv_fetchpv(bstate->bs_sv, arg);
 545                 break;
 546             }
 547           case INSN_GV_STASHPV:         /* 70 */
 548             {
 549                 strconst arg;
 550                 BGET_strconst(arg);
 551                 BSET_gv_stashpv(bstate->bs_sv, arg);
 552                 break;
 553             }
 554           case INSN_GP_SV:              /* 71 */
 555             {
 556                 svindex arg;
 557                 BGET_svindex(arg);
 558                 GvSV(bstate->bs_sv) = arg;
 559                 break;
 560             }
 561           case INSN_GP_REFCNT:          /* 72 */
 562             {
 563                 U32 arg;
 564                 BGET_U32(arg);
 565                 GvREFCNT(bstate->bs_sv) = arg;
 566                 break;
 567             }
 568           case INSN_GP_REFCNT_ADD:              /* 73 */
 569             {
 570                 I32 arg;
 571                 BGET_I32(arg);
 572                 BSET_gp_refcnt_add(GvREFCNT(bstate->bs_sv), arg);
 573                 break;
 574             }
 575           case INSN_GP_AV:              /* 74 */
 576             {
 577                 svindex arg;
 578                 BGET_svindex(arg);
 579                 *(SV**)&GvAV(bstate->bs_sv) = arg;
 580                 break;
 581             }
 582           case INSN_GP_HV:              /* 75 */
 583             {
 584                 svindex arg;
 585                 BGET_svindex(arg);
 586                 *(SV**)&GvHV(bstate->bs_sv) = arg;
 587                 break;
 588             }
 589           case INSN_GP_CV:              /* 76 */
 590             {
 591                 svindex arg;
 592                 BGET_svindex(arg);
 593                 *(SV**)&GvCV(bstate->bs_sv) = arg;
 594                 break;
 595             }
 596           case INSN_GP_FILE:            /* 77 */
 597             {
 598                 pvindex arg;
 599                 BGET_pvindex(arg);
 600                 GvFILE(bstate->bs_sv) = arg;
 601                 break;
 602             }
 603           case INSN_GP_IO:              /* 78 */
 604             {
 605                 svindex arg;
 606                 BGET_svindex(arg);
 607                 *(SV**)&GvIOp(bstate->bs_sv) = arg;
 608                 break;
 609             }
 610           case INSN_GP_FORM:            /* 79 */
 611             {
 612                 svindex arg;
 613                 BGET_svindex(arg);
 614                 *(SV**)&GvFORM(bstate->bs_sv) = arg;
 615                 break;
 616             }
 617           case INSN_GP_CVGEN:           /* 80 */
 618             {
 619                 U32 arg;
 620                 BGET_U32(arg);
 621                 GvCVGEN(bstate->bs_sv) = arg;
 622                 break;
 623             }
 624           case INSN_GP_LINE:            /* 81 */
 625             {
 626                 line_t arg;
 627                 BGET_U16(arg);
 628                 GvLINE(bstate->bs_sv) = arg;
 629                 break;
 630             }
 631           case INSN_GP_SHARE:           /* 82 */
 632             {
 633                 svindex arg;
 634                 BGET_svindex(arg);
 635                 BSET_gp_share(bstate->bs_sv, arg);
 636                 break;
 637             }
 638           case INSN_XGV_FLAGS:          /* 83 */
 639             {
 640                 U8 arg;
 641                 BGET_U8(arg);
 642                 GvFLAGS(bstate->bs_sv) = arg;
 643                 break;
 644             }
 645           case INSN_OP_NEXT:            /* 84 */
 646             {
 647                 opindex arg;
 648                 BGET_opindex(arg);
 649                 PL_op->op_next = arg;
 650                 break;
 651             }
 652           case INSN_OP_SIBLING:         /* 85 */
 653             {
 654                 opindex arg;
 655                 BGET_opindex(arg);
 656                 PL_op->op_sibling = arg;
 657                 break;
 658             }
 659           case INSN_OP_PPADDR:          /* 86 */
 660             {
 661                 strconst arg;
 662                 BGET_strconst(arg);
 663                 BSET_op_ppaddr(PL_op->op_ppaddr, arg);
 664                 break;
 665             }
 666           case INSN_OP_TARG:            /* 87 */
 667             {
 668                 PADOFFSET arg;
 669                 BGET_U32(arg);
 670                 PL_op->op_targ = arg;
 671                 break;
 672             }
 673           case INSN_OP_TYPE:            /* 88 */
 674             {
 675                 OPCODE arg;
 676                 BGET_U16(arg);
 677                 BSET_op_type(PL_op, arg);
 678                 break;
 679             }
 680           case INSN_OP_SEQ:             /* 89 */
 681             {
 682                 U16 arg;
 683                 BGET_U16(arg);
 684                 PL_op->op_seq = arg;
 685                 break;
 686             }
 687           case INSN_OP_FLAGS:           /* 90 */
 688             {
 689                 U8 arg;
 690                 BGET_U8(arg);
 691                 PL_op->op_flags = arg;
 692                 break;
 693             }
 694           case INSN_OP_PRIVATE:         /* 91 */
 695             {
 696                 U8 arg;
 697                 BGET_U8(arg);
 698                 PL_op->op_private = arg;
 699                 break;
 700             }
 701           case INSN_OP_FIRST:           /* 92 */
 702             {
 703                 opindex arg;
 704                 BGET_opindex(arg);
 705                 cUNOP->op_first = arg;
 706                 break;
 707             }
 708           case INSN_OP_LAST:            /* 93 */
 709             {
 710                 opindex arg;
 711                 BGET_opindex(arg);
 712                 cBINOP->op_last = arg;
 713                 break;
 714             }
 715           case INSN_OP_OTHER:           /* 94 */
 716             {
 717                 opindex arg;
 718                 BGET_opindex(arg);
 719                 cLOGOP->op_other = arg;
 720                 break;
 721             }
 722           case INSN_OP_PMREPLROOT:              /* 95 */
 723             {
 724                 opindex arg;
 725                 BGET_opindex(arg);
 726                 cPMOP->op_pmreplroot = arg;
 727                 break;
 728             }
 729           case INSN_OP_PMREPLROOTGV:            /* 96 */
 730             {
 731                 svindex arg;
 732                 BGET_svindex(arg);
 733                 *(SV**)&cPMOP->op_pmreplroot = arg;
 734                 break;
 735             }
 736           case INSN_OP_PMREPLSTART:             /* 97 */
 737             {
 738                 opindex arg;
 739                 BGET_opindex(arg);
 740                 cPMOP->op_pmreplstart = arg;
 741                 break;
 742             }
 743           case INSN_OP_PMNEXT:          /* 98 */
 744             {
 745                 opindex arg;
 746                 BGET_opindex(arg);
 747                 *(OP**)&cPMOP->op_pmnext = arg;
 748                 break;
 749             }
 750           case INSN_PREGCOMP:           /* 99 */
 751             {
 752                 pvcontents arg;
 753                 BGET_pvcontents(arg);
 754                 BSET_pregcomp(PL_op, arg);
 755                 break;
 756             }
 757           case INSN_OP_PMFLAGS:         /* 100 */
 758             {
 759                 U16 arg;
 760                 BGET_U16(arg);
 761                 cPMOP->op_pmflags = arg;
 762                 break;
 763             }
 764           case INSN_OP_PMPERMFLAGS:             /* 101 */
 765             {
 766                 U16 arg;
 767                 BGET_U16(arg);
 768                 cPMOP->op_pmpermflags = arg;
 769                 break;
 770             }
 771           case INSN_OP_SV:              /* 102 */
 772             {
 773                 svindex arg;
 774                 BGET_svindex(arg);
 775                 cSVOP->op_sv = arg;
 776                 break;
 777             }
 778           case INSN_OP_PADIX:           /* 103 */
 779             {
 780                 PADOFFSET arg;
 781                 BGET_U32(arg);
 782                 cPADOP->op_padix = arg;
 783                 break;
 784             }
 785           case INSN_OP_PV:              /* 104 */
 786             {
 787                 pvcontents arg;
 788                 BGET_pvcontents(arg);
 789                 cPVOP->op_pv = arg;
 790                 break;
 791             }
 792           case INSN_OP_PV_TR:           /* 105 */
 793             {
 794                 op_tr_array arg;
 795                 BGET_op_tr_array(arg);
 796                 cPVOP->op_pv = arg;
 797                 break;
 798             }
 799           case INSN_OP_REDOOP:          /* 106 */
 800             {
 801                 opindex arg;
 802                 BGET_opindex(arg);
 803                 cLOOP->op_redoop = arg;
 804                 break;
 805             }
 806           case INSN_OP_NEXTOP:          /* 107 */
 807             {
 808                 opindex arg;
 809                 BGET_opindex(arg);
 810                 cLOOP->op_nextop = arg;
 811                 break;
 812             }
 813           case INSN_OP_LASTOP:          /* 108 */
 814             {
 815                 opindex arg;
 816                 BGET_opindex(arg);
 817                 cLOOP->op_lastop = arg;
 818                 break;
 819             }
 820           case INSN_COP_LABEL:          /* 109 */
 821             {
 822                 pvindex arg;
 823                 BGET_pvindex(arg);
 824                 cCOP->cop_label = arg;
 825                 break;
 826             }
 827           case INSN_COP_STASHPV:                /* 110 */
 828             {
 829                 pvindex arg;
 830                 BGET_pvindex(arg);
 831                 BSET_cop_stashpv(cCOP, arg);
 832                 break;
 833             }
 834           case INSN_COP_FILE:           /* 111 */
 835             {
 836                 pvindex arg;
 837                 BGET_pvindex(arg);
 838                 BSET_cop_file(cCOP, arg);
 839                 break;
 840             }
 841           case INSN_COP_SEQ:            /* 112 */
 842             {
 843                 U32 arg;
 844                 BGET_U32(arg);
 845                 cCOP->cop_seq = arg;
 846                 break;
 847             }
 848           case INSN_COP_ARYBASE:                /* 113 */
 849             {
 850                 I32 arg;
 851                 BGET_I32(arg);
 852                 cCOP->cop_arybase = arg;
 853                 break;
 854             }
 855           case INSN_COP_LINE:           /* 114 */
 856             {
 857                 line_t arg;
 858                 BGET_U16(arg);
 859                 BSET_cop_line(cCOP, arg);
 860                 break;
 861             }
 862           case INSN_COP_WARNINGS:               /* 115 */
 863             {
 864                 svindex arg;
 865                 BGET_svindex(arg);
 866                 cCOP->cop_warnings = arg;
 867                 break;
 868             }
 869           case INSN_MAIN_START:         /* 116 */
 870             {
 871                 opindex arg;
 872                 BGET_opindex(arg);
 873                 PL_main_start = arg;
 874                 break;
 875             }
 876           case INSN_MAIN_ROOT:          /* 117 */
 877             {
 878                 opindex arg;
 879                 BGET_opindex(arg);
 880                 PL_main_root = arg;
 881                 break;
 882             }
 883           case INSN_CURPAD:             /* 118 */
 884             {
 885                 svindex arg;
 886                 BGET_svindex(arg);
 887                 BSET_curpad(PL_curpad, arg);
 888                 break;
 889             }
 890           case INSN_PUSH_BEGIN:         /* 119 */
 891             {
 892                 svindex arg;
 893                 BGET_svindex(arg);
 894                 BSET_push_begin(PL_beginav, arg);
 895                 break;
 896             }
 897           case INSN_PUSH_INIT:          /* 120 */
 898             {
 899                 svindex arg;
 900                 BGET_svindex(arg);
 901                 BSET_push_init(PL_initav, arg);
 902                 break;
 903             }
 904           case INSN_PUSH_END:           /* 121 */
 905             {
 906                 svindex arg;
 907                 BGET_svindex(arg);
 908                 BSET_push_end(PL_endav, arg);
 909                 break;
 910             }
 911           default:
 912             Perl_croak(aTHX_ "Illegal bytecode instruction %d\n", insn);
 913             /* NOTREACHED */
 914         }
 915     }
 916 }