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

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

Thread Previous | Thread Next
From:
Reini Urban
Date:
July 31, 2011 08:54
Subject:
Re: [perl #95986] [PATCH] Superficial separation of INSTRUCTION from OP.
Message ID:
CAHiT=DGzddUqUwWzmd97P+Ug=AAaPOwsQGaYYi-_AWNtdx78NA@mail.gmail.com
Did we use OP or OPERATOR? If it should be renamed then to INSTR
Am 31.07.2011 12:59 schrieb "Gerard Goossen" <perlbug-followup@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 Previous | 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