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