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