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