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