develooper Front page | perl.perl5.porters | Postings from July 2011

[perl #95986] [PATCH] Superficial separation of INSTRUCTION from OP.

Thread Next
From:
Gerard Goossen
Date:
July 31, 2011 03:58
Subject:
[perl #95986] [PATCH] Superficial separation of INSTRUCTION from OP.
Message ID:
rt-3.6.HEAD-7815-1312109897-322.95986-75-0@perl.org
# New Ticket Created by  Gerard Goossen 
# Please include the string:  [perl #95986]
# in the subject line of all future correspondence about this issue. 
# <URL: https://rt.perl.org:443/rt3/Ticket/Display.html?id=95986 >



This is a bug report for perl from gerard@ggoossen.net,
generated with the help of perlbug 1.39 running under perl 5.15.1.

>From 3f9031a69a4c36ac36e7984bf9cb4ab22ed428c5 Mon Sep 17 00:00:00 2001
From: Gerard Goossen <gerard@ggoossen.net>
Date: Sat, 30 Jul 2011 16:00:02 +0200
Subject: [PATCH] Superficial separation of INSTRUCTION from OP.

Preparation for having INSTRUCTION which is different from OP.
This patch only introduces the INSTRUCTION type which is a synonym for
OP, changes function and variable definitions to use the type and
renames variables from *op to *instr.
---
 cop.h                     |   24 +-
 deb.c                     |    6 +-
 doop.c                    |    2 +-
 embed.fnc                 |   20 +-
 embedvar.h                |    4 +-
 ext/XS-APItest/APItest.pm |    2 +-
 ext/XS-APItest/APItest.xs |    4 +-
 intrpvar.h                |    8 +-
 op.h                      |    2 +-
 perl.c                    |   26 +-
 perl.h                    |    8 +-
 pod/perlinterp.pod        |   20 +-
 pp.c                      |    8 +-
 pp.h                      |    4 +-
 pp_ctl.c                  |  130 ++++++------
 pp_hot.c                  |   24 +-
 pp_proto.h                |  532 ++++++++++++++++++++++----------------------
 pp_sort.c                 |    4 +-
 pp_sys.c                  |   16 +-
 proto.h                   |   20 +-
 regen/opcode.pl           |    2 +-
 scope.c                   |    6 +-
 sv.c                      |    4 +-
 sv.h                      |    2 +-
 util.c                    |   14 +-
 win32/perlhost.h          |    6 +-
 26 files changed, 450 insertions(+), 448 deletions(-)

diff --git a/cop.h b/cop.h
index 6512451..b376c00 100644
--- a/cop.h
+++ b/cop.h
@@ -590,7 +590,7 @@ be zero.
 
 /* subroutine context */
 struct block_sub {
-    OP *	retop;	/* op to execute on exit from sub */
+    INSTRUCTION *	ret_instr;	/* instruction to execute on exit from sub */
     /* Above here is the same for sub, format and eval.  */
     CV *	cv;
     /* Above here is the same for sub and format.  */
@@ -603,7 +603,7 @@ struct block_sub {
 
 /* format context */
 struct block_format {
-    OP *	retop;	/* op to execute on exit from sub */
+    INSTRUCTION *	ret_instr;	/* instruction to execute on exit from sub */
     /* Above here is the same for sub, format and eval.  */
     CV *	cv;
     /* Above here is the same for sub and format.  */
@@ -624,7 +624,7 @@ struct block_format {
 	cx->blk_sub.cv = cv;						\
 	cx->blk_sub.olddepth = CvDEPTH(cv);				\
 	cx->cx_type |= (hasargs) ? CXp_HASARGS : 0;			\
-	cx->blk_sub.retop = NULL;					\
+	cx->blk_sub.ret_instr = NULL;					\
 	if (!CvDEPTH(cv)) {						\
 	    SvREFCNT_inc_simple_void_NN(cv);				\
 	    SvREFCNT_inc_simple_void_NN(cv);				\
@@ -652,10 +652,10 @@ struct block_format {
 	cx->blk_u16 = 0;
 
 
-#define PUSHFORMAT(cx, retop)						\
+#define PUSHFORMAT(cx, ret_instr)						\
 	cx->blk_format.cv = cv;						\
 	cx->blk_format.gv = gv;						\
-	cx->blk_format.retop = (retop);					\
+	cx->blk_format.ret_instr = (ret_instr);					\
 	cx->blk_format.dfoutgv = PL_defoutgv;				\
 	SvREFCNT_inc_void(cx->blk_format.dfoutgv)
 
@@ -713,7 +713,7 @@ struct block_format {
 
 /* eval context */
 struct block_eval {
-    OP *	retop;	/* op to execute on exit from eval */
+    INSTRUCTION *	ret_instr;	/* instruction to execute on exit from eval */
     /* Above here is the same for sub, format and eval.  */
     SV *	old_namesv;
     OP *	old_eval_root;
@@ -738,7 +738,7 @@ struct block_eval {
 	cx->blk_eval.old_eval_root = PL_eval_root;			\
 	cx->blk_eval.cur_text = PL_parser ? PL_parser->linestr : NULL;	\
 	cx->blk_eval.cv = NULL; /* set by doeval(), as applicable */	\
-	cx->blk_eval.retop = NULL;					\
+	cx->blk_eval.ret_instr = NULL;					\
 	cx->blk_eval.cur_top_env = PL_top_env; 				\
     } STMT_END
 
@@ -818,11 +818,11 @@ struct block_loop {
 
 /* given/when context */
 struct block_givwhen {
-	OP *leave_op;
+	INSTRUCTION *leave_instr;
 };
 
 #define PUSHGIVEN(cx)							\
-	cx->blk_givwhen.leave_op = cLOGOP->op_other;
+	cx->blk_givwhen.leave_instr = cLOGOP->op_other;
 
 #define PUSHWHEN PUSHGIVEN
 
@@ -1203,7 +1203,7 @@ See L<perlcall/LIGHTWEIGHT CALLBACKS>.
     SV **newsp;			/* set by POPBLOCK */			\
     PERL_CONTEXT *cx;							\
     CV *multicall_cv;							\
-    OP *multicall_cop;							\
+    INSTRUCTION *multicall_instr;					\
     bool multicall_oldcatch; 						\
     U8 hasargs = 0		/* used by PUSHSUB */
 
@@ -1226,12 +1226,12 @@ See L<perlcall/LIGHTWEIGHT CALLBACKS>.
 	SAVECOMPPAD();							\
 	PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv));			\
 	multicall_cv = cv;						\
-	multicall_cop = CvSTART(cv);					\
+	multicall_instr = CvSTART(cv);					\
     } STMT_END
 
 #define MULTICALL \
     STMT_START {							\
-	PL_op = multicall_cop;						\
+	PL_op = multicall_instr;					\
 	CALLRUNOPS(aTHX);						\
     } STMT_END
 
diff --git a/deb.c b/deb.c
index 3664d07..fe79111 100644
--- a/deb.c
+++ b/deb.c
@@ -302,10 +302,10 @@ Perl_deb_stack_all(pTHX)
 		if (CxTYPE(cx) == CXt_EVAL || CxTYPE(cx) == CXt_SUB
 			|| CxTYPE(cx) == CXt_FORMAT)
 		{
-		    const OP * const retop = cx->blk_sub.retop;
+		    const INSTRUCTION * const ret_instr = cx->blk_sub.ret_instr;
 
-		    PerlIO_printf(Perl_debug_log, "  retop=%s\n",
-			    retop ? OP_NAME(retop) : "(null)"
+		    PerlIO_printf(Perl_debug_log, "  ret_instr=%s\n",
+			    ret_instr ? OP_NAME(ret_instr) : "(null)"
 		    );
 		}
 	    }
diff --git a/doop.c b/doop.c
index c11555f..11bac09 100644
--- a/doop.c
+++ b/doop.c
@@ -1219,7 +1219,7 @@ finish:
     SvTAINT(sv);
 }
 
-OP *
+INSTRUCTION *
 Perl_do_kv(pTHX)
 {
     dVAR;
diff --git a/embed.fnc b/embed.fnc
index a84a958..b4f174a 100644
--- a/embed.fnc
+++ b/embed.fnc
@@ -248,7 +248,7 @@ Aprd	|void	|croak_xs_usage	|NN const CV *const cv \
 
 #if defined(PERL_IMPLICIT_CONTEXT)
 Afnrp	|void	|croak_nocontext|NULLOK const char* pat|...
-Afnp	|OP*	|die_nocontext	|NULLOK const char* pat|...
+Afnp	|INSTRUCTION*	|die_nocontext	|NULLOK const char* pat|...
 Afnp	|void	|deb_nocontext	|NN const char* pat|...
 Afnp	|char*	|form_nocontext	|NN const char* pat|...
 Anp	|void	|load_module_nocontext|U32 flags|NN SV* name|NULLOK SV* ver|...
@@ -298,8 +298,8 @@ Anp	|char*	|delimcpy	|NN char* to|NN const char* toend|NN const char* from \
 				|NN const char* fromend|int delim|NN I32* retlen
 : Used in op.c, perl.c
 pM	|void	|delete_eval_scope
-Apd	|OP*	|die_sv		|NN SV *baseex
-Afpd	|OP*	|die		|NULLOK const char* pat|...
+Apd	|INSTRUCTION*	|die_sv		|NN SV *baseex
+Afpd	|INSTRUCTION*	|die		|NULLOK const char* pat|...
 : Used in util.c
 pr	|void	|die_unwind	|NN SV* msv
 Ap	|void	|dounwind	|I32 cxix
@@ -347,7 +347,7 @@ p	|I32	|do_shmio	|I32 optype|NN SV** mark|NN SV** sp
 #endif
 Ap	|void	|do_join	|NN SV *sv|NN SV *delim|NN SV **mark|NN SV **sp
 : Used in pp.c and pp_hot.c, prototype generated by regen/opcode.pl
-: p	|OP*	|do_kv
+: p	|INSTRUCTION*	|do_kv
 : used in pp.c, pp_hot.c
 pR	|I32	|do_ncmp	|NN SV *const left|NN SV *const right
 Apmb	|bool	|do_open	|NN GV* gv|NN const char* name|I32 len|int as_raw \
@@ -362,7 +362,7 @@ Ap	|bool	|do_openn	|NN GV *gv|NN const char *oname|I32 len \
 : Used in pp_hot.c and pp_sys.c
 p	|bool	|do_print	|NULLOK SV* sv|NN PerlIO* fp
 : Used in pp_sys.c
-pR	|OP*	|do_readline
+pR	|INSTRUCTION*	|do_readline
 : Defined in doio.c, used only in pp_sys.c
 p	|bool	|do_seek	|NULLOK GV* gv|Off_t pos|int whence
 Ap	|void	|do_sprintf	|NN SV* sv|I32 len|NN SV** sarg
@@ -1698,7 +1698,7 @@ s	|SV *	|incpush_if_exists|NN AV *const av|NN SV *dir|NN SV *const stem
 
 #if defined(PERL_IN_PP_C)
 s	|void	|do_chomp	|NN SV *retval|NN SV *sv|bool chomping
-s	|OP*	|do_delete_local
+s	|INSTRUCTION*	|do_delete_local
 sR	|SV*	|refto		|NN SV* sv
 #endif
 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C)
@@ -1726,7 +1726,7 @@ snR	|char *	|bytes_to_uni	|NN const U8 *start|STRLEN len|NN char *dest
 #endif
 
 #if defined(PERL_IN_PP_CTL_C)
-sR	|OP*	|docatch	|NULLOK OP *o
+sR	|INSTRUCTION*	|docatch	|NULLOK INSTRUCTION *instr
 sR	|OP*	|dofindlabel	|NN OP *o|NN const char *label|NN OP **opstack|NN OP **oplimit
 s	|MAGIC *|doparseform	|NN SV *sv
 snR	|bool	|num_overflow	|NV value|I32 fldsize|I32 frcsize
@@ -1748,7 +1748,7 @@ sR	|I32	|run_user_filter|int idx|NN SV *buf_sv|int maxlen
 sR	|PMOP*	|make_matcher	|NN REGEXP* re
 sR	|bool	|matcher_matches_sv|NN PMOP* matcher|NN SV* sv
 s	|void	|destroy_matcher|NN PMOP* matcher
-s	|OP*	|do_smartmatch	|NULLOK HV* seen_this|NULLOK HV* seen_other
+s	|INSTRUCTION*	|do_smartmatch	|NULLOK HV* seen_this|NULLOK HV* seen_other
 #endif
 
 #if defined(PERL_IN_PP_HOT_C)
@@ -1770,13 +1770,13 @@ s	|void	|qsortsvu	|NULLOK SV** array|size_t num_elts|NN SVCOMPARE_t compare
 #endif
 
 #if defined(PERL_IN_PP_SYS_C)
-s	|OP*	|doform		|NN CV *cv|NN GV *gv|NN OP *retop
+s	|INSTRUCTION*	|doform		|NN CV *cv|NN GV *gv|NN INSTRUCTION *ret_instr
 #  if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
 sR	|int	|dooneliner	|NN const char *cmd|NN const char *filename
 #  endif
 s	|SV *	|space_join_names_mortal|NN char *const *array
 #endif
-p	|OP *	|tied_method|NN const char *const methname|NN SV **sp \
+p	|INSTRUCTION *	|tied_method|NN const char *const methname|NN SV **sp \
 				|NN SV *const sv|NN const MAGIC *const mg \
 				|const U32 flags|U32 argc|...
 
diff --git a/embedvar.h b/embedvar.h
index 2405ee5..935cf92 100644
--- a/embedvar.h
+++ b/embedvar.h
@@ -252,8 +252,8 @@
 #define PL_rehash_seed		(vTHX->Irehash_seed)
 #define PL_rehash_seed_set	(vTHX->Irehash_seed_set)
 #define PL_replgv		(vTHX->Ireplgv)
+#define PL_restart_instr	(vTHX->Irestart_instr)
 #define PL_restartjmpenv	(vTHX->Irestartjmpenv)
-#define PL_restartop		(vTHX->Irestartop)
 #define PL_rpeepp		(vTHX->Irpeepp)
 #define PL_rs			(vTHX->Irs)
 #define PL_runops		(vTHX->Irunops)
@@ -582,8 +582,8 @@
 #define PL_Irehash_seed		PL_rehash_seed
 #define PL_Irehash_seed_set	PL_rehash_seed_set
 #define PL_Ireplgv		PL_replgv
+#define PL_Irestart_instr	PL_restart_instr
 #define PL_Irestartjmpenv	PL_restartjmpenv
-#define PL_Irestartop		PL_restartop
 #define PL_Irpeepp		PL_rpeepp
 #define PL_Irs			PL_rs
 #define PL_Irunops		PL_runops
diff --git a/ext/XS-APItest/APItest.pm b/ext/XS-APItest/APItest.pm
index c0326b3..5da52c2 100644
--- a/ext/XS-APItest/APItest.pm
+++ b/ext/XS-APItest/APItest.pm
@@ -50,7 +50,7 @@ sub import {
     }
 }
 
-our $VERSION = '0.30';
+our $VERSION = '0.31';
 
 use vars '$WARNINGS_ON_BOOTSTRAP';
 use vars map "\$${_}_called_PP", qw(BEGIN UNITCHECK CHECK INIT END);
diff --git a/ext/XS-APItest/APItest.xs b/ext/XS-APItest/APItest.xs
index beb7e2c..7a347b7 100644
--- a/ext/XS-APItest/APItest.xs
+++ b/ext/XS-APItest/APItest.xs
@@ -540,7 +540,7 @@ THX_run_cleanup(pTHX_ void *cleanup_code_ref)
     LEAVE;
 }
 
-STATIC OP *
+STATIC INSTRUCTION *
 THX_pp_establish_cleanup(pTHX)
 {
     dSP;
@@ -1030,7 +1030,7 @@ static int my_keyword_plugin(pTHX_
 
 static XOP my_xop;
 
-static OP *
+static INSTRUCTION *
 pp_xop(pTHX)
 {
     return PL_op->op_next;
diff --git a/intrpvar.h b/intrpvar.h
index 4a6122f..3f52757 100644
--- a/intrpvar.h
+++ b/intrpvar.h
@@ -126,7 +126,7 @@ PERLVAR(Itoptarget,	SV *)
 PERLVAR(Idefstash,	HV *)		/* main symbol table */
 PERLVAR(Icurstash,	HV *)		/* symbol table for current package */
 
-PERLVAR(Irestartop,	OP *)		/* propagating an error from croak? */
+PERLVAR(Irestart_instr,	INSTRUCTION *)		/* propagating an error from croak? */
 PERLVAR(Irestartjmpenv,	JMPENV *)	/* target frame for longjmp in die */
 PERLVAR(Icurcop,	COP *)
 PERLVAR(Icurstack,	AV *)		/* THE STACK */
@@ -144,7 +144,7 @@ PERLVAR(Ihv_fetch_ent_mh, HE*)		/* owned by hv_fetch_ent() */
 PERLVAR(Ilastgotoprobe,	OP*)		/* from pp_ctl.c */
 
 /* sort stuff */
-PERLVAR(Isortcop,	OP *)		/* user defined sort routine */
+PERLVAR(Isortcop,	INSTRUCTION *)		/* user defined sort routine */
 PERLVAR(Isortstash,	HV *)		/* which is in some package or other */
 PERLVAR(Ifirstgv,	GV *)		/* $a */
 PERLVAR(Isecondgv,	GV *)		/* $b */
@@ -398,9 +398,9 @@ PERLVARI(Iop_mask,	char *,	NULL)	/* masked operations for safe evals */
 /* current interpreter roots */
 PERLVAR(Imain_cv,	CV *)
 PERLVAR(Imain_root,	OP *)
-PERLVAR(Imain_start,	OP *)
+PERLVAR(Imain_start,	INSTRUCTION *)
 PERLVAR(Ieval_root,	OP *)
-PERLVAR(Ieval_start,	OP *)
+PERLVAR(Ieval_start,	INSTRUCTION *)
 
 /* runtime control stuff */
 PERLVARI(Icurcopdb,	COP *,	NULL)
diff --git a/op.h b/op.h
index cbcac7d..0f96d66 100644
--- a/op.h
+++ b/op.h
@@ -54,7 +54,7 @@ typedef PERL_BITFIELD16 Optype;
 #define BASEOP				\
     OP*		op_next;		\
     OP*		op_sibling;		\
-    OP*		(*op_ppaddr)(pTHX);	\
+    INSTRUCTION*		(*op_ppaddr)(pTHX);	\
     MADPROP_IN_BASEOP			\
     PADOFFSET	op_targ;		\
     PERL_BITFIELD16 op_type:9;		\
diff --git a/perl.c b/perl.c
index 1f69e05..9751268 100644
--- a/perl.c
+++ b/perl.c
@@ -2229,7 +2229,7 @@ S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
 
     ENTER;
     PL_restartjmpenv = NULL;
-    PL_restartop = 0;
+    PL_restart_instr = NULL;
     return NULL;
 }
 
@@ -2285,7 +2285,7 @@ perl_run(pTHXx)
 	ret = STATUS_EXIT;
 	break;
     case 3:
-	if (PL_restartop) {
+	if (PL_restart_instr) {
 	    POPSTACK_TO(PL_mainstack);
 	    goto redo_body;
 	}
@@ -2306,7 +2306,7 @@ S_run_body(pTHX_ I32 oldscope)
     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
                     PL_sawampersand ? "Enabling" : "Omitting"));
 
-    if (!PL_restartop) {
+    if (!PL_restart_instr) {
 #ifdef PERL_MAD
 	if (PL_xmlfp) {
 	    xmldump_all();
@@ -2339,10 +2339,10 @@ S_run_body(pTHX_ I32 oldscope)
 
     PERL_SET_PHASE(PERL_PHASE_RUN);
 
-    if (PL_restartop) {
+    if (PL_restart_instr) {
 	PL_restartjmpenv = NULL;
-	PL_op = PL_restartop;
-	PL_restartop = 0;
+	PL_op = PL_restart_instr;
+	PL_restart_instr = 0;
 	CALLRUNOPS(aTHX);
     }
     else if (PL_main_start) {
@@ -2668,10 +2668,10 @@ Perl_call_sv(pTHX_ SV *sv, VOL I32 flags)
 	    my_exit_jump();
 	    /* NOTREACHED */
 	case 3:
-	    if (PL_restartop) {
+	    if (PL_restart_instr) {
 		PL_restartjmpenv = NULL;
-		PL_op = PL_restartop;
-		PL_restartop = 0;
+		PL_op = PL_restart_instr;
+		PL_restart_instr = 0;
 		goto redo_body;
 	    }
 	    PL_stack_sp = PL_stack_base + oldmark;
@@ -2775,10 +2775,10 @@ Perl_eval_sv(pTHX_ SV *sv, I32 flags)
 	my_exit_jump();
 	/* NOTREACHED */
     case 3:
-	if (PL_restartop) {
+	if (PL_restart_instr) {
 	    PL_restartjmpenv = NULL;
-	    PL_op = PL_restartop;
-	    PL_restartop = 0;
+	    PL_op = PL_restart_instr;
+	    PL_restart_instr = 0;
 	    goto redo_body;
 	}
       fail:
@@ -4753,7 +4753,7 @@ Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
 	    my_exit_jump();
 	    /* NOTREACHED */
 	case 3:
-	    if (PL_restartop) {
+	    if (PL_restart_instr) {
 		PL_curcop = &PL_compiling;
 		CopLINE_set(PL_curcop, oldline);
 		JMPENV_JUMP(3);
diff --git a/perl.h b/perl.h
index 79989d9..aaaa6b3 100644
--- a/perl.h
+++ b/perl.h
@@ -2422,6 +2422,8 @@ typedef struct loop LOOP;
 typedef struct block_hooks BHK;
 typedef struct custom_op XOP;
 
+typedef struct op INSTRUCTION;
+
 typedef struct interpreter PerlInterpreter;
 
 /* Amdahl's <ksync.h> has struct sv */
@@ -4172,7 +4174,7 @@ struct perl_memory_debug_header {
 typedef int (*runops_proc_t)(pTHX);
 typedef void (*share_proc_t) (pTHX_ SV *sv);
 typedef int  (*thrhook_proc_t) (pTHX);
-typedef OP* (*PPADDR_t[]) (pTHX);
+typedef INSTRUCTION* (*PPADDR_t[]) (pTHX);
 typedef bool (*destroyable_proc_t) (pTHX_ SV *sv);
 typedef void (*despatch_signals_proc_t) (pTHX);
 
@@ -4894,7 +4896,7 @@ typedef void (*XSINIT_t) (pTHX);
 typedef void (*ATEXIT_t) (pTHX_ void*);
 typedef void (*XSUBADDR_t) (pTHX_ CV *);
 
-typedef OP* (*Perl_ppaddr_t)(pTHX);
+typedef INSTRUCTION* (*Perl_ppaddr_t)(pTHX);
 typedef OP* (*Perl_check_t) (pTHX_ OP*);
 typedef void(*Perl_ophook_t)(pTHX_ OP*);
 typedef int (*Perl_keyword_plugin_t)(pTHX_ char*, STRLEN, OP**);
@@ -5009,7 +5011,7 @@ struct tempsym; /* defined in pp_pack.c */
 #undef PERL_CKDEF
 #undef PERL_PPDEF
 #define PERL_CKDEF(s)	PERL_CALLCONV OP *s (pTHX_ OP *o);
-#define PERL_PPDEF(s)	PERL_CALLCONV OP *s (pTHX);
+#define PERL_PPDEF(s)	PERL_CALLCONV INSTRUCTION *s (pTHX);
 
 #ifdef MYMALLOC
 #  include "malloc_ctl.h"
diff --git a/pod/perlinterp.pod b/pod/perlinterp.pod
index c7f2120..0d2b7f3 100644
--- a/pod/perlinterp.pod
+++ b/pod/perlinterp.pod
@@ -188,9 +188,9 @@ cleanup still occurs during an C<exit>.
 
 If a C<die> can find a C<CxEVAL> block on the context stack, then the
 stack is popped to that level and the return op in that block is
-assigned to C<PL_restartop>; then a C<JMPENV_JUMP(3)> is performed.
+assigned to C<PL_restart_instr>; then a C<JMPENV_JUMP(3)> is performed.
 This normally passes control back to the guard. In the case of
-C<perl_run> and C<call_sv>, a non-null C<PL_restartop> triggers
+C<perl_run> and C<call_sv>, a non-null C<PL_restart_instr> triggers
 re-entry to the runops loop. The is the normal way that C<die> or
 C<croak> is handled within an C<eval>.
 
@@ -252,15 +252,15 @@ and the context and data stacks, as shown by C<-Dstv>, look like:
     STACK 0: MAIN
       CX 0: BLOCK  =>
       CX 1: EVAL   => AV()  PV("A"\0)
-      retop=leave
+      ret_instr=leave
     STACK 1: MAGIC
       CX 0: SUB    =>
-      retop=(null)
+      ret_instr=(null)
       CX 1: EVAL   => *
-    retop=nextstate
+    ret_instr=nextstate
 
 The die pops the first C<CxEVAL> off the context stack, sets
-C<PL_restartop> from it, does a C<JMPENV_JUMP(3)>, and control returns
+C<PL_restart_instr> from it, does a C<JMPENV_JUMP(3)>, and control returns
 to the top C<docatch>. This then starts another third-level runops
 level, which executes the nextstate, pushmark and die ops on line 4. At
 the point that the second C<pp_die> is called, the C call stack looks
@@ -271,10 +271,10 @@ the context stack now looks like this, ie with the top CxEVAL popped:
     STACK 0: MAIN
       CX 0: BLOCK  =>
       CX 1: EVAL   => AV()  PV("A"\0)
-      retop=leave
+      ret_instr=leave
     STACK 1: MAGIC
       CX 0: SUB    =>
-      retop=(null)
+      ret_instr=(null)
 
 The die on line 4 pops the context stack back down to the CxEVAL,
 leaving it as:
@@ -282,7 +282,7 @@ leaving it as:
     STACK 0: MAIN
       CX 0: BLOCK  =>
 
-As usual, C<PL_restartop> is extracted from the C<CxEVAL>, and a
+As usual, C<PL_restart_instr> is extracted from the C<CxEVAL>, and a
 C<JMPENV_JUMP(3)> done, which pops the C stack back to the docatch:
 
     S_docatch
@@ -303,7 +303,7 @@ and the C stack unwinds to:
     perl_run
     main
 
-Because C<PL_restartop> is non-null, C<run_body> starts a new runops
+Because C<PL_restart_instr> is non-null, C<run_body> starts a new runops
 loop and execution continues.
 
 =head2 INTERNAL VARIABLE TYPES
diff --git a/pp.c b/pp.c
index 8649bec..4196b31 100644
--- a/pp.c
+++ b/pp.c
@@ -127,7 +127,7 @@ PP(pp_padhv)
     }
     gimme = GIMME_V;
     if (gimme == G_ARRAY) {
-	RETURNOP(Perl_do_kv(aTHX));
+	RETURNINSTR(Perl_do_kv(aTHX));
     }
     else if (gimme == G_SCALAR) {
 	SV* const sv = Perl_hv_scalar(aTHX_ MUTABLE_HV(TARG));
@@ -4574,7 +4574,7 @@ PP(pp_each)
     RETURN;
 }
 
-STATIC OP *
+STATIC INSTRUCTION *
 S_do_delete_local(pTHX)
 {
     dVAR;
@@ -5898,9 +5898,9 @@ PP(pp_once)
     if (SvPADSTALE(sv)) {
 	/* First time. */
 	SvPADSTALE_off(sv);
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     }
-    RETURNOP(cLOGOP->op_next);
+    RETURNINSTR(cLOGOP->op_next);
 }
 
 PP(pp_lock)
diff --git a/pp.h b/pp.h
index 5cde92b..e5ab430 100644
--- a/pp.h
+++ b/pp.h
@@ -8,7 +8,7 @@
  *
  */
 
-#define PP(s) OP * Perl_##s(pTHX)
+#define PP(s) INSTRUCTION * Perl_##s(pTHX)
 
 /*
 =head1 Stack Manipulation Macros
@@ -119,7 +119,7 @@ Pops a long off the stack.
 
 #define PUTBACK		PL_stack_sp = sp
 #define RETURN		return (PUTBACK, NORMAL)
-#define RETURNOP(o)	return (PUTBACK, o)
+#define RETURNINSTR(o)	return (PUTBACK, o)
 #define RETURNX(x)	return (x, PUTBACK, NORMAL)
 
 #define POPs		(*sp--)
diff --git a/pp_ctl.c b/pp_ctl.c
index f226e0d..62d5c7c 100644
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -375,7 +375,7 @@ PP(pp_substcont)
 	    TAINT_NOT;
 	    LEAVE_SCOPE(cx->sb_oldsave);
 	    POPSUBST(cx);
-	    RETURNOP(pm->op_next);
+	    RETURNINSTR(pm->op_next);
 	    /* NOTREACHED */
 	}
 	cx->sb_iters = saviters;
@@ -433,7 +433,7 @@ PP(pp_substcont)
     }
     rxres_save(&cx->sb_rxres, rx);
     PL_curpm = pm;
-    RETURNOP(pm->op_pmstashstartu.op_pmreplstart);
+    RETURNINSTR(pm->op_pmstashstartu.op_pmreplstart);
 }
 
 void
@@ -1034,7 +1034,7 @@ PP(pp_formline)
 	    FmLINES(PL_formtarget) += lines;
 	    SP = ORIGMARK;
 	    if (fpc[-1] == FF_BLANK)
-		RETURNOP(cLISTOP->op_first);
+		RETURNINSTR(cLISTOP->op_first);
 	    else
 		RETPUSHYES;
 	}
@@ -1050,7 +1050,7 @@ PP(pp_grepstart)
 	(void)POPMARK;
 	if (GIMME_V == G_SCALAR)
 	    mXPUSHi(0);
-	RETURNOP(PL_op->op_next->op_next);
+	RETURNINSTR(PL_op->op_next->op_next);
     }
     PL_stack_sp = PL_stack_base + *PL_markstack_ptr + 1;
     Perl_pp_pushmark(aTHX);				/* push dst */
@@ -1220,7 +1220,7 @@ PP(pp_mapwhile)
 	else
 	    DEFSV_set(src);
 
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     }
 }
 
@@ -1243,7 +1243,7 @@ PP(pp_flip)
     dSP;
 
     if (GIMME == G_ARRAY) {
-	RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
+	RETURNINSTR(((LOGOP*)cUNOP->op_first)->op_other);
     }
     else {
 	dTOPss;
@@ -1272,7 +1272,7 @@ PP(pp_flip)
 	    else {
 		sv_setiv(targ, 0);
 		SP--;
-		RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
+		RETURNINSTR(((LOGOP*)cUNOP->op_first)->op_other);
 	    }
 	}
 	sv_setpvs(TARG, "");
@@ -1724,7 +1724,7 @@ Perl_die_unwind(pTHX_ SV *msv)
 	    SV **newsp;
 	    COP *oldcop;
 	    JMPENV *restartjmpenv;
-	    OP *restartop;
+	    INSTRUCTION *restart_instr;
 
 	    if (cxix < cxstack_ix)
 		dounwind(cxix);
@@ -1741,7 +1741,7 @@ Perl_die_unwind(pTHX_ SV *msv)
 	    namesv = cx->blk_eval.old_namesv;
 	    oldcop = cx->blk_oldcop;
 	    restartjmpenv = cx->blk_eval.cur_top_env;
-	    restartop = cx->blk_eval.retop;
+	    restart_instr = cx->blk_eval.ret_instr;
 
 	    if (gimme == G_SCALAR)
 		*++newsp = &PL_sv_undef;
@@ -1775,7 +1775,7 @@ Perl_die_unwind(pTHX_ SV *msv)
 		sv_setsv(ERRSV, exceptsv);
 	    }
 	    PL_restartjmpenv = restartjmpenv;
-	    PL_restartop = restartop;
+	    PL_restart_instr = restart_instr;
 	    JMPENV_JUMP(3);
 	    /* NOTREACHED */
 	}
@@ -2053,11 +2053,11 @@ PP(pp_dbstate)
 	else {
 	    PUSHBLOCK(cx, CXt_SUB, SP);
 	    PUSHSUB_DB(cx);
-	    cx->blk_sub.retop = PL_op->op_next;
+	    cx->blk_sub.ret_instr = PL_op->op_next;
 	    CvDEPTH(cv)++;
 	    SAVECOMPPAD();
 	    PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1);
-	    RETURNOP(CvSTART(cv));
+	    RETURNINSTR(CvSTART(cv));
 	}
     }
     else
@@ -2358,12 +2358,12 @@ S_return_lvalues(pTHX_ SV **mark, SV **sp, SV **newsp, I32 gimme,
 	    SvGETMAGIC(TOPs);
 	    if (!SvOK(TOPs)) {
 		U8 deref_type;
-		if (cx->blk_sub.retop->op_type == OP_RV2SV)
+		if (cx->blk_sub.ret_instr->op_type == OP_RV2SV)
 		    deref_type = OPpDEREF_SV;
-		else if (cx->blk_sub.retop->op_type == OP_RV2AV)
+		else if (cx->blk_sub.ret_instr->op_type == OP_RV2AV)
 		    deref_type = OPpDEREF_AV;
 		else {
-		    assert(cx->blk_sub.retop->op_type == OP_RV2HV);
+		    assert(cx->blk_sub.ret_instr->op_type == OP_RV2HV);
 		    deref_type = OPpDEREF_HV;
 		}
 		vivify_ref(TOPs, deref_type);
@@ -2423,7 +2423,7 @@ PP(pp_return)
     I32 optype = 0;
     SV *namesv;
     SV *sv;
-    OP *retop = NULL;
+    INSTRUCTION *ret_instr = NULL;
 
     const I32 cxix = dopoptosub(cxstack_ix);
 
@@ -2458,7 +2458,7 @@ PP(pp_return)
     case CXt_SUB:
 	popsub2 = TRUE;
 	lval = !!CvLVALUE(cx->blk_sub.cv);
-	retop = cx->blk_sub.retop;
+	ret_instr = cx->blk_sub.ret_instr;
 	gmagic = CxLVAL(cx) & OPpENTERSUB_DEREF;
 	cxstack_ix++; /* preserve cx entry on stack for use by POPSUB */
 	break;
@@ -2467,7 +2467,7 @@ PP(pp_return)
 	    clear_errsv = TRUE;
 	POPEVAL(cx);
 	namesv = cx->blk_eval.old_namesv;
-	retop = cx->blk_eval.retop;
+	ret_instr = cx->blk_eval.ret_instr;
 	if (CxTRYBLOCK(cx))
 	    break;
 	if (optype == OP_REQUIRE &&
@@ -2482,7 +2482,7 @@ PP(pp_return)
 	break;
     case CXt_FORMAT:
 	POPFORMAT(cx);
-	retop = cx->blk_sub.retop;
+	ret_instr = cx->blk_sub.ret_instr;
 	break;
     default:
 	DIE(aTHX_ "panic: return");
@@ -2545,7 +2545,7 @@ PP(pp_return)
     if (clear_errsv) {
 	CLEAR_ERRSV();
     }
-    return retop;
+    return ret_instr;
 }
 
 /* This duplicates parts of pp_leavesub, so that it can share code with
@@ -2576,7 +2576,7 @@ PP(pp_leavesublv)
     PL_curpm = newpm;	/* ... and pop $1 et al */
 
     LEAVESUB(sv);
-    return cx->blk_sub.retop;
+    return cx->blk_sub.ret_instr;
 }
 
 PP(pp_last)
@@ -2587,7 +2587,7 @@ PP(pp_last)
     I32 pop2 = 0;
     I32 gimme;
     I32 optype;
-    OP *nextop = NULL;
+    INSTRUCTION *next_instr = NULL;
     SV **newsp;
     PMOP *newpm;
     SV **mark;
@@ -2617,19 +2617,19 @@ PP(pp_last)
     case CXt_LOOP_PLAIN:
 	pop2 = CxTYPE(cx);
 	newsp = PL_stack_base + cx->blk_loop.resetsp;
-	nextop = cx->blk_loop.my_op->op_lastop->op_next;
+	next_instr = cx->blk_loop.my_op->op_lastop->op_next;
 	break;
     case CXt_SUB:
 	pop2 = CXt_SUB;
-	nextop = cx->blk_sub.retop;
+	next_instr = cx->blk_sub.ret_instr;
 	break;
     case CXt_EVAL:
 	POPEVAL(cx);
-	nextop = cx->blk_eval.retop;
+	next_instr = cx->blk_eval.ret_instr;
 	break;
     case CXt_FORMAT:
 	POPFORMAT(cx);
-	nextop = cx->blk_sub.retop;
+	next_instr = cx->blk_sub.ret_instr;
 	break;
     default:
 	DIE(aTHX_ "panic: last");
@@ -2660,7 +2660,7 @@ PP(pp_last)
     LEAVESUB(sv);
     PERL_UNUSED_VAR(optype);
     PERL_UNUSED_VAR(gimme);
-    return nextop;
+    return next_instr;
 }
 
 PP(pp_next)
@@ -2699,7 +2699,7 @@ PP(pp_redo)
     I32 cxix;
     register PERL_CONTEXT *cx;
     I32 oldsave;
-    OP* redo_op;
+    INSTRUCTION* redo_instr;
 
     if (PL_op->op_flags & OPf_SPECIAL) {
 	cxix = dopoptoloop(cxstack_ix);
@@ -2714,12 +2714,12 @@ PP(pp_redo)
     if (cxix < cxstack_ix)
 	dounwind(cxix);
 
-    redo_op = cxstack[cxix].blk_loop.my_op->op_redoop;
-    if (redo_op->op_type == OP_ENTER) {
+    redo_instr = cxstack[cxix].blk_loop.my_op->op_redoop;
+    if (redo_instr->op_type == OP_ENTER) {
 	/* pop one less context to avoid $x being freed in while (my $x..) */
 	cxstack_ix++;
 	assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_BLOCK);
-	redo_op = redo_op->op_next;
+	redo_instr = redo_instr->op_next;
     }
 
     TOPBLOCK(cx);
@@ -2727,7 +2727,7 @@ PP(pp_redo)
     LEAVE_SCOPE(oldsave);
     FREETMPS;
     PL_curcop = cx->blk_oldcop;
-    return redo_op;
+    return redo_instr;
 }
 
 STATIC OP *
@@ -2884,7 +2884,7 @@ PP(pp_goto)
 	    SAVETMPS;
 	    SAVEFREESV(cv); /* later, undo the 'avoid premature free' hack */
 	    if (CvISXSUB(cv)) {
-		OP* const retop = cx->blk_sub.retop;
+		INSTRUCTION* const ret_instr = cx->blk_sub.ret_instr;
 		SV **newsp __attribute__unused__;
 		I32 gimme __attribute__unused__;
 		if (reified) {
@@ -2900,7 +2900,7 @@ PP(pp_goto)
 		PUTBACK;
 		(void)(*CvXSUB(cv))(aTHX_ cv);
 		LEAVE;
-		return retop;
+		return ret_instr;
 	    }
 	    else {
 		AV* const padlist = CvPADLIST(cv);
@@ -2970,7 +2970,7 @@ PP(pp_goto)
 			}
 		    }
 		}
-		RETURNOP(CvSTART(cv));
+		RETURNINSTR(CvSTART(cv));
 	    }
 	}
 	else {
@@ -3113,16 +3113,16 @@ PP(pp_goto)
 #ifdef VMS
 	if (!retop) retop = PL_main_start;
 #endif
-	PL_restartop = retop;
+	PL_restart_instr = retop;
 	PL_do_undump = TRUE;
 
 	my_unexec();
 
-	PL_restartop = 0;		/* hmm, must be GNU unexec().. */
+	PL_restart_instr = NULL;		/* hmm, must be GNU unexec().. */
 	PL_do_undump = FALSE;
     }
 
-    RETURNOP(retop);
+    RETURNINSTR(retop);
 }
 
 PP(pp_exit)
@@ -3194,18 +3194,18 @@ establish a local jmpenv to handle exception traps.
 
 =cut
 */
-STATIC OP *
-S_docatch(pTHX_ OP *o)
+STATIC INSTRUCTION *
+S_docatch(pTHX_ INSTRUCTION *instr)
 {
     dVAR;
     int ret;
-    OP * const oldop = PL_op;
+    OP * const old_instr = PL_op;
     dJMPENV;
 
 #ifdef DEBUGGING
     assert(CATCH_GET == TRUE);
 #endif
-    PL_op = o;
+    PL_op = instr;
 
     JMPENV_PUSH(ret);
     switch (ret) {
@@ -3218,21 +3218,21 @@ S_docatch(pTHX_ OP *o)
 	break;
     case 3:
 	/* die caught by an inner eval - continue inner loop */
-	if (PL_restartop && PL_restartjmpenv == PL_top_env) {
+	if (PL_restart_instr && PL_restartjmpenv == PL_top_env) {
 	    PL_restartjmpenv = NULL;
-	    PL_op = PL_restartop;
-	    PL_restartop = 0;
+	    PL_op = PL_restart_instr;
+	    PL_restart_instr = 0;
 	    goto redo_body;
 	}
 	/* FALL THROUGH */
     default:
 	JMPENV_POP;
-	PL_op = oldop;
+	PL_op = old_instr;
 	JMPENV_JUMP(ret);
 	/* NOTREACHED */
     }
     JMPENV_POP;
-    PL_op = oldop;
+    PL_op = old_instr;
     return NULL;
 }
 
@@ -3618,7 +3618,7 @@ S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq)
     }
 
     if (PL_unitcheckav) {
-	OP *es = PL_eval_start;
+	INSTRUCTION *es = PL_eval_start;
 	call_list(PL_scopestack_ix, PL_unitcheckav);
 	PL_eval_start = es;
     }
@@ -3701,7 +3701,7 @@ PP(pp_require)
     SV *filter_sub = NULL;
     SV *hook_sv = NULL;
     SV *encoding;
-    OP *op;
+    INSTRUCTION *next_instr;
 
     sv = POPs;
     if ( (SvNIOKp(sv) || SvVOK(sv)) && PL_op->op_type != OP_DOFILE) {
@@ -4087,7 +4087,7 @@ PP(pp_require)
     /* switch to eval mode */
     PUSHBLOCK(cx, CXt_EVAL, SP);
     PUSHEVAL(cx, name);
-    cx->blk_eval.retop = PL_op->op_next;
+    cx->blk_eval.ret_instr = PL_op->op_next;
 
     SAVECOPLINE(&PL_compiling);
     CopLINE_set(&PL_compiling, 0);
@@ -4099,14 +4099,14 @@ PP(pp_require)
     PL_encoding = NULL;
 
     if (doeval(gimme, NULL, NULL, PL_curcop->cop_seq))
-	op = DOCATCH(PL_eval_start);
+	next_instr = DOCATCH(PL_eval_start);
     else
-	op = PL_op->op_next;
+	next_instr = PL_op->op_next;
 
     /* Restore encoding. */
     PL_encoding = encoding;
 
-    return op;
+    return next_instr;
 }
 
 /* This is a op added to hold the hints hash for
@@ -4209,7 +4209,7 @@ PP(pp_entereval)
 
     PUSHBLOCK(cx, (CXt_EVAL|CXp_REAL), SP);
     PUSHEVAL(cx, 0);
-    cx->blk_eval.retop = PL_op->op_next;
+    cx->blk_eval.ret_instr = PL_op->op_next;
 
     /* prepare to compile string */
 
@@ -4254,7 +4254,7 @@ PP(pp_leaveeval)
     PMOP *newpm;
     I32 gimme;
     register PERL_CONTEXT *cx;
-    OP *retop;
+    INSTRUCTION *ret_instr;
     const U8 save_flags = PL_op -> op_flags;
     I32 optype;
     SV *namesv;
@@ -4263,7 +4263,7 @@ PP(pp_leaveeval)
     POPBLOCK(cx,newpm);
     POPEVAL(cx);
     namesv = cx->blk_eval.old_namesv;
-    retop = cx->blk_eval.retop;
+    ret_instr = cx->blk_eval.ret_instr;
 
     TAINT_NOT;
     SP = adjust_stack_on_leave((gimme == G_VOID) ? SP : newsp, SP, newsp,
@@ -4282,7 +4282,7 @@ PP(pp_leaveeval)
 	(void)hv_delete(GvHVn(PL_incgv),
 			SvPVX_const(namesv), SvCUR(namesv),
 			G_DISCARD);
-	retop = Perl_die(aTHX_ "%"SVf" did not return a true value",
+	ret_instr = Perl_die(aTHX_ "%"SVf" did not return a true value",
 			       SVfARG(namesv));
 	/* die_unwind() did LEAVE, or we won't be here */
     }
@@ -4293,7 +4293,7 @@ PP(pp_leaveeval)
 	}
     }
 
-    RETURNOP(retop);
+    RETURNINSTR(ret_instr);
 }
 
 /* Common code for Perl_call_sv and Perl_fold_constants, put here to keep it
@@ -4345,7 +4345,7 @@ PP(pp_entertry)
 {
     dVAR;
     PERL_CONTEXT * const cx = create_eval_scope(0);
-    cx->blk_eval.retop = cLOGOP->op_other->op_next;
+    cx->blk_eval.ret_instr = cLOGOP->op_other->op_next;
     return DOCATCH(PL_op->op_next);
 }
 
@@ -4464,7 +4464,7 @@ PP(pp_smartmatch)
 /* This version of do_smartmatch() implements the
  * table of smart matches that is found in perlsyn.
  */
-STATIC OP *
+STATIC INSTRUCTION *
 S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other)
 {
     dVAR;
@@ -4947,10 +4947,10 @@ PP(pp_enterwhen)
        fails, we don't want to push a context and then
        pop it again right away, so we skip straight
        to the op that follows the leavewhen.
-       RETURNOP calls PUTBACK which restores the stack pointer after the POPs.
+       RETURNINSTR calls PUTBACK which restores the stack pointer after the POPs.
     */
     if ((0 == (PL_op->op_flags & OPf_SPECIAL)) && !SvTRUEx(POPs))
-	RETURNOP(cLOGOP->op_other->op_next);
+	RETURNINSTR(cLOGOP->op_other->op_next);
 
     ENTER_with_name("when");
     SAVETMPS;
@@ -5000,7 +5000,7 @@ PP(pp_leavewhen)
 	return cx->blk_loop.my_op->op_nextop;
     }
     else
-	RETURNOP(cx->blk_givwhen.leave_op);
+	RETURNINSTR(cx->blk_givwhen.leave_instr);
 }
 
 PP(pp_continue)
@@ -5028,7 +5028,7 @@ PP(pp_continue)
     PL_curpm = newpm;   /* pop $1 et al */
 
     LEAVE_with_name("when");
-    RETURNOP(cx->blk_givwhen.leave_op->op_next);
+    RETURNINSTR(cx->blk_givwhen.leave_instr->op_next);
 }
 
 PP(pp_break)
@@ -5051,7 +5051,7 @@ PP(pp_break)
     /* Restore the sp at the time we entered the given block */
     TOPBLOCK(cx);
 
-    return cx->blk_givwhen.leave_op;
+    return cx->blk_givwhen.leave_instr;
 }
 
 static MAGIC *
diff --git a/pp_hot.c b/pp_hot.c
index 2f159e5..12eb3f0 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -105,7 +105,7 @@ PP(pp_and)
     else {
         if (PL_op->op_type == OP_AND)
 	    --SP;
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     }
 }
 
@@ -214,9 +214,9 @@ PP(pp_cond_expr)
     dVAR; dSP;
     PERL_ASYNC_CHECK();
     if (SvTRUEx(POPs))
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     else
-	RETURNOP(cLOGOP->op_next);
+	RETURNINSTR(cLOGOP->op_next);
 }
 
 PP(pp_unstack)
@@ -380,7 +380,7 @@ PP(pp_or)
     else {
 	if (PL_op->op_type == OP_OR)
             --SP;
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     }
 }
 
@@ -398,7 +398,7 @@ PP(pp_defined)
         if (!sv || !SvANY(sv)) {
 	    if (op_type == OP_DOR)
 		--SP;
-            RETURNOP(cLOGOP->op_other);
+            RETURNINSTR(cLOGOP->op_other);
         }
     }
     else {
@@ -434,7 +434,7 @@ PP(pp_defined)
             RETURN; 
         if(op_type == OP_DOR)
             --SP;
-        RETURNOP(cLOGOP->op_other);
+        RETURNINSTR(cLOGOP->op_other);
     }
     /* assuming OP_DEFINED */
     if(defined) 
@@ -1526,7 +1526,7 @@ ret_no:
     RETPUSHNO;
 }
 
-OP *
+INSTRUCTION *
 Perl_do_readline(pTHX)
 {
     dVAR; dSP; dTARGETSTACKED;
@@ -2307,7 +2307,7 @@ PP(pp_subst)
 	     * iters maxiters r_flags oldsave rxtainted orig dstr targ
 	     * s m strend rx once */
 	    PUSHSUBST(cx);
-	    RETURNOP(cPMOP->op_pmreplrootu.op_pmreplroot);
+	    RETURNINSTR(cPMOP->op_pmreplrootu.op_pmreplroot);
 	}
 	r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
 	do {
@@ -2450,7 +2450,7 @@ PP(pp_grepwhile)
 	else
 	    DEFSV_set(src);
 
-	RETURNOP(cLOGOP->op_other);
+	RETURNINSTR(cLOGOP->op_other);
     }
 }
 
@@ -2519,7 +2519,7 @@ PP(pp_leavesub)
     PL_curpm = newpm;	/* ... and pop $1 et al */
 
     LEAVESUB(sv);
-    return cx->blk_sub.retop;
+    return cx->blk_sub.ret_instr;
 }
 
 PP(pp_entersub)
@@ -2654,7 +2654,7 @@ try_autoload:
 	AV* const padlist = CvPADLIST(cv);
 	PUSHBLOCK(cx, CXt_SUB, MARK);
 	PUSHSUB(cx);
-	cx->blk_sub.retop = PL_op->op_next;
+	cx->blk_sub.ret_instr = PL_op->op_next;
 	CvDEPTH(cv)++;
 	/* XXX This would be a natural place to set C<PL_compcv = cv> so
 	 * that eval'' ops within this sub know the correct lexical space.
@@ -2711,7 +2711,7 @@ try_autoload:
 	if (CvDEPTH(cv) == PERL_SUB_DEPTH_WARN && ckWARN(WARN_RECURSION)
 	    && !(PERLDB_SUB && cv == GvCV(PL_DBsub)))
 	    sub_crush_depth(cv);
-	RETURNOP(CvSTART(cv));
+	RETURNINSTR(CvSTART(cv));
     }
     else {
 	I32 markix = TOPMARK;
diff --git a/pp_proto.h b/pp_proto.h
index 2b01d6b..a320c32 100644
--- a/pp_proto.h
+++ b/pp_proto.h
@@ -4,271 +4,271 @@
    Any changes made here will be lost!
  */
 
-PERL_CALLCONV OP *Perl_do_kv(pTHX);
-PERL_CALLCONV OP *Perl_pp_aassign(pTHX);
-PERL_CALLCONV OP *Perl_pp_abs(pTHX);
-PERL_CALLCONV OP *Perl_pp_accept(pTHX);
-PERL_CALLCONV OP *Perl_pp_add(pTHX);
-PERL_CALLCONV OP *Perl_pp_aeach(pTHX);
-PERL_CALLCONV OP *Perl_pp_aelem(pTHX);
-PERL_CALLCONV OP *Perl_pp_aelemfast(pTHX);
-PERL_CALLCONV OP *Perl_pp_akeys(pTHX);
-PERL_CALLCONV OP *Perl_pp_alarm(pTHX);
-PERL_CALLCONV OP *Perl_pp_and(pTHX);
-PERL_CALLCONV OP *Perl_pp_anoncode(pTHX);
-PERL_CALLCONV OP *Perl_pp_anonhash(pTHX);
-PERL_CALLCONV OP *Perl_pp_anonlist(pTHX);
-PERL_CALLCONV OP *Perl_pp_aslice(pTHX);
-PERL_CALLCONV OP *Perl_pp_atan2(pTHX);
-PERL_CALLCONV OP *Perl_pp_av2arylen(pTHX);
-PERL_CALLCONV OP *Perl_pp_backtick(pTHX);
-PERL_CALLCONV OP *Perl_pp_bind(pTHX);
-PERL_CALLCONV OP *Perl_pp_binmode(pTHX);
-PERL_CALLCONV OP *Perl_pp_bit_and(pTHX);
-PERL_CALLCONV OP *Perl_pp_bit_or(pTHX);
-PERL_CALLCONV OP *Perl_pp_bless(pTHX);
-PERL_CALLCONV OP *Perl_pp_boolkeys(pTHX);
-PERL_CALLCONV OP *Perl_pp_break(pTHX);
-PERL_CALLCONV OP *Perl_pp_caller(pTHX);
-PERL_CALLCONV OP *Perl_pp_chdir(pTHX);
-PERL_CALLCONV OP *Perl_pp_chop(pTHX);
-PERL_CALLCONV OP *Perl_pp_chown(pTHX);
-PERL_CALLCONV OP *Perl_pp_chr(pTHX);
-PERL_CALLCONV OP *Perl_pp_chroot(pTHX);
-PERL_CALLCONV OP *Perl_pp_close(pTHX);
-PERL_CALLCONV OP *Perl_pp_closedir(pTHX);
-PERL_CALLCONV OP *Perl_pp_complement(pTHX);
-PERL_CALLCONV OP *Perl_pp_concat(pTHX);
-PERL_CALLCONV OP *Perl_pp_cond_expr(pTHX);
-PERL_CALLCONV OP *Perl_pp_const(pTHX);
-PERL_CALLCONV OP *Perl_pp_continue(pTHX);
-PERL_CALLCONV OP *Perl_pp_crypt(pTHX);
-PERL_CALLCONV OP *Perl_pp_dbmopen(pTHX);
-PERL_CALLCONV OP *Perl_pp_dbstate(pTHX);
-PERL_CALLCONV OP *Perl_pp_defined(pTHX);
-PERL_CALLCONV OP *Perl_pp_delete(pTHX);
-PERL_CALLCONV OP *Perl_pp_die(pTHX);
-PERL_CALLCONV OP *Perl_pp_divide(pTHX);
-PERL_CALLCONV OP *Perl_pp_each(pTHX);
-PERL_CALLCONV OP *Perl_pp_ehostent(pTHX);
-PERL_CALLCONV OP *Perl_pp_enter(pTHX);
-PERL_CALLCONV OP *Perl_pp_entereval(pTHX);
-PERL_CALLCONV OP *Perl_pp_entergiven(pTHX);
-PERL_CALLCONV OP *Perl_pp_enteriter(pTHX);
-PERL_CALLCONV OP *Perl_pp_enterloop(pTHX);
-PERL_CALLCONV OP *Perl_pp_entersub(pTHX);
-PERL_CALLCONV OP *Perl_pp_entertry(pTHX);
-PERL_CALLCONV OP *Perl_pp_enterwhen(pTHX);
-PERL_CALLCONV OP *Perl_pp_enterwrite(pTHX);
-PERL_CALLCONV OP *Perl_pp_eof(pTHX);
-PERL_CALLCONV OP *Perl_pp_eq(pTHX);
-PERL_CALLCONV OP *Perl_pp_exec(pTHX);
-PERL_CALLCONV OP *Perl_pp_exists(pTHX);
-PERL_CALLCONV OP *Perl_pp_exit(pTHX);
-PERL_CALLCONV OP *Perl_pp_fileno(pTHX);
-PERL_CALLCONV OP *Perl_pp_flip(pTHX);
-PERL_CALLCONV OP *Perl_pp_flock(pTHX);
-PERL_CALLCONV OP *Perl_pp_flop(pTHX);
-PERL_CALLCONV OP *Perl_pp_fork(pTHX);
-PERL_CALLCONV OP *Perl_pp_formline(pTHX);
-PERL_CALLCONV OP *Perl_pp_ftis(pTHX);
-PERL_CALLCONV OP *Perl_pp_ftlink(pTHX);
-PERL_CALLCONV OP *Perl_pp_ftrowned(pTHX);
-PERL_CALLCONV OP *Perl_pp_ftrread(pTHX);
-PERL_CALLCONV OP *Perl_pp_fttext(pTHX);
-PERL_CALLCONV OP *Perl_pp_fttty(pTHX);
-PERL_CALLCONV OP *Perl_pp_ge(pTHX);
-PERL_CALLCONV OP *Perl_pp_gelem(pTHX);
-PERL_CALLCONV OP *Perl_pp_getc(pTHX);
-PERL_CALLCONV OP *Perl_pp_getlogin(pTHX);
-PERL_CALLCONV OP *Perl_pp_getpeername(pTHX);
-PERL_CALLCONV OP *Perl_pp_getpgrp(pTHX);
-PERL_CALLCONV OP *Perl_pp_getppid(pTHX);
-PERL_CALLCONV OP *Perl_pp_getpriority(pTHX);
-PERL_CALLCONV OP *Perl_pp_ggrent(pTHX);
-PERL_CALLCONV OP *Perl_pp_ghostent(pTHX);
-PERL_CALLCONV OP *Perl_pp_glob(pTHX);
-PERL_CALLCONV OP *Perl_pp_gmtime(pTHX);
-PERL_CALLCONV OP *Perl_pp_gnetent(pTHX);
-PERL_CALLCONV OP *Perl_pp_goto(pTHX);
-PERL_CALLCONV OP *Perl_pp_gprotoent(pTHX);
-PERL_CALLCONV OP *Perl_pp_gpwent(pTHX);
-PERL_CALLCONV OP *Perl_pp_grepstart(pTHX);
-PERL_CALLCONV OP *Perl_pp_grepwhile(pTHX);
-PERL_CALLCONV OP *Perl_pp_gservent(pTHX);
-PERL_CALLCONV OP *Perl_pp_gt(pTHX);
-PERL_CALLCONV OP *Perl_pp_gv(pTHX);
-PERL_CALLCONV OP *Perl_pp_gvsv(pTHX);
-PERL_CALLCONV OP *Perl_pp_helem(pTHX);
-PERL_CALLCONV OP *Perl_pp_hintseval(pTHX);
-PERL_CALLCONV OP *Perl_pp_hslice(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_add(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_divide(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_eq(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_ge(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_gt(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_le(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_lt(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_modulo(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_multiply(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_ncmp(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_ne(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_negate(pTHX);
-PERL_CALLCONV OP *Perl_pp_i_subtract(pTHX);
-PERL_CALLCONV OP *Perl_pp_index(pTHX);
-PERL_CALLCONV OP *Perl_pp_int(pTHX);
-PERL_CALLCONV OP *Perl_pp_ioctl(pTHX);
-PERL_CALLCONV OP *Perl_pp_iter(pTHX);
-PERL_CALLCONV OP *Perl_pp_join(pTHX);
-PERL_CALLCONV OP *Perl_pp_last(pTHX);
-PERL_CALLCONV OP *Perl_pp_lc(pTHX);
-PERL_CALLCONV OP *Perl_pp_le(pTHX);
-PERL_CALLCONV OP *Perl_pp_leave(pTHX);
-PERL_CALLCONV OP *Perl_pp_leaveeval(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavegiven(pTHX);
-PERL_CALLCONV OP *Perl_pp_leaveloop(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavesub(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavesublv(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavetry(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavewhen(pTHX);
-PERL_CALLCONV OP *Perl_pp_leavewrite(pTHX);
-PERL_CALLCONV OP *Perl_pp_left_shift(pTHX);
-PERL_CALLCONV OP *Perl_pp_length(pTHX);
-PERL_CALLCONV OP *Perl_pp_link(pTHX);
-PERL_CALLCONV OP *Perl_pp_list(pTHX);
-PERL_CALLCONV OP *Perl_pp_listen(pTHX);
-PERL_CALLCONV OP *Perl_pp_lock(pTHX);
-PERL_CALLCONV OP *Perl_pp_lslice(pTHX);
-PERL_CALLCONV OP *Perl_pp_lt(pTHX);
-PERL_CALLCONV OP *Perl_pp_mapwhile(pTHX);
-PERL_CALLCONV OP *Perl_pp_match(pTHX);
-PERL_CALLCONV OP *Perl_pp_method(pTHX);
-PERL_CALLCONV OP *Perl_pp_method_named(pTHX);
-PERL_CALLCONV OP *Perl_pp_mkdir(pTHX);
-PERL_CALLCONV OP *Perl_pp_modulo(pTHX);
-PERL_CALLCONV OP *Perl_pp_multiply(pTHX);
-PERL_CALLCONV OP *Perl_pp_ncmp(pTHX);
-PERL_CALLCONV OP *Perl_pp_ne(pTHX);
-PERL_CALLCONV OP *Perl_pp_negate(pTHX);
-PERL_CALLCONV OP *Perl_pp_next(pTHX);
-PERL_CALLCONV OP *Perl_pp_nextstate(pTHX);
-PERL_CALLCONV OP *Perl_pp_not(pTHX);
-PERL_CALLCONV OP *Perl_pp_null(pTHX);
-PERL_CALLCONV OP *Perl_pp_oct(pTHX);
-PERL_CALLCONV OP *Perl_pp_once(pTHX);
-PERL_CALLCONV OP *Perl_pp_open(pTHX);
-PERL_CALLCONV OP *Perl_pp_open_dir(pTHX);
-PERL_CALLCONV OP *Perl_pp_or(pTHX);
-PERL_CALLCONV OP *Perl_pp_ord(pTHX);
-PERL_CALLCONV OP *Perl_pp_pack(pTHX);
-PERL_CALLCONV OP *Perl_pp_padav(pTHX);
-PERL_CALLCONV OP *Perl_pp_padhv(pTHX);
-PERL_CALLCONV OP *Perl_pp_padsv(pTHX);
-PERL_CALLCONV OP *Perl_pp_pipe_op(pTHX);
-PERL_CALLCONV OP *Perl_pp_pos(pTHX);
-PERL_CALLCONV OP *Perl_pp_postdec(pTHX);
-PERL_CALLCONV OP *Perl_pp_postinc(pTHX);
-PERL_CALLCONV OP *Perl_pp_pow(pTHX);
-PERL_CALLCONV OP *Perl_pp_predec(pTHX);
-PERL_CALLCONV OP *Perl_pp_preinc(pTHX);
-PERL_CALLCONV OP *Perl_pp_print(pTHX);
-PERL_CALLCONV OP *Perl_pp_prototype(pTHX);
-PERL_CALLCONV OP *Perl_pp_prtf(pTHX);
-PERL_CALLCONV OP *Perl_pp_push(pTHX);
-PERL_CALLCONV OP *Perl_pp_pushmark(pTHX);
-PERL_CALLCONV OP *Perl_pp_pushre(pTHX);
-PERL_CALLCONV OP *Perl_pp_qr(pTHX);
-PERL_CALLCONV OP *Perl_pp_quotemeta(pTHX);
-PERL_CALLCONV OP *Perl_pp_rand(pTHX);
-PERL_CALLCONV OP *Perl_pp_range(pTHX);
-PERL_CALLCONV OP *Perl_pp_rcatline(pTHX);
-PERL_CALLCONV OP *Perl_pp_readdir(pTHX);
-PERL_CALLCONV OP *Perl_pp_readline(pTHX);
-PERL_CALLCONV OP *Perl_pp_readlink(pTHX);
-PERL_CALLCONV OP *Perl_pp_redo(pTHX);
-PERL_CALLCONV OP *Perl_pp_ref(pTHX);
-PERL_CALLCONV OP *Perl_pp_refgen(pTHX);
-PERL_CALLCONV OP *Perl_pp_regcomp(pTHX);
-PERL_CALLCONV OP *Perl_pp_regcreset(pTHX);
-PERL_CALLCONV OP *Perl_pp_rename(pTHX);
-PERL_CALLCONV OP *Perl_pp_repeat(pTHX);
-PERL_CALLCONV OP *Perl_pp_require(pTHX);
-PERL_CALLCONV OP *Perl_pp_reset(pTHX);
-PERL_CALLCONV OP *Perl_pp_return(pTHX);
-PERL_CALLCONV OP *Perl_pp_reverse(pTHX);
-PERL_CALLCONV OP *Perl_pp_rewinddir(pTHX);
-PERL_CALLCONV OP *Perl_pp_right_shift(pTHX);
-PERL_CALLCONV OP *Perl_pp_rkeys(pTHX);
-PERL_CALLCONV OP *Perl_pp_rmdir(pTHX);
-PERL_CALLCONV OP *Perl_pp_rv2av(pTHX);
-PERL_CALLCONV OP *Perl_pp_rv2cv(pTHX);
-PERL_CALLCONV OP *Perl_pp_rv2gv(pTHX);
-PERL_CALLCONV OP *Perl_pp_rv2sv(pTHX);
-PERL_CALLCONV OP *Perl_pp_sassign(pTHX);
-PERL_CALLCONV OP *Perl_pp_schop(pTHX);
-PERL_CALLCONV OP *Perl_pp_scmp(pTHX);
-PERL_CALLCONV OP *Perl_pp_seekdir(pTHX);
-PERL_CALLCONV OP *Perl_pp_select(pTHX);
-PERL_CALLCONV OP *Perl_pp_semctl(pTHX);
-PERL_CALLCONV OP *Perl_pp_semget(pTHX);
-PERL_CALLCONV OP *Perl_pp_seq(pTHX);
-PERL_CALLCONV OP *Perl_pp_setpgrp(pTHX);
-PERL_CALLCONV OP *Perl_pp_setpriority(pTHX);
-PERL_CALLCONV OP *Perl_pp_shift(pTHX);
-PERL_CALLCONV OP *Perl_pp_shmwrite(pTHX);
-PERL_CALLCONV OP *Perl_pp_shostent(pTHX);
-PERL_CALLCONV OP *Perl_pp_shutdown(pTHX);
-PERL_CALLCONV OP *Perl_pp_sin(pTHX);
-PERL_CALLCONV OP *Perl_pp_sle(pTHX);
-PERL_CALLCONV OP *Perl_pp_sleep(pTHX);
-PERL_CALLCONV OP *Perl_pp_smartmatch(pTHX);
-PERL_CALLCONV OP *Perl_pp_sne(pTHX);
-PERL_CALLCONV OP *Perl_pp_socket(pTHX);
-PERL_CALLCONV OP *Perl_pp_sockpair(pTHX);
-PERL_CALLCONV OP *Perl_pp_sort(pTHX);
-PERL_CALLCONV OP *Perl_pp_splice(pTHX);
-PERL_CALLCONV OP *Perl_pp_split(pTHX);
-PERL_CALLCONV OP *Perl_pp_sprintf(pTHX);
-PERL_CALLCONV OP *Perl_pp_srand(pTHX);
-PERL_CALLCONV OP *Perl_pp_srefgen(pTHX);
-PERL_CALLCONV OP *Perl_pp_sselect(pTHX);
-PERL_CALLCONV OP *Perl_pp_ssockopt(pTHX);
-PERL_CALLCONV OP *Perl_pp_stat(pTHX);
-PERL_CALLCONV OP *Perl_pp_stringify(pTHX);
-PERL_CALLCONV OP *Perl_pp_stub(pTHX);
-PERL_CALLCONV OP *Perl_pp_study(pTHX);
-PERL_CALLCONV OP *Perl_pp_subst(pTHX);
-PERL_CALLCONV OP *Perl_pp_substcont(pTHX);
-PERL_CALLCONV OP *Perl_pp_substr(pTHX);
-PERL_CALLCONV OP *Perl_pp_subtract(pTHX);
-PERL_CALLCONV OP *Perl_pp_syscall(pTHX);
-PERL_CALLCONV OP *Perl_pp_sysopen(pTHX);
-PERL_CALLCONV OP *Perl_pp_sysread(pTHX);
-PERL_CALLCONV OP *Perl_pp_sysseek(pTHX);
-PERL_CALLCONV OP *Perl_pp_system(pTHX);
-PERL_CALLCONV OP *Perl_pp_syswrite(pTHX);
-PERL_CALLCONV OP *Perl_pp_tell(pTHX);
-PERL_CALLCONV OP *Perl_pp_telldir(pTHX);
-PERL_CALLCONV OP *Perl_pp_tie(pTHX);
-PERL_CALLCONV OP *Perl_pp_tied(pTHX);
-PERL_CALLCONV OP *Perl_pp_time(pTHX);
-PERL_CALLCONV OP *Perl_pp_tms(pTHX);
-PERL_CALLCONV OP *Perl_pp_trans(pTHX);
-PERL_CALLCONV OP *Perl_pp_truncate(pTHX);
-PERL_CALLCONV OP *Perl_pp_uc(pTHX);
-PERL_CALLCONV OP *Perl_pp_ucfirst(pTHX);
-PERL_CALLCONV OP *Perl_pp_umask(pTHX);
-PERL_CALLCONV OP *Perl_pp_undef(pTHX);
-PERL_CALLCONV OP *Perl_pp_unpack(pTHX);
-PERL_CALLCONV OP *Perl_pp_unshift(pTHX);
-PERL_CALLCONV OP *Perl_pp_unstack(pTHX);
-PERL_CALLCONV OP *Perl_pp_untie(pTHX);
-PERL_CALLCONV OP *Perl_pp_vec(pTHX);
-PERL_CALLCONV OP *Perl_pp_wait(pTHX);
-PERL_CALLCONV OP *Perl_pp_waitpid(pTHX);
-PERL_CALLCONV OP *Perl_pp_wantarray(pTHX);
-PERL_CALLCONV OP *Perl_pp_warn(pTHX);
-PERL_CALLCONV OP *Perl_pp_xor(pTHX);
-PERL_CALLCONV OP *Perl_unimplemented_op(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_do_kv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_aassign(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_abs(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_accept(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_add(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_aeach(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_aelem(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_aelemfast(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_akeys(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_alarm(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_and(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_anoncode(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_anonhash(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_anonlist(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_aslice(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_atan2(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_av2arylen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_backtick(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_bind(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_binmode(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_bit_and(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_bit_or(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_bless(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_boolkeys(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_break(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_caller(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_chdir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_chop(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_chown(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_chr(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_chroot(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_close(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_closedir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_complement(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_concat(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_cond_expr(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_const(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_continue(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_crypt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_dbmopen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_dbstate(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_defined(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_delete(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_die(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_divide(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_each(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ehostent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_enter(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_entereval(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_entergiven(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_enteriter(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_enterloop(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_entersub(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_entertry(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_enterwhen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_enterwrite(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_eof(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_eq(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_exec(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_exists(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_exit(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_fileno(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_flip(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_flock(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_flop(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_fork(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_formline(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ftis(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ftlink(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ftrowned(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ftrread(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_fttext(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_fttty(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ge(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gelem(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getc(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getlogin(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getpeername(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getpgrp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getppid(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_getpriority(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ggrent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ghostent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_glob(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gmtime(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gnetent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_goto(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gprotoent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gpwent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_grepstart(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_grepwhile(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gservent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_gvsv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_helem(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_hintseval(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_hslice(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_add(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_divide(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_eq(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_ge(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_gt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_le(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_lt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_modulo(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_multiply(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_ncmp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_ne(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_negate(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_i_subtract(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_index(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_int(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ioctl(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_iter(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_join(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_last(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_lc(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_le(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leave(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leaveeval(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavegiven(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leaveloop(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavesub(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavesublv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavetry(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavewhen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_leavewrite(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_left_shift(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_length(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_link(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_list(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_listen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_lock(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_lslice(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_lt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_mapwhile(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_match(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_method(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_method_named(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_mkdir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_modulo(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_multiply(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ncmp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ne(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_negate(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_next(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_nextstate(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_not(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_null(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_oct(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_once(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_open(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_open_dir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_or(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ord(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pack(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_padav(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_padhv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_padsv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pipe_op(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pos(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_postdec(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_postinc(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pow(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_predec(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_preinc(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_print(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_prototype(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_prtf(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_push(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pushmark(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_pushre(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_qr(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_quotemeta(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rand(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_range(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rcatline(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_readdir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_readline(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_readlink(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_redo(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ref(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_refgen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_regcomp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_regcreset(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rename(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_repeat(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_require(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_reset(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_return(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_reverse(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rewinddir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_right_shift(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rkeys(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rmdir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rv2av(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rv2cv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rv2gv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_rv2sv(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sassign(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_schop(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_scmp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_seekdir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_select(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_semctl(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_semget(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_seq(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_setpgrp(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_setpriority(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_shift(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_shmwrite(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_shostent(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_shutdown(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sin(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sle(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sleep(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_smartmatch(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sne(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_socket(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sockpair(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sort(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_splice(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_split(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sprintf(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_srand(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_srefgen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sselect(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ssockopt(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_stat(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_stringify(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_stub(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_study(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_subst(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_substcont(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_substr(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_subtract(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_syscall(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sysopen(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sysread(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_sysseek(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_system(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_syswrite(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_tell(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_telldir(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_tie(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_tied(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_time(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_tms(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_trans(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_truncate(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_uc(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_ucfirst(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_umask(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_undef(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_unpack(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_unshift(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_unstack(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_untie(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_vec(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_wait(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_waitpid(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_wantarray(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_warn(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_pp_xor(pTHX);
+PERL_CALLCONV INSTRUCTION *Perl_unimplemented_op(pTHX);
 
 /* ex: set ro: */
diff --git a/pp_sort.c b/pp_sort.c
index fd2f28a..bd523dd 100644
--- a/pp_sort.c
+++ b/pp_sort.c
@@ -1480,7 +1480,7 @@ PP(pp_sort)
     GV *gv;
     CV *cv = NULL;
     I32 gimme = GIMME;
-    OP* const nextop = PL_op->op_next;
+    INSTRUCTION* const next_instr = PL_op->op_next;
     I32 overloading = 0;
     bool hasargs = FALSE;
     I32 is_xsub = 0;
@@ -1735,7 +1735,7 @@ PP(pp_sort)
     }
     LEAVE;
     PL_stack_sp = ORIGMARK + (sorting_av ? 0 : max);
-    return nextop;
+    return next_instr;
 }
 
 static I32
diff --git a/pp_sys.c b/pp_sys.c
index 726be76..3f1d3c2 100644
--- a/pp_sys.c
+++ b/pp_sys.c
@@ -357,7 +357,7 @@ PP(pp_backtick)
 PP(pp_glob)
 {
     dVAR;
-    OP *result;
+    INSTRUCTION *result;
     dSP;
     /* make a copy of the pattern, to ensure that magic is called once
      * and only once */
@@ -507,7 +507,7 @@ PP(pp_die)
 
 /* I/O. */
 
-OP *
+INSTRUCTION *
 Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv,
 		 const MAGIC *const mg, const U32 flags, U32 argc, ...)
 {
@@ -1294,8 +1294,8 @@ PP(pp_getc)
     RETURN;
 }
 
-STATIC OP *
-S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
+STATIC INSTRUCTION *
+S_doform(pTHX_ CV *cv, GV *gv, INSTRUCTION *ret_instr)
 {
     dVAR;
     register PERL_CONTEXT *cx;
@@ -1310,7 +1310,7 @@ S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
     SAVETMPS;
 
     PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
-    PUSHFORMAT(cx, retop);
+    PUSHFORMAT(cx, ret_instr);
     SAVECOMPPAD();
     PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1);
 
@@ -1375,7 +1375,7 @@ PP(pp_leavewrite)
     SV **newsp;
     I32 gimme;
     register PERL_CONTEXT *cx;
-    OP *retop;
+    INSTRUCTION *ret_instr;
 
     if (!io || !(ofp = IoOFP(io)))
         goto forget_top;
@@ -1456,7 +1456,7 @@ PP(pp_leavewrite)
   forget_top:
     POPBLOCK(cx,PL_curpm);
     POPFORMAT(cx);
-    retop = cx->blk_sub.retop;
+    ret_instr = cx->blk_sub.ret_instr;
     LEAVE;
 
     fp = IoOFP(io);
@@ -1487,7 +1487,7 @@ PP(pp_leavewrite)
     PUTBACK;
     PERL_UNUSED_VAR(newsp);
     PERL_UNUSED_VAR(gimme);
-    return retop;
+    return ret_instr;
 }
 
 PP(pp_prtf)
diff --git a/proto.h b/proto.h
index 6ddc11c..f7a06e3 100644
--- a/proto.h
+++ b/proto.h
@@ -697,10 +697,10 @@ PERL_CALLCONV char*	Perl_delimcpy(char* to, const char* toend, const char* from,
 	assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
 
 PERL_CALLCONV void	Perl_despatch_signals(pTHX);
-PERL_CALLCONV OP*	Perl_die(pTHX_ const char* pat, ...)
+PERL_CALLCONV INSTRUCTION*	Perl_die(pTHX_ const char* pat, ...)
 			__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 
-PERL_CALLCONV OP*	Perl_die_sv(pTHX_ SV *baseex)
+PERL_CALLCONV INSTRUCTION*	Perl_die_sv(pTHX_ SV *baseex)
 			__attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_DIE_SV	\
 	assert(baseex)
@@ -813,7 +813,7 @@ PERL_CALLCONV bool	Perl_do_print(pTHX_ SV* sv, PerlIO* fp)
 #define PERL_ARGS_ASSERT_DO_PRINT	\
 	assert(fp)
 
-PERL_CALLCONV OP*	Perl_do_readline(pTHX)
+PERL_CALLCONV INSTRUCTION*	Perl_do_readline(pTHX)
 			__attribute__warn_unused_result__;
 
 PERL_CALLCONV bool	Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence);
@@ -4229,7 +4229,7 @@ PERL_CALLCONV void	Perl_taint_proper(pTHX_ const char* f, const char *const s)
 #define PERL_ARGS_ASSERT_TAINT_PROPER	\
 	assert(s)
 
-PERL_CALLCONV OP *	Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
+PERL_CALLCONV INSTRUCTION *	Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
 			__attribute__nonnull__(pTHX_1)
 			__attribute__nonnull__(pTHX_2)
 			__attribute__nonnull__(pTHX_3)
@@ -5059,7 +5059,7 @@ PERL_CALLCONV void	Perl_deb_nocontext(const char* pat, ...)
 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT	\
 	assert(pat)
 
-PERL_CALLCONV OP*	Perl_die_nocontext(const char* pat, ...)
+PERL_CALLCONV INSTRUCTION*	Perl_die_nocontext(const char* pat, ...)
 			__attribute__format__null_ok__(__printf__,1,2);
 
 PERL_CALLCONV char*	Perl_form_nocontext(const char* pat, ...)
@@ -5704,7 +5704,7 @@ STATIC void	S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
 #define PERL_ARGS_ASSERT_DO_CHOMP	\
 	assert(retval); assert(sv)
 
-STATIC OP*	S_do_delete_local(pTHX);
+STATIC INSTRUCTION*	S_do_delete_local(pTHX);
 STATIC SV*	S_refto(pTHX_ SV* sv)
 			__attribute__warn_unused_result__
 			__attribute__nonnull__(pTHX_1);
@@ -5741,8 +5741,8 @@ STATIC void	S_destroy_matcher(pTHX_ PMOP* matcher)
 #define PERL_ARGS_ASSERT_DESTROY_MATCHER	\
 	assert(matcher)
 
-STATIC OP*	S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other);
-STATIC OP*	S_docatch(pTHX_ OP *o)
+STATIC INSTRUCTION*	S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other);
+STATIC INSTRUCTION*	S_docatch(pTHX_ INSTRUCTION *instr)
 			__attribute__warn_unused_result__;
 
 STATIC bool	S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq);
@@ -5989,12 +5989,12 @@ STATIC I32	S_sv_ncmp(pTHX_ SV *const a, SV *const b)
 
 #endif
 #if defined(PERL_IN_PP_SYS_C)
-STATIC OP*	S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
+STATIC INSTRUCTION*	S_doform(pTHX_ CV *cv, GV *gv, INSTRUCTION *ret_instr)
 			__attribute__nonnull__(pTHX_1)
 			__attribute__nonnull__(pTHX_2)
 			__attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_DOFORM	\
-	assert(cv); assert(gv); assert(retop)
+	assert(cv); assert(gv); assert(ret_instr)
 
 STATIC SV *	S_space_join_names_mortal(pTHX_ char *const *array)
 			__attribute__nonnull__(pTHX_1);
diff --git a/regen/opcode.pl b/regen/opcode.pl
index 791de9f..673bee1 100755
--- a/regen/opcode.pl
+++ b/regen/opcode.pl
@@ -451,7 +451,7 @@ my $pp = open_new('pp_proto.h', '>',
 	my $name = $alias{$_} ? $alias{$_}[0] : "Perl_pp_$_";
 	++$funcs{$name};
     }
-    print $pp "PERL_CALLCONV OP *$_(pTHX);\n" foreach sort keys %funcs;
+    print $pp "PERL_CALLCONV INSTRUCTION *$_(pTHX);\n" foreach sort keys %funcs;
 }
 foreach ($oc, $on, $pp) {
     read_only_bottom_close_and_rename($_);
diff --git a/scope.c b/scope.c
index e0ba9a3..bc4570f 100644
--- a/scope.c
+++ b/scope.c
@@ -1189,7 +1189,7 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx)
 	PerlIO_printf(Perl_debug_log, "BLK_FORMAT.HASARGS = %d\n",
 		      (int)CxHASARGS(cx));
 	PerlIO_printf(Perl_debug_log, "BLK_FORMAT.RETOP = 0x%"UVxf"\n",
-		PTR2UV(cx->blk_format.retop));
+		PTR2UV(cx->blk_format.ret_instr));
 	break;
     case CXt_SUB:
 	PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n",
@@ -1200,7 +1200,7 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx)
 		(int)CxHASARGS(cx));
 	PerlIO_printf(Perl_debug_log, "BLK_SUB.LVAL = %d\n", (int)CxLVAL(cx));
 	PerlIO_printf(Perl_debug_log, "BLK_SUB.RETOP = 0x%"UVxf"\n",
-		PTR2UV(cx->blk_sub.retop));
+		PTR2UV(cx->blk_sub.ret_instr));
 	break;
     case CXt_EVAL:
 	PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_IN_EVAL = %ld\n",
@@ -1214,7 +1214,7 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx)
 	PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%"UVxf"\n",
 		PTR2UV(cx->blk_eval.old_eval_root));
 	PerlIO_printf(Perl_debug_log, "BLK_EVAL.RETOP = 0x%"UVxf"\n",
-		PTR2UV(cx->blk_eval.retop));
+		PTR2UV(cx->blk_eval.ret_instr));
 	break;
 
     case CXt_LOOP_LAZYIV:
diff --git a/sv.c b/sv.c
index e3426ad..c246d18 100644
--- a/sv.c
+++ b/sv.c
@@ -12970,7 +12970,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_chopset		= proto_perl->Ichopset;	/* XXX never deallocated */
 
     PL_restartjmpenv	= proto_perl->Irestartjmpenv;
-    PL_restartop	= proto_perl->Irestartop;
+    PL_restart_instr	= proto_perl->Irestart_instr;
     PL_in_eval		= proto_perl->Iin_eval;
     PL_delaymagic	= proto_perl->Idelaymagic;
     PL_phase		= proto_perl->Iphase;
@@ -13328,7 +13328,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
 
     PL_errors		= sv_dup_inc(proto_perl->Ierrors, param);
 
-    PL_sortcop		= (OP*)any_dup(proto_perl->Isortcop, proto_perl);
+    PL_sortcop		= (INSTRUCTION*)any_dup(proto_perl->Isortcop, proto_perl);
     PL_sortstash	= hv_dup(proto_perl->Isortstash, param);
     PL_firstgv		= gv_dup(proto_perl->Ifirstgv, param);
     PL_secondgv		= gv_dup(proto_perl->Isecondgv, param);
diff --git a/sv.h b/sv.h
index c838367..f418d43 100644
--- a/sv.h
+++ b/sv.h
@@ -497,7 +497,7 @@ typedef U16 cv_flags_t;
 #define _XPVCV_COMMON								\
     HV *	xcv_stash;							\
     union {									\
-	OP *	xcv_start;							\
+	INSTRUCTION *	xcv_start;							\
 	ANY	xcv_xsubany;							\
     }		xcv_start_u;					    		\
     union {									\
diff --git a/util.c b/util.c
index e22a97f..543ae098 100644
--- a/util.c
+++ b/util.c
@@ -1594,16 +1594,16 @@ S_invoke_exception_hook(pTHX_ SV *ex, bool warn)
 }
 
 /*
-=for apidoc Am|OP *|die_sv|SV *baseex
+=for apidoc Am|INSTRUCTION *|die_sv|SV *baseex
 
 Behaves the same as L</croak_sv>, except for the return type.
-It should be used only where the C<OP *> return type is required.
+It should be used only where the C<INSTRUCTION *> return type is required.
 The function never actually returns.
 
 =cut
 */
 
-OP *
+INSTRUCTION *
 Perl_die_sv(pTHX_ SV *baseex)
 {
     PERL_ARGS_ASSERT_DIE_SV;
@@ -1613,17 +1613,17 @@ Perl_die_sv(pTHX_ SV *baseex)
 }
 
 /*
-=for apidoc Am|OP *|die|const char *pat|...
+=for apidoc Am|INSTRUCTION *|die|const char *pat|...
 
 Behaves the same as L</croak>, except for the return type.
-It should be used only where the C<OP *> return type is required.
+It should be used only where the C<INSTRUCTION *> return type is required.
 The function never actually returns.
 
 =cut
 */
 
 #if defined(PERL_IMPLICIT_CONTEXT)
-OP *
+INSTRUCTION *
 Perl_die_nocontext(const char* pat, ...)
 {
     dTHX;
@@ -1636,7 +1636,7 @@ Perl_die_nocontext(const char* pat, ...)
 }
 #endif /* PERL_IMPLICIT_CONTEXT */
 
-OP *
+INSTRUCTION *
 Perl_die(pTHX_ const char* pat, ...)
 {
     va_list args;
diff --git a/win32/perlhost.h b/win32/perlhost.h
index 677da4d..0c76634 100644
--- a/win32/perlhost.h
+++ b/win32/perlhost.h
@@ -1778,10 +1778,10 @@ restart:
 	    status = STATUS_EXIT;
 	    break;
 	case 3:
-	    if (PL_restartop) {
+	    if (PL_restart_instr) {
 		POPSTACK_TO(PL_mainstack);
-		PL_op = PL_restartop;
-		PL_restartop = (OP*)NULL;
+		PL_op = PL_restart_instr;
+		PL_restart_instr = (OP*)NULL;
 		goto restart;
 	    }
 	    PerlIO_printf(Perl_error_log, "panic: restartop\n");
-- 
1.7.5.4

---
Flags:
    category=core
    severity=low
---
Site configuration information for perl 5.15.1:

Configured by gerard at Sun Jul 31 12:24:03 CEST 2011.

Summary of my perl5 (revision 5 version 15 subversion 1) configuration:
  Derived from: 1363b6283b96aa411f36f58106c21e2f20c2dab9
  Platform:
    osname=linux, osvers=2.6.39-2-686-pae, archname=i686-linux-thread-multi
    uname='linux zeus 2.6.39-2-686-pae #1 smp tue jul 5 03:48:49 utc 2011 i686 gnulinux '
    config_args='-des -DDEBUGGING -Dusethreads -Dusedevel -Doptimize=-O3 -g3 -Dprefix=/home/gerard/perl/inst/madperl'
    hint=recommended, useposix=true, d_sigaction=define
    useithreads=define, usemultiplicity=define
    useperlio=define, d_sfio=undef, uselargefiles=define, usesocks=undef
    use64bitint=undef, use64bitall=undef, uselongdouble=undef
    usemymalloc=n, bincompat5005=undef
  Compiler:
    cc='cc', ccflags ='-D_REENTRANT -D_GNU_SOURCE -DDEBUGGING -fno-strict-aliasing -pipe -fstack-protector -I/usr/local/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64',
    optimize='-O3 -g3',
    cppflags='-D_REENTRANT -D_GNU_SOURCE -DDEBUGGING -fno-strict-aliasing -pipe -fstack-protector -I/usr/local/include'
    ccversion='', gccversion='4.6.1', gccosandvers=''
    intsize=4, longsize=4, ptrsize=4, doublesize=8, byteorder=1234
    d_longlong=define, longlongsize=8, d_longdbl=define, longdblsize=12
    ivtype='long', ivsize=4, nvtype='double', nvsize=8, Off_t='off_t', lseeksize=8
    alignbytes=4, prototype=define
  Linker and Libraries:
    ld='cc', ldflags =' -fstack-protector -L/usr/local/lib'
    libpth=/usr/local/lib /lib /usr/lib /usr/lib/i386-linux-gnu /usr/lib64
    libs=-lnsl -ldb -ldl -lm -lcrypt -lutil -lpthread -lc
    perllibs=-lnsl -ldl -lm -lcrypt -lutil -lpthread -lc
    libc=, so=so, useshrplib=false, libperl=libperl.a
    gnulibc_version='2.13'
  Dynamic Linking:
    dlsrc=dl_dlopen.xs, dlext=so, d_dlsymun=undef, ccdlflags='-Wl,-E'
    cccdlflags='-fPIC', lddlflags='-shared -O3 -g3 -L/usr/local/lib -fstack-protector'

Locally applied patches:
    

---
@INC for perl 5.15.1:
    lib
    /home/gerard/perl/inst/madperl/lib/site_perl/5.15.1/i686-linux-thread-multi
    /home/gerard/perl/inst/madperl/lib/site_perl/5.15.1
    /home/gerard/perl/inst/madperl/lib/5.15.1/i686-linux-thread-multi
    /home/gerard/perl/inst/madperl/lib/5.15.1
    /home/gerard/perl/inst/madperl/lib/site_perl
    .

---
Environment for perl 5.15.1:
    HOME=/home/gerard
    LANG=en_US.UTF-8
    LANGUAGE (unset)
    LD_LIBRARY_PATH (unset)
    LOGDIR (unset)
    PATH=/home/gerard/bin:/usr/local/bin:/usr/bin:/bin:/usr/games
    PERL_BADLANG (unset)
    SHELL=/bin/bash


Thread Next


nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About