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