This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
This looks like a memory leak.
[perl5.git] / op.c
diff --git a/op.c b/op.c
index 3dd0cdb..ae5c6a8 100644 (file)
--- a/op.c
+++ b/op.c
@@ -1,7 +1,7 @@
 /*    op.c
  *
  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
 /*    op.c
  *
  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- *    2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
+ *    2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -146,14 +146,14 @@ Perl_Slab_Free(pTHX_ void *op)
 }
 #endif
 /*
 }
 #endif
 /*
- * In the following definition, the ", Nullop" is just to make the compiler
+ * In the following definition, the ", (OP*)0" is just to make the compiler
  * think the expression is of the right type: croak actually does a Siglongjmp.
  */
 #define CHECKOP(type,o) \
  * think the expression is of the right type: croak actually does a Siglongjmp.
  */
 #define CHECKOP(type,o) \
-    ((PL_op_mask && PL_op_mask[type])                                  \
+    ((PL_op_mask && PL_op_mask[type])                          \
      ? ( op_free((OP*)o),                                      \
         Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),  \
      ? ( op_free((OP*)o),                                      \
         Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),  \
-        Nullop )                                               \
+        (OP*)0 )                                               \
      : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
 
 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
      : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
 
 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
@@ -162,7 +162,7 @@ STATIC const char*
 S_gv_ename(pTHX_ GV *gv)
 {
     SV* const tmpsv = sv_newmortal();
 S_gv_ename(pTHX_ GV *gv)
 {
     SV* const tmpsv = sv_newmortal();
-    gv_efullname3(tmpsv, gv, Nullch);
+    gv_efullname3(tmpsv, gv, NULL);
     return SvPV_nolen_const(tmpsv);
 }
 
     return SvPV_nolen_const(tmpsv);
 }
 
@@ -208,11 +208,13 @@ S_no_bareword_allowed(pTHX_ const OP *o)
 PADOFFSET
 Perl_allocmy(pTHX_ char *name)
 {
 PADOFFSET
 Perl_allocmy(pTHX_ char *name)
 {
+    dVAR;
     PADOFFSET off;
     PADOFFSET off;
+    const bool is_our = (PL_in_my == KEY_our);
 
     /* complain about "my $<special_var>" etc etc */
     if (*name &&
 
     /* complain about "my $<special_var>" etc etc */
     if (*name &&
-       !(PL_in_my == KEY_our ||
+       !(is_our ||
          isALPHA(name[1]) ||
          (USE_UTF8_IN_NAMES && UTF8_IS_START(name[1])) ||
          (name[1] == '_' && (*name == '$' || name[2]))))
          isALPHA(name[1]) ||
          (USE_UTF8_IN_NAMES && UTF8_IS_START(name[1])) ||
          (name[1] == '_' && (*name == '$' || name[2]))))
@@ -241,22 +243,19 @@ Perl_allocmy(pTHX_ char *name)
     }
 
     /* check for duplicate declaration */
     }
 
     /* check for duplicate declaration */
-    pad_check_dup(name,
-               (bool)(PL_in_my == KEY_our),
-               (PL_curstash ? PL_curstash : PL_defstash)
-    );
+    pad_check_dup(name, is_our, (PL_curstash ? PL_curstash : PL_defstash));
 
     if (PL_in_my_stash && *name != '$') {
        yyerror(Perl_form(aTHX_
                    "Can't declare class for non-scalar %s in \"%s\"",
 
     if (PL_in_my_stash && *name != '$') {
        yyerror(Perl_form(aTHX_
                    "Can't declare class for non-scalar %s in \"%s\"",
-                    name, PL_in_my == KEY_our ? "our" : "my"));
+                    name, is_our ? "our" : "my"));
     }
 
     /* allocate a spare slot and store the name in that slot */
 
     off = pad_add_name(name,
                    PL_in_my_stash,
     }
 
     /* allocate a spare slot and store the name in that slot */
 
     off = pad_add_name(name,
                    PL_in_my_stash,
-                   (PL_in_my == KEY_our 
+                   (is_our
                        /* $_ is always in main::, even with our */
                        ? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
                        : NULL
                        /* $_ is always in main::, even with our */
                        ? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
                        : NULL
@@ -273,24 +272,27 @@ Perl_op_free(pTHX_ OP *o)
 {
     dVAR;
     OPCODE type;
 {
     dVAR;
     OPCODE type;
-    PADOFFSET refcnt;
 
     if (!o || o->op_static)
        return;
 
 
     if (!o || o->op_static)
        return;
 
+    type = o->op_type;
     if (o->op_private & OPpREFCOUNTED) {
     if (o->op_private & OPpREFCOUNTED) {
-       switch (o->op_type) {
+       switch (type) {
        case OP_LEAVESUB:
        case OP_LEAVESUBLV:
        case OP_LEAVEEVAL:
        case OP_LEAVE:
        case OP_SCOPE:
        case OP_LEAVEWRITE:
        case OP_LEAVESUB:
        case OP_LEAVESUBLV:
        case OP_LEAVEEVAL:
        case OP_LEAVE:
        case OP_SCOPE:
        case OP_LEAVEWRITE:
+           {
+           PADOFFSET refcnt;
            OP_REFCNT_LOCK;
            refcnt = OpREFCNT_dec(o);
            OP_REFCNT_UNLOCK;
            if (refcnt)
                return;
            OP_REFCNT_LOCK;
            refcnt = OpREFCNT_dec(o);
            OP_REFCNT_UNLOCK;
            if (refcnt)
                return;
+           }
            break;
        default:
            break;
            break;
        default:
            break;
@@ -304,7 +306,6 @@ Perl_op_free(pTHX_ OP *o)
            op_free(kid);
        }
     }
            op_free(kid);
        }
     }
-    type = o->op_type;
     if (type == OP_NULL)
        type = (OPCODE)o->op_targ;
 
     if (type == OP_NULL)
        type = (OPCODE)o->op_targ;
 
@@ -317,7 +318,7 @@ Perl_op_free(pTHX_ OP *o)
     FreeOp(o);
 #ifdef DEBUG_LEAKING_SCALARS
     if (PL_op == o)
     FreeOp(o);
 #ifdef DEBUG_LEAKING_SCALARS
     if (PL_op == o)
-       PL_op = Nullop;
+       PL_op = NULL;
 #endif
 }
 
 #endif
 }
 
@@ -350,14 +351,14 @@ Perl_op_clear(pTHX_ OP *o)
            }
 #else
            SvREFCNT_dec(cSVOPo->op_sv);
            }
 #else
            SvREFCNT_dec(cSVOPo->op_sv);
-           cSVOPo->op_sv = Nullsv;
+           cSVOPo->op_sv = NULL;
 #endif
        }
        break;
     case OP_METHOD_NAMED:
     case OP_CONST:
        SvREFCNT_dec(cSVOPo->op_sv);
 #endif
        }
        break;
     case OP_METHOD_NAMED:
     case OP_CONST:
        SvREFCNT_dec(cSVOPo->op_sv);
-       cSVOPo->op_sv = Nullsv;
+       cSVOPo->op_sv = NULL;
 #ifdef USE_ITHREADS
        /** Bug #15654
          Even if op_clear does a pad_free for the target of the op,
 #ifdef USE_ITHREADS
        /** Bug #15654
          Even if op_clear does a pad_free for the target of the op,
@@ -381,11 +382,11 @@ Perl_op_clear(pTHX_ OP *o)
     case OP_TRANS:
        if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
            SvREFCNT_dec(cSVOPo->op_sv);
     case OP_TRANS:
        if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
            SvREFCNT_dec(cSVOPo->op_sv);
-           cSVOPo->op_sv = Nullsv;
+           cSVOPo->op_sv = NULL;
        }
        else {
            Safefree(cPVOPo->op_pv);
        }
        else {
            Safefree(cPVOPo->op_pv);
-           cPVOPo->op_pv = Nullch;
+           cPVOPo->op_pv = NULL;
        }
        break;
     case OP_SUBST:
        }
        break;
     case OP_SUBST:
@@ -427,7 +428,7 @@ clear_pmop:
            }
            PmopSTASH_free(cPMOPo);
        }
            }
            PmopSTASH_free(cPMOPo);
        }
-       cPMOPo->op_pmreplroot = Nullop;
+       cPMOPo->op_pmreplroot = NULL;
         /* we use the "SAFE" version of the PM_ macros here
          * since sv_clean_all might release some PMOPs
          * after PL_regex_padav has been cleared
         /* we use the "SAFE" version of the PM_ macros here
          * since sv_clean_all might release some PMOPs
          * after PL_regex_padav has been cleared
@@ -435,7 +436,7 @@ clear_pmop:
          * happen before sv_clean_all
          */
        ReREFCNT_dec(PM_GETRE_SAFE(cPMOPo));
          * happen before sv_clean_all
          */
        ReREFCNT_dec(PM_GETRE_SAFE(cPMOPo));
-       PM_SETRE_SAFE(cPMOPo, (REGEXP*)NULL);
+       PM_SETRE_SAFE(cPMOPo, NULL);
 #ifdef USE_ITHREADS
        if(PL_regex_pad) {        /* We could be in destruction */
             av_push((AV*) PL_regex_pad[0],(SV*) PL_regex_pad[(cPMOPo)->op_pmoffset]);
 #ifdef USE_ITHREADS
        if(PL_regex_pad) {        /* We could be in destruction */
             av_push((AV*) PL_regex_pad[0],(SV*) PL_regex_pad[(cPMOPo)->op_pmoffset]);
@@ -463,11 +464,7 @@ S_cop_free(pTHX_ COP* cop)
        SvREFCNT_dec(cop->cop_warnings);
     if (! specialCopIO(cop->cop_io)) {
 #ifdef USE_ITHREADS
        SvREFCNT_dec(cop->cop_warnings);
     if (! specialCopIO(cop->cop_io)) {
 #ifdef USE_ITHREADS
-#if 0
-       STRLEN len;
-        char *s = SvPV(cop->cop_io,len);
-       Perl_warn(aTHX_ "io='%.*s'",(int) len,s); /* ??? --jhi */
-#endif
+       /*EMPTY*/
 #else
        SvREFCNT_dec(cop->cop_io);
 #endif
 #else
        SvREFCNT_dec(cop->cop_io);
 #endif
@@ -490,6 +487,7 @@ void
 Perl_op_refcnt_lock(pTHX)
 {
     dVAR;
 Perl_op_refcnt_lock(pTHX)
 {
     dVAR;
+    PERL_UNUSED_CONTEXT;
     OP_REFCNT_LOCK;
 }
 
     OP_REFCNT_LOCK;
 }
 
@@ -497,6 +495,7 @@ void
 Perl_op_refcnt_unlock(pTHX)
 {
     dVAR;
 Perl_op_refcnt_unlock(pTHX)
 {
     dVAR;
+    PERL_UNUSED_CONTEXT;
     OP_REFCNT_UNLOCK;
 }
 
     OP_REFCNT_UNLOCK;
 }
 
@@ -507,19 +506,25 @@ Perl_op_refcnt_unlock(pTHX)
 OP *
 Perl_linklist(pTHX_ OP *o)
 {
 OP *
 Perl_linklist(pTHX_ OP *o)
 {
+    OP *first;
 
     if (o->op_next)
        return o->op_next;
 
     /* establish postfix order */
 
     if (o->op_next)
        return o->op_next;
 
     /* establish postfix order */
-    if (cUNOPo->op_first) {
+    first = cUNOPo->op_first;
+    if (first) {
         register OP *kid;
         register OP *kid;
-       o->op_next = LINKLIST(cUNOPo->op_first);
-       for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
-           if (kid->op_sibling)
+       o->op_next = LINKLIST(first);
+       kid = first;
+       for (;;) {
+           if (kid->op_sibling) {
                kid->op_next = LINKLIST(kid->op_sibling);
                kid->op_next = LINKLIST(kid->op_sibling);
-           else
+               kid = kid->op_sibling;
+           } else {
                kid->op_next = o;
                kid->op_next = o;
+               break;
+           }
        }
     }
     else
        }
     }
     else
@@ -542,6 +547,7 @@ Perl_scalarkids(pTHX_ OP *o)
 STATIC OP *
 S_scalarboolean(pTHX_ OP *o)
 {
 STATIC OP *
 S_scalarboolean(pTHX_ OP *o)
 {
+    dVAR;
     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
        if (ckWARN(WARN_SYNTAX)) {
            const line_t oldline = CopLINE(PL_curcop);
     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
        if (ckWARN(WARN_SYNTAX)) {
            const line_t oldline = CopLINE(PL_curcop);
@@ -631,7 +637,7 @@ Perl_scalarvoid(pTHX_ OP *o)
 {
     dVAR;
     OP *kid;
 {
     dVAR;
     OP *kid;
-    const char* useless = 0;
+    const char* useless = NULL;
     SV* sv;
     U8 want;
 
     SV* sv;
     U8 want;
 
@@ -770,6 +776,8 @@ Perl_scalarvoid(pTHX_ OP *o)
        else {
            if (ckWARN(WARN_VOID)) {
                useless = "a constant";
        else {
            if (ckWARN(WARN_VOID)) {
                useless = "a constant";
+               if (o->op_private & OPpCONST_ARYBASE)
+                   useless = 0;
                /* don't warn on optimised away booleans, eg 
                 * use constant Foo, 5; Foo || print; */
                if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
                /* don't warn on optimised away booleans, eg 
                 * use constant Foo, 5; Foo || print; */
                if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
@@ -786,9 +794,10 @@ Perl_scalarvoid(pTHX_ OP *o)
                      built upon these three nroff macros being used in
                      void context. The pink camel has the details in
                      the script wrapman near page 319. */
                      built upon these three nroff macros being used in
                      void context. The pink camel has the details in
                      the script wrapman near page 319. */
-                   if (strnEQ(SvPVX_const(sv), "di", 2) ||
-                       strnEQ(SvPVX_const(sv), "ds", 2) ||
-                       strnEQ(SvPVX_const(sv), "ig", 2))
+                   const char * const maybe_macro = SvPVX_const(sv);
+                   if (strnEQ(maybe_macro, "di", 2) ||
+                       strnEQ(maybe_macro, "ds", 2) ||
+                       strnEQ(maybe_macro, "ig", 2))
                            useless = 0;
                }
            }
                            useless = 0;
                }
            }
@@ -959,6 +968,7 @@ Perl_list(pTHX_ OP *o)
 OP *
 Perl_scalarseq(pTHX_ OP *o)
 {
 OP *
 Perl_scalarseq(pTHX_ OP *o)
 {
+    dVAR;
     if (o) {
        if (o->op_type == OP_LINESEQ ||
             o->op_type == OP_SCOPE ||
     if (o) {
        if (o->op_type == OP_LINESEQ ||
             o->op_type == OP_SCOPE ||
@@ -1027,8 +1037,9 @@ Perl_mod(pTHX_ OP *o, I32 type)
        PL_modcount++;
        return o;
     case OP_CONST:
        PL_modcount++;
        return o;
     case OP_CONST:
-       if (!(o->op_private & (OPpCONST_ARYBASE)))
+       if (!(o->op_private & OPpCONST_ARYBASE))
            goto nomod;
            goto nomod;
+       localize = 0;
        if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
            PL_compiling.cop_arybase = (I32)SvIV(cSVOPx(PL_eval_start)->op_sv);
            PL_eval_start = 0;
        if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
            PL_compiling.cop_arybase = (I32)SvIV(cSVOPx(PL_eval_start)->op_sv);
            PL_eval_start = 0;
@@ -1050,6 +1061,10 @@ Perl_mod(pTHX_ OP *o, I32 type)
        if ((type == OP_UNDEF || type == OP_REFGEN) &&
            !(o->op_flags & OPf_STACKED)) {
            o->op_type = OP_RV2CV;              /* entersub => rv2cv */
        if ((type == OP_UNDEF || type == OP_REFGEN) &&
            !(o->op_flags & OPf_STACKED)) {
            o->op_type = OP_RV2CV;              /* entersub => rv2cv */
+           /* The default is to set op_private to the number of children,
+              which for a UNOP such as RV2CV is always 1. And w're using
+              the bit for a flag in RV2CV, so we need it clear.  */
+           o->op_private &= ~1;
            o->op_ppaddr = PL_ppaddr[OP_RV2CV];
            assert(cUNOPo->op_first->op_type == OP_NULL);
            op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
            o->op_ppaddr = PL_ppaddr[OP_RV2CV];
            assert(cUNOPo->op_first->op_type == OP_NULL);
            op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
@@ -1091,10 +1106,11 @@ Perl_mod(pTHX_ OP *o, I32 type)
                        NewOp(1101, newop, 1, UNOP);
                        newop->op_type = OP_RV2CV;
                        newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
                        NewOp(1101, newop, 1, UNOP);
                        newop->op_type = OP_RV2CV;
                        newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
-                       newop->op_first = Nullop;
+                       newop->op_first = NULL;
                         newop->op_next = (OP*)newop;
                        kid->op_sibling = (OP*)newop;
                        newop->op_private |= OPpLVAL_INTRO;
                         newop->op_next = (OP*)newop;
                        kid->op_sibling = (OP*)newop;
                        newop->op_private |= OPpLVAL_INTRO;
+                       newop->op_private &= ~1;
                        break;
                    }
 
                        break;
                    }
 
@@ -1124,11 +1140,12 @@ Perl_mod(pTHX_ OP *o, I32 type)
                        kid->op_next = okid;
                    }
                    else
                        kid->op_next = okid;
                    }
                    else
-                       okid->op_next = Nullop;
+                       okid->op_next = NULL;
                    okid->op_type = OP_RV2CV;
                    okid->op_targ = 0;
                    okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
                    okid->op_private |= OPpLVAL_INTRO;
                    okid->op_type = OP_RV2CV;
                    okid->op_targ = 0;
                    okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
                    okid->op_private |= OPpLVAL_INTRO;
+                   okid->op_private &= ~1;
                    break;
                }
 
                    break;
                }
 
@@ -1347,7 +1364,7 @@ Perl_mod(pTHX_ OP *o, I32 type)
 }
 
 STATIC bool
 }
 
 STATIC bool
-S_scalar_mod_type(pTHX_ const OP *o, I32 type)
+S_scalar_mod_type(const OP *o, I32 type)
 {
     switch (type) {
     case OP_SASSIGN:
 {
     switch (type) {
     case OP_SASSIGN:
@@ -1394,7 +1411,7 @@ S_scalar_mod_type(pTHX_ const OP *o, I32 type)
 }
 
 STATIC bool
 }
 
 STATIC bool
-S_is_handle_constructor(pTHX_ const OP *o, I32 numargs)
+S_is_handle_constructor(const OP *o, I32 numargs)
 {
     switch (o->op_type) {
     case OP_PIPE_OP:
 {
     switch (o->op_type) {
     case OP_PIPE_OP:
@@ -1410,7 +1427,7 @@ S_is_handle_constructor(pTHX_ const OP *o, I32 numargs)
     case OP_ACCEPT:
        if (numargs == 1)
            return TRUE;
     case OP_ACCEPT:
        if (numargs == 1)
            return TRUE;
-       /* FALL THROUGH */
+       /* FALLTHROUGH */
     default:
        return FALSE;
     }
     default:
        return FALSE;
     }
@@ -1445,6 +1462,7 @@ Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
            assert(cUNOPo->op_first->op_type == OP_NULL);
            op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
            o->op_flags |= OPf_SPECIAL;
            assert(cUNOPo->op_first->op_type == OP_NULL);
            op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
            o->op_flags |= OPf_SPECIAL;
+           o->op_private &= ~1;
        }
        break;
 
        }
        break;
 
@@ -1524,6 +1542,7 @@ Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
 STATIC OP *
 S_dup_attrlist(pTHX_ OP *o)
 {
 STATIC OP *
 S_dup_attrlist(pTHX_ OP *o)
 {
+    dVAR;
     OP *rop;
 
     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
     OP *rop;
 
     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
@@ -1531,15 +1550,15 @@ S_dup_attrlist(pTHX_ OP *o)
      * are OP_CONST.  We need to push the OP_CONST values.
      */
     if (o->op_type == OP_CONST)
      * are OP_CONST.  We need to push the OP_CONST values.
      */
     if (o->op_type == OP_CONST)
-       rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc(cSVOPo->op_sv));
+       rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
     else {
        assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
     else {
        assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
-       rop = Nullop;
+       rop = NULL;
        for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
            if (o->op_type == OP_CONST)
                rop = append_elem(OP_LIST, rop,
                                  newSVOP(OP_CONST, o->op_flags,
        for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
            if (o->op_type == OP_CONST)
                rop = append_elem(OP_LIST, rop,
                                  newSVOP(OP_CONST, o->op_flags,
-                                         SvREFCNT_inc(cSVOPo->op_sv)));
+                                         SvREFCNT_inc_NN(cSVOPo->op_sv)));
        }
     }
     return rop;
        }
     }
     return rop;
@@ -1561,19 +1580,17 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
 
     if (for_my) {
        /* Don't force the C<use> if we don't need it. */
 
     if (for_my) {
        /* Don't force the C<use> if we don't need it. */
-       SV * const * const svp = hv_fetch(GvHVn(PL_incgv), ATTRSMODULE_PM,
-                      sizeof(ATTRSMODULE_PM)-1, 0);
+       SV * const * const svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
        if (svp && *svp != &PL_sv_undef)
        if (svp && *svp != &PL_sv_undef)
-           ;           /* already in %INC */
+           /*EMPTY*/;          /* already in %INC */
        else
            Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
        else
            Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-                            newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-                            Nullsv);
+                            newSVpvs(ATTRSMODULE), NULL);
     }
     else {
        Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
     }
     else {
        Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
-                        newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-                        Nullsv,
+                        newSVpvs(ATTRSMODULE),
+                        NULL,
                         prepend_elem(OP_LIST,
                                      newSVOP(OP_CONST, 0, stashsv),
                                      prepend_elem(OP_LIST,
                         prepend_elem(OP_LIST,
                                      newSVOP(OP_CONST, 0, stashsv),
                                      prepend_elem(OP_LIST,
@@ -1587,6 +1604,7 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
 STATIC void
 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
 {
 STATIC void
 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
 {
+    dVAR;
     OP *pack, *imop, *arg;
     SV *meth, *stashsv;
 
     OP *pack, *imop, *arg;
     SV *meth, *stashsv;
 
@@ -1601,7 +1619,7 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
     apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
 
     /* Need package name for method call. */
     apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
 
     /* Need package name for method call. */
-    pack = newSVOP(OP_CONST, 0, newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1));
+    pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
 
     /* Build up the real arg-list. */
     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
 
     /* Build up the real arg-list. */
     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
@@ -1616,7 +1634,7 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
                                    dup_attrlist(attrs)));
 
     /* Fake up a method call to import */
                                    dup_attrlist(attrs)));
 
     /* Fake up a method call to import */
-    meth = newSVpvn_share("import", 6, 0);
+    meth = newSVpvs_share("import");
     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
                   append_elem(OP_LIST,
                               prepend_elem(OP_LIST, pack, list(arg)),
     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
                   append_elem(OP_LIST,
                               prepend_elem(OP_LIST, pack, list(arg)),
@@ -1648,7 +1666,7 @@ void
 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
                         const char *attrstr, STRLEN len)
 {
 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
                         const char *attrstr, STRLEN len)
 {
-    OP *attrs = Nullop;
+    OP *attrs = NULL;
 
     if (!len) {
         len = strlen(attrstr);
 
     if (!len) {
         len = strlen(attrstr);
@@ -1666,8 +1684,8 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
     }
 
     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
     }
 
     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
-                     newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-                     Nullsv, prepend_elem(OP_LIST,
+                    newSVpvs(ATTRSMODULE),
+                     NULL, prepend_elem(OP_LIST,
                                  newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
                                  prepend_elem(OP_LIST,
                                               newSVOP(OP_CONST, 0,
                                  newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
                                  prepend_elem(OP_LIST,
                                               newSVOP(OP_CONST, 0,
@@ -1678,6 +1696,7 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
 STATIC OP *
 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 {
 STATIC OP *
 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 {
+    dVAR;
     I32 type;
 
     if (!o || PL_error_count)
     I32 type;
 
     if (!o || PL_error_count)
@@ -1739,6 +1758,7 @@ S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 OP *
 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 {
 OP *
 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 {
+    dVAR;
     OP *rops;
     int maybe_scalar = 0;
 
     OP *rops;
     int maybe_scalar = 0;
 
@@ -1754,7 +1774,7 @@ Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 #endif
     if (attrs)
        SAVEFREEOP(attrs);
 #endif
     if (attrs)
        SAVEFREEOP(attrs);
-    rops = Nullop;
+    rops = NULL;
     o = my_kid(o, attrs, &rops);
     if (rops) {
        if (maybe_scalar && o->op_type == OP_PADSV) {
     o = my_kid(o, attrs, &rops);
     if (rops) {
        if (maybe_scalar && o->op_type == OP_PADSV) {
@@ -1772,12 +1792,13 @@ Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 OP *
 Perl_my(pTHX_ OP *o)
 {
 OP *
 Perl_my(pTHX_ OP *o)
 {
-    return my_attrs(o, Nullop);
+    return my_attrs(o, NULL);
 }
 
 OP *
 Perl_sawparens(pTHX_ OP *o)
 {
 }
 
 OP *
 Perl_sawparens(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     if (o)
        o->op_flags |= OPf_PARENS;
     return o;
     if (o)
        o->op_flags |= OPf_PARENS;
     return o;
@@ -1874,7 +1895,7 @@ Perl_scope(pTHX_ OP *o)
            }
        }
        else
            }
        }
        else
-           o = newLISTOP(OP_SCOPE, 0, o, Nullop);
+           o = newLISTOP(OP_SCOPE, 0, o, NULL);
     }
     return o;
 }
     }
     return o;
 }
@@ -1882,6 +1903,7 @@ Perl_scope(pTHX_ OP *o)
 int
 Perl_block_start(pTHX_ int full)
 {
 int
 Perl_block_start(pTHX_ int full)
 {
+    dVAR;
     const int retval = PL_savestack_ix;
     pad_block_start(full);
     SAVEHINTS();
     const int retval = PL_savestack_ix;
     pad_block_start(full);
     SAVEHINTS();
@@ -1902,6 +1924,7 @@ Perl_block_start(pTHX_ int full)
 OP*
 Perl_block_end(pTHX_ I32 floor, OP *seq)
 {
 OP*
 Perl_block_end(pTHX_ I32 floor, OP *seq)
 {
+    dVAR;
     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
     OP* const retval = scalarseq(seq);
     LEAVE_SCOPE(floor);
     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
     OP* const retval = scalarseq(seq);
     LEAVE_SCOPE(floor);
@@ -1915,8 +1938,9 @@ Perl_block_end(pTHX_ I32 floor, OP *seq)
 STATIC OP *
 S_newDEFSVOP(pTHX)
 {
 STATIC OP *
 S_newDEFSVOP(pTHX)
 {
+    dVAR;
     const I32 offset = pad_findmy("$_");
     const I32 offset = pad_findmy("$_");
-    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
        return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
     }
     else {
        return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
     }
     else {
@@ -1929,6 +1953,7 @@ S_newDEFSVOP(pTHX)
 void
 Perl_newPROG(pTHX_ OP *o)
 {
 void
 Perl_newPROG(pTHX_ OP *o)
 {
+    dVAR;
     if (PL_in_eval) {
        if (PL_eval_root)
                return;
     if (PL_in_eval) {
        if (PL_eval_root)
                return;
@@ -1974,13 +1999,14 @@ Perl_newPROG(pTHX_ OP *o)
 OP *
 Perl_localize(pTHX_ OP *o, I32 lex)
 {
 OP *
 Perl_localize(pTHX_ OP *o, I32 lex)
 {
+    dVAR;
     if (o->op_flags & OPf_PARENS)
 /* [perl #17376]: this appears to be premature, and results in code such as
    C< our(%x); > executing in list mode rather than void mode */
 #if 0
        list(o);
 #else
     if (o->op_flags & OPf_PARENS)
 /* [perl #17376]: this appears to be premature, and results in code such as
    C< our(%x); > executing in list mode rather than void mode */
 #if 0
        list(o);
 #else
-       ;
+       /*EMPTY*/;
 #endif
     else {
        if ( PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ','
 #endif
     else {
        if ( PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ','
@@ -2027,8 +2053,9 @@ OP *
 Perl_jmaybe(pTHX_ OP *o)
 {
     if (o->op_type == OP_LIST) {
 Perl_jmaybe(pTHX_ OP *o)
 {
     if (o->op_type == OP_LIST) {
-       OP *o2;
-       o2 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
+       OP * const o2
+           = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL,
+                                                    SVt_PV)));
        o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
     }
     return o;
        o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
     }
     return o;
@@ -2101,7 +2128,7 @@ Perl_fold_constants(pTHX_ register OP *o)
     if (o->op_targ && sv == PAD_SV(o->op_targ))        /* grab pad temp? */
        pad_swipe(o->op_targ,  FALSE);
     else if (SvTEMP(sv)) {                     /* grab mortal temp? */
     if (o->op_targ && sv == PAD_SV(o->op_targ))        /* grab pad temp? */
        pad_swipe(o->op_targ,  FALSE);
     else if (SvTEMP(sv)) {                     /* grab mortal temp? */
-       (void)SvREFCNT_inc(sv);
+       SvREFCNT_inc_simple_void(sv);
        SvTEMP_off(sv);
     }
     op_free(o);
        SvTEMP_off(sv);
     }
     op_free(o);
@@ -2139,7 +2166,7 @@ Perl_gen_constant_list(pTHX_ register OP *o)
     o->op_flags |= OPf_PARENS; /* and flatten \(1..2,3) */
     o->op_opt = 0;             /* needs to be revisited in peep() */
     curop = ((UNOP*)o)->op_first;
     o->op_flags |= OPf_PARENS; /* and flatten \(1..2,3) */
     o->op_opt = 0;             /* needs to be revisited in peep() */
     curop = ((UNOP*)o)->op_first;
-    ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--));
+    ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc_NN(*PL_stack_sp--));
     op_free(curop);
     linklist(o);
     return list(o);
     op_free(curop);
     linklist(o);
     return list(o);
@@ -2150,7 +2177,7 @@ Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
 {
     dVAR;
     if (!o || o->op_type != OP_LIST)
 {
     dVAR;
     if (!o || o->op_type != OP_LIST)
-       o = newLISTOP(OP_LIST, 0, o, Nullop);
+       o = newLISTOP(OP_LIST, 0, o, NULL);
     else
        o->op_flags &= ~OPf_WANT;
 
     else
        o->op_flags &= ~OPf_WANT;
 
@@ -2262,7 +2289,7 @@ OP *
 Perl_force_list(pTHX_ OP *o)
 {
     if (!o || o->op_type != OP_LIST)
 Perl_force_list(pTHX_ OP *o)
 {
     if (!o || o->op_type != OP_LIST)
-       o = newLISTOP(OP_LIST, 0, o, Nullop);
+       o = newLISTOP(OP_LIST, 0, o, NULL);
     op_null(o);
     return o;
 }
     op_null(o);
     return o;
 }
@@ -2376,7 +2403,10 @@ Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
     return fold_constants((OP *)binop);
 }
 
     return fold_constants((OP *)binop);
 }
 
-static int uvcompare(const void *a, const void *b) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__pure__;
+static int uvcompare(const void *a, const void *b)
+    __attribute__nonnull__(1)
+    __attribute__nonnull__(2)
+    __attribute__pure__;
 static int uvcompare(const void *a, const void *b)
 {
     if (*((const UV *)a) < (*(const UV *)b))
 static int uvcompare(const void *a, const void *b)
 {
     if (*((const UV *)a) < (*(const UV *)b))
@@ -2393,6 +2423,7 @@ static int uvcompare(const void *a, const void *b)
 OP *
 Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 {
 OP *
 Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 {
+    dVAR;
     SV * const tstr = ((SVOP*)expr)->op_sv;
     SV * const rstr = ((SVOP*)repl)->op_sv;
     STRLEN tlen;
     SV * const tstr = ((SVOP*)expr)->op_sv;
     SV * const rstr = ((SVOP*)repl)->op_sv;
     STRLEN tlen;
@@ -2416,8 +2447,8 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
         o->op_private |= OPpTRANS_TO_UTF;
 
     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
         o->op_private |= OPpTRANS_TO_UTF;
 
     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
-       SV* const listsv = newSVpvn("# comment\n",10);
-       SV* transv = 0;
+       SV* const listsv = newSVpvs("# comment\n");
+       SV* transv = NULL;
        const U8* tend = t + tlen;
        const U8* rend = r + rlen;
        STRLEN ulen;
        const U8* tend = t + tlen;
        const U8* rend = r + rlen;
        STRLEN ulen;
@@ -2461,7 +2492,7 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
            UV nextmin = 0;
            Newx(cp, 2*tlen, UV);
            i = 0;
            UV nextmin = 0;
            Newx(cp, 2*tlen, UV);
            i = 0;
-           transv = newSVpvn("",0);
+           transv = newSVpvs("");
            while (t < tend) {
                cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, 0);
                t += ulen;
            while (t < tend) {
                cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, 0);
                t += ulen;
@@ -2602,8 +2633,7 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
        Safefree(cPVOPo->op_pv);
        cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
        SvREFCNT_dec(listsv);
        Safefree(cPVOPo->op_pv);
        cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
        SvREFCNT_dec(listsv);
-       if (transv)
-           SvREFCNT_dec(transv);
+       SvREFCNT_dec(transv);
 
        if (!del && havefinal && rlen)
            (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5,
 
        if (!del && havefinal && rlen)
            (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5,
@@ -2612,10 +2642,8 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
        if (grows)
            o->op_private |= OPpTRANS_GROWS;
 
        if (grows)
            o->op_private |= OPpTRANS_GROWS;
 
-       if (tsave)
-           Safefree(tsave);
-       if (rsave)
-           Safefree(rsave);
+       Safefree(tsave);
+       Safefree(rsave);
 
        op_free(expr);
        op_free(repl);
 
        op_free(expr);
        op_free(repl);
@@ -2720,7 +2748,7 @@ Perl_newPMOP(pTHX_ I32 type, I32 flags)
        sv_setiv(repointer,0);
     } else {
        SV * const repointer = newSViv(0);
        sv_setiv(repointer,0);
     } else {
        SV * const repointer = newSViv(0);
-       av_push(PL_regex_padav,SvREFCNT_inc(repointer));
+       av_push(PL_regex_padav, SvREFCNT_inc_simple_NN(repointer));
        pmop->op_pmoffset = av_len(PL_regex_padav);
        PL_regex_pad = AvARRAY(PL_regex_padav);
     }
        pmop->op_pmoffset = av_len(PL_regex_padav);
        PL_regex_pad = AvARRAY(PL_regex_padav);
     }
@@ -2760,7 +2788,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
     PMOP *pm;
     LOGOP *rcop;
     I32 repl_has_vars = 0;
     PMOP *pm;
     LOGOP *rcop;
     I32 repl_has_vars = 0;
-    OP* repl  = Nullop;
+    OP* repl = NULL;
     bool reglist;
 
     if (o->op_type == OP_SUBST || o->op_type == OP_TRANS) {
     bool reglist;
 
     if (o->op_type == OP_SUBST || o->op_type == OP_TRANS) {
@@ -2770,7 +2798,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
        kid = cLISTOPx(expr)->op_first;
        while (kid->op_sibling != repl)
            kid = kid->op_sibling;
        kid = cLISTOPx(expr)->op_first;
        while (kid->op_sibling != repl)
            kid = kid->op_sibling;
-       kid->op_sibling = Nullop;
+       kid->op_sibling = NULL;
        cLISTOPx(expr)->op_last = kid;
     }
 
        cLISTOPx(expr)->op_last = kid;
     }
 
@@ -2780,8 +2808,8 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
        /* convert single element list to element */
        OP* const oe = expr;
        expr = cLISTOPx(oe)->op_first->op_sibling;
        /* convert single element list to element */
        OP* const oe = expr;
        expr = cLISTOPx(oe)->op_first->op_sibling;
-       cLISTOPx(oe)->op_first->op_sibling = Nullop;
-       cLISTOPx(oe)->op_last = Nullop;
+       cLISTOPx(oe)->op_first->op_sibling = NULL;
+       cLISTOPx(oe)->op_last = NULL;
        op_free(oe);
     }
 
        op_free(oe);
     }
 
@@ -2798,7 +2826,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
 
     if (expr->op_type == OP_CONST) {
        STRLEN plen;
 
     if (expr->op_type == OP_CONST) {
        STRLEN plen;
-       SV *pat = ((SVOP*)expr)->op_sv;
+       SV * const pat = ((SVOP*)expr)->op_sv;
        const char *p = SvPV_const(pat, plen);
        if ((o->op_flags & OPf_SPECIAL) && (*p == ' ' && p[1] == '\0')) {
            U32 was_readonly = SvREADONLY(pat);
        const char *p = SvPV_const(pat, plen);
        if ((o->op_flags & OPf_SPECIAL) && (*p == ' ' && p[1] == '\0')) {
            U32 was_readonly = SvREADONLY(pat);
@@ -2866,18 +2894,18 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
     if (repl) {
        OP *curop;
        if (pm->op_pmflags & PMf_EVAL) {
     if (repl) {
        OP *curop;
        if (pm->op_pmflags & PMf_EVAL) {
-           curop = 0;
+           curop = NULL;
            if (CopLINE(PL_curcop) < (line_t)PL_multi_end)
                CopLINE_set(PL_curcop, (line_t)PL_multi_end);
        }
        else if (repl->op_type == OP_CONST)
            curop = repl;
        else {
            if (CopLINE(PL_curcop) < (line_t)PL_multi_end)
                CopLINE_set(PL_curcop, (line_t)PL_multi_end);
        }
        else if (repl->op_type == OP_CONST)
            curop = repl;
        else {
-           OP *lastop = 0;
+           OP *lastop = NULL;
            for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
                if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
                    if (curop->op_type == OP_GV) {
            for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
                if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
                    if (curop->op_type == OP_GV) {
-                       GV *gv = cGVOPx_gv(curop);
+                       GV * const gv = cGVOPx_gv(curop);
                        repl_has_vars = 1;
                        if (strchr("&`'123456789+-\016\022", *GvENAME(gv)))
                            break;
                        repl_has_vars = 1;
                        if (strchr("&`'123456789+-\016\022", *GvENAME(gv)))
                            break;
@@ -2898,7 +2926,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
                        repl_has_vars = 1;
                    }
                    else if (curop->op_type == OP_PUSHRE)
                        repl_has_vars = 1;
                    }
                    else if (curop->op_type == OP_PUSHRE)
-                       ; /* Okay here, dangerous in newASSIGNOP */
+                       /*EMPTY*/; /* Okay here, dangerous in newASSIGNOP */
                    else
                        break;
                }
                    else
                        break;
                }
@@ -2986,9 +3014,9 @@ Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
 #ifdef USE_ITHREADS
     if (gv)
        GvIN_PAD_on(gv);
 #ifdef USE_ITHREADS
     if (gv)
        GvIN_PAD_on(gv);
-    return newPADOP(type, flags, SvREFCNT_inc(gv));
+    return newPADOP(type, flags, SvREFCNT_inc_simple(gv));
 #else
 #else
-    return newSVOP(type, flags, SvREFCNT_inc(gv));
+    return newSVOP(type, flags, SvREFCNT_inc_simple(gv));
 #endif
 }
 
 #endif
 }
 
@@ -3013,6 +3041,7 @@ Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
 void
 Perl_package(pTHX_ OP *o)
 {
 void
 Perl_package(pTHX_ OP *o)
 {
+    dVAR;
     const char *name;
     STRLEN len;
 
     const char *name;
     STRLEN len;
 
@@ -3032,6 +3061,7 @@ Perl_package(pTHX_ OP *o)
 void
 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 {
 void
 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 {
+    dVAR;
     OP *pack;
     OP *imop;
     OP *veop;
     OP *pack;
     OP *imop;
     OP *veop;
@@ -3039,7 +3069,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
     if (idop->op_type != OP_CONST)
        Perl_croak(aTHX_ "Module name must be constant");
 
     if (idop->op_type != OP_CONST)
        Perl_croak(aTHX_ "Module name must be constant");
 
-    veop = Nullop;
+    veop = NULL;
 
     if (version) {
        SV * const vesv = ((SVOP*)version)->op_sv;
 
     if (version) {
        SV * const vesv = ((SVOP*)version)->op_sv;
@@ -3058,7 +3088,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
            pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
 
            /* Fake up a method call to VERSION */
            pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
 
            /* Fake up a method call to VERSION */
-           meth = newSVpvn_share("VERSION", 7, 0);
+           meth = newSVpvs_share("VERSION");
            veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
                            append_elem(OP_LIST,
                                        prepend_elem(OP_LIST, pack, list(version)),
            veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
                            append_elem(OP_LIST,
                                        prepend_elem(OP_LIST, pack, list(version)),
@@ -3070,7 +3100,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
     if (arg && arg->op_type == OP_STUB)
        imop = arg;             /* no import on explicit () */
     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
     if (arg && arg->op_type == OP_STUB)
        imop = arg;             /* no import on explicit () */
     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
-       imop = Nullop;          /* use 5.0; */
+       imop = NULL;            /* use 5.0; */
        if (!aver)
            idop->op_private |= OPpCONST_NOVER;
     }
        if (!aver)
            idop->op_private |= OPpCONST_NOVER;
     }
@@ -3082,7 +3112,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 
        /* Fake up a method call to import/unimport */
        meth = aver
 
        /* Fake up a method call to import/unimport */
        meth = aver
-           ? newSVpvn_share("import",6, 0) : newSVpvn_share("unimport", 8, 0);
+           ? newSVpvs_share("import") : newSVpvs_share("unimport");
        imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
                       append_elem(OP_LIST,
                                   prepend_elem(OP_LIST, pack, list(arg)),
        imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
                       append_elem(OP_LIST,
                                   prepend_elem(OP_LIST, pack, list(arg)),
@@ -3091,14 +3121,14 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 
     /* Fake up the BEGIN {}, which does its thing immediately. */
     newATTRSUB(floor,
 
     /* Fake up the BEGIN {}, which does its thing immediately. */
     newATTRSUB(floor,
-       newSVOP(OP_CONST, 0, newSVpvn_share("BEGIN", 5, 0)),
-       Nullop,
-       Nullop,
+       newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
+       NULL,
+       NULL,
        append_elem(OP_LINESEQ,
            append_elem(OP_LINESEQ,
        append_elem(OP_LINESEQ,
            append_elem(OP_LINESEQ,
-               newSTATEOP(0, Nullch, newUNOP(OP_REQUIRE, 0, idop)),
-               newSTATEOP(0, Nullch, veop)),
-           newSTATEOP(0, Nullch, imop) ));
+               newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
+               newSTATEOP(0, NULL, veop)),
+           newSTATEOP(0, NULL, imop) ));
 
     /* The "did you use incorrect case?" warning used to be here.
      * The problem is that on case-insensitive filesystems one
 
     /* The "did you use incorrect case?" warning used to be here.
      * The problem is that on case-insensitive filesystems one
@@ -3163,6 +3193,7 @@ Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
 void
 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 {
 void
 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 {
+    dVAR;
     OP *veop, *imop;
 
     OP * const modname = newSVOP(OP_CONST, 0, name);
     OP *veop, *imop;
 
     OP * const modname = newSVOP(OP_CONST, 0, name);
@@ -3171,7 +3202,7 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
        veop = newSVOP(OP_CONST, 0, ver);
     }
     else
        veop = newSVOP(OP_CONST, 0, ver);
     }
     else
-       veop = Nullop;
+       veop = NULL;
     if (flags & PERL_LOADMOD_NOIMPORT) {
        imop = sawparens(newNULLLIST());
     }
     if (flags & PERL_LOADMOD_NOIMPORT) {
        imop = sawparens(newNULLLIST());
     }
@@ -3180,7 +3211,7 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
     }
     else {
        SV *sv;
     }
     else {
        SV *sv;
-       imop = Nullop;
+       imop = NULL;
        sv = va_arg(*args, SV*);
        while (sv) {
            imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
        sv = va_arg(*args, SV*);
        while (sv) {
            imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
@@ -3203,14 +3234,15 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 OP *
 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
 {
 OP *
 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
 {
+    dVAR;
     OP *doop;
     OP *doop;
-    GV *gv = Nullgv;
+    GV *gv = NULL;
 
     if (!force_builtin) {
 
     if (!force_builtin) {
-       gv = gv_fetchpv("do", FALSE, SVt_PVCV);
+       gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
        if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
        if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-           GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "do", 2, FALSE);
-           gv = gvp ? *gvp : Nullgv;
+           GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
+           gv = gvp ? *gvp : NULL;
        }
     }
 
        }
     }
 
@@ -3277,6 +3309,7 @@ S_is_list_assignment(pTHX_ register const OP *o)
 OP *
 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 {
 OP *
 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 {
+    dVAR;
     OP *o;
 
     if (optype) {
     OP *o;
 
     if (optype) {
@@ -3330,9 +3363,10 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
                if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
                    if (curop->op_type == OP_GV) {
                        GV *gv = cGVOPx_gv(curop);
                if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
                    if (curop->op_type == OP_GV) {
                        GV *gv = cGVOPx_gv(curop);
-                       if (gv == PL_defgv || (int)SvCUR(gv) == PL_generation)
+                       if (gv == PL_defgv
+                           || (int)GvASSIGN_GENERATION(gv) == PL_generation)
                            break;
                            break;
-                       SvCUR_set(gv, PL_generation);
+                       GvASSIGN_GENERATION_set(gv, PL_generation);
                    }
                    else if (curop->op_type == OP_PADSV ||
                             curop->op_type == OP_PADAV ||
                    }
                    else if (curop->op_type == OP_PADSV ||
                             curop->op_type == OP_PADAV ||
@@ -3362,9 +3396,11 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 #else
                            GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
 #endif
 #else
                            GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
 #endif
-                           if (gv == PL_defgv || (int)SvCUR(gv) == PL_generation)
+                           if (gv == PL_defgv
+                               || (int)GvASSIGN_GENERATION(gv) == PL_generation)
                                break;
                                break;
-                           SvCUR_set(gv, PL_generation);
+                           GvASSIGN_GENERATION_set(gv, PL_generation);
+                           GvASSIGN_GENERATION_set(gv, PL_generation);
                        }
                    }
                    else
                        }
                    }
                    else
@@ -3392,12 +3428,12 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
                        cPADOPx(tmpop)->op_padix = 0;   /* steal it */
 #else
                        pm->op_pmreplroot = (OP*)cSVOPx(tmpop)->op_sv;
                        cPADOPx(tmpop)->op_padix = 0;   /* steal it */
 #else
                        pm->op_pmreplroot = (OP*)cSVOPx(tmpop)->op_sv;
-                       cSVOPx(tmpop)->op_sv = Nullsv;  /* steal it */
+                       cSVOPx(tmpop)->op_sv = NULL;    /* steal it */
 #endif
                        pm->op_pmflags |= PMf_ONCE;
                        tmpop = cUNOPo->op_first;       /* to list (nulled) */
                        tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
 #endif
                        pm->op_pmflags |= PMf_ONCE;
                        tmpop = cUNOPo->op_first;       /* to list (nulled) */
                        tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
-                       tmpop->op_sibling = Nullop;     /* don't free split */
+                       tmpop->op_sibling = NULL;       /* don't free split */
                        right->op_next = tmpop->op_next;  /* fix starting loc */
                        op_free(o);                     /* blow off assign */
                        right->op_flags &= ~OPf_WANT;
                        right->op_next = tmpop->op_next;  /* fix starting loc */
                        op_free(o);                     /* blow off assign */
                        right->op_flags &= ~OPf_WANT;
@@ -3431,7 +3467,9 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
        if (PL_eval_start)
            PL_eval_start = 0;
        else {
        if (PL_eval_start)
            PL_eval_start = 0;
        else {
+           op_free(o);
            o = newSVOP(OP_CONST, 0, newSViv(PL_compiling.cop_arybase));
            o = newSVOP(OP_CONST, 0, newSViv(PL_compiling.cop_arybase));
+           o->op_private |= OPpCONST_ARYBASE;
        }
     }
     return o;
        }
     }
     return o;
@@ -3491,7 +3529,7 @@ Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
     CopSTASH_set(cop, PL_curstash);
 
     if (PERLDB_LINE && PL_curstash != PL_debstash) {
     CopSTASH_set(cop, PL_curstash);
 
     if (PERLDB_LINE && PL_curstash != PL_debstash) {
-       SV * const * const svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), FALSE);
+       SV * const * const svp = av_fetch(CopFILEAVx(PL_curcop), (I32)CopLINE(cop), FALSE);
        if (svp && *svp != &PL_sv_undef ) {
            (void)SvIOK_on(*svp);
            SvIV_set(*svp, PTR2IV(cop));
        if (svp && *svp != &PL_sv_undef ) {
            (void)SvIOK_on(*svp);
            SvIV_set(*svp, PTR2IV(cop));
@@ -3533,7 +3571,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
            first = *firstp = cUNOPo->op_first;
            if (o->op_next)
                first->op_next = o->op_next;
            first = *firstp = cUNOPo->op_first;
            if (o->op_next)
                first->op_next = o->op_next;
-           cUNOPo->op_first = Nullop;
+           cUNOPo->op_first = NULL;
            op_free(o);
        }
     }
            op_free(o);
        }
     }
@@ -3546,7 +3584,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
            (type == OP_OR  && !SvTRUE(((SVOP*)first)->op_sv)) ||
            (type == OP_DOR && !SvOK(((SVOP*)first)->op_sv))) {
            op_free(first);
            (type == OP_OR  && !SvTRUE(((SVOP*)first)->op_sv)) ||
            (type == OP_DOR && !SvOK(((SVOP*)first)->op_sv))) {
            op_free(first);
-           *firstp = Nullop;
+           *firstp = NULL;
            if (other->op_type == OP_CONST)
                other->op_private |= OPpCONST_SHORTCIRCUIT;
            return other;
            if (other->op_type == OP_CONST)
                other->op_private |= OPpCONST_SHORTCIRCUIT;
            return other;
@@ -3570,7 +3608,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
            }
 
            op_free(other);
            }
 
            op_free(other);
-           *otherp = Nullop;
+           *otherp = NULL;
            if (first->op_type == OP_CONST)
                first->op_private |= OPpCONST_SHORTCIRCUIT;
            return first;
            if (first->op_type == OP_CONST)
                first->op_private |= OPpCONST_SHORTCIRCUIT;
            return first;
@@ -3750,6 +3788,7 @@ Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
 OP *
 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
 {
 OP *
 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
 {
+    dVAR;
     OP* listop;
     OP* o;
     const bool once = block && block->op_flags & OPf_SPECIAL &&
     OP* listop;
     OP* o;
     const bool once = block && block->op_flags & OPf_SPECIAL &&
@@ -3814,7 +3853,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 {
     dVAR;
     OP *redo;
 {
     dVAR;
     OP *redo;
-    OP *next = 0;
+    OP *next = NULL;
     OP *listop;
     OP *o;
     U8 loopflags = 0;
     OP *listop;
     OP *o;
     U8 loopflags = 0;
@@ -3874,7 +3913,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
        if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
            op_free(expr);              /* oops, it's a while (0) */
            op_free((OP*)loop);
        if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
            op_free(expr);              /* oops, it's a while (0) */
            op_free((OP*)loop);
-           return Nullop;              /* listop already freed by new_logop */
+           return NULL;                /* listop already freed by new_logop */
        }
        if (listop)
            ((LISTOP*)listop)->op_last->op_next =
        }
        if (listop)
            ((LISTOP*)listop)->op_last->op_next =
@@ -3930,14 +3969,14 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
            padoff = sv->op_targ;
            sv->op_targ = 0;
            op_free(sv);
            padoff = sv->op_targ;
            sv->op_targ = 0;
            op_free(sv);
-           sv = Nullop;
+           sv = NULL;
        }
        else if (sv->op_type == OP_THREADSV) { /* per-thread variable */
            padoff = sv->op_targ;
            sv->op_targ = 0;
            iterflags |= OPf_SPECIAL;
            op_free(sv);
        }
        else if (sv->op_type == OP_THREADSV) { /* per-thread variable */
            padoff = sv->op_targ;
            sv->op_targ = 0;
            iterflags |= OPf_SPECIAL;
            op_free(sv);
-           sv = Nullop;
+           sv = NULL;
        }
        else
            Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
        }
        else
            Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
@@ -3946,7 +3985,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
     }
     else {
         const I32 offset = pad_findmy("$_");
     }
     else {
         const I32 offset = pad_findmy("$_");
-       if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+       if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
            sv = newGVOP(OP_GV, 0, PL_defgv);
        }
        else {
            sv = newGVOP(OP_GV, 0, PL_defgv);
        }
        else {
@@ -3973,7 +4012,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
        LISTOP* listop;
 
        range->op_flags &= ~OPf_KIDS;
        LISTOP* listop;
 
        range->op_flags &= ~OPf_KIDS;
-       range->op_first = Nullop;
+       range->op_first = NULL;
 
        listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
        listop->op_first->op_next = range->op_next;
 
        listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
        listop->op_first->op_next = range->op_next;
@@ -4016,6 +4055,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
 OP*
 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
 {
 OP*
 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
 {
+    dVAR;
     OP *o;
 
     if (type != OP_GOTO || label->op_type == OP_CONST) {
     OP *o;
 
     if (type != OP_GOTO || label->op_type == OP_CONST) {
@@ -4075,6 +4115,7 @@ S_newGIVWHENOP(pTHX_ OP *cond, OP *block,
                   I32 enter_opcode, I32 leave_opcode,
                   PADOFFSET entertarg)
 {
                   I32 enter_opcode, I32 leave_opcode,
                   PADOFFSET entertarg)
 {
+    dVAR;
     LOGOP *enterop;
     OP *o;
 
     LOGOP *enterop;
     OP *o;
 
@@ -4127,6 +4168,7 @@ STATIC
 bool
 S_looks_like_bool(pTHX_ OP *o)
 {
 bool
 S_looks_like_bool(pTHX_ OP *o)
 {
+    dVAR;
     switch(o->op_type) {
        case OP_OR:
            return looks_like_bool(cLOGOPo->op_first);
     switch(o->op_type) {
        case OP_OR:
            return looks_like_bool(cLOGOPo->op_first);
@@ -4182,6 +4224,7 @@ S_looks_like_bool(pTHX_ OP *o)
 OP *
 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off)
 {
 OP *
 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off)
 {
+    dVAR;
     assert( cond );
     return newGIVWHENOP(
        ref_array_or_hash(cond),
     assert( cond );
     return newGIVWHENOP(
        ref_array_or_hash(cond),
@@ -4227,27 +4270,27 @@ Perl_cv_undef(pTHX_ CV *cv)
 {
     dVAR;
 #ifdef USE_ITHREADS
 {
     dVAR;
 #ifdef USE_ITHREADS
-    if (CvFILE(cv) && !CvXSUB(cv)) {
+    if (CvFILE(cv) && !CvISXSUB(cv)) {
        /* for XSUBs CvFILE point directly to static memory; __FILE__ */
        Safefree(CvFILE(cv));
     }
     CvFILE(cv) = 0;
 #endif
 
        /* for XSUBs CvFILE point directly to static memory; __FILE__ */
        Safefree(CvFILE(cv));
     }
     CvFILE(cv) = 0;
 #endif
 
-    if (!CvXSUB(cv) && CvROOT(cv)) {
-       if (CvDEPTH(cv))
+    if (!CvISXSUB(cv) && CvROOT(cv)) {
+       if (SvTYPE(cv) == SVt_PVCV && CvDEPTH(cv))
            Perl_croak(aTHX_ "Can't undef active subroutine");
        ENTER;
 
        PAD_SAVE_SETNULLPAD();
 
        op_free(CvROOT(cv));
            Perl_croak(aTHX_ "Can't undef active subroutine");
        ENTER;
 
        PAD_SAVE_SETNULLPAD();
 
        op_free(CvROOT(cv));
-       CvROOT(cv) = Nullop;
-       CvSTART(cv) = Nullop;
+       CvROOT(cv) = NULL;
+       CvSTART(cv) = NULL;
        LEAVE;
     }
     SvPOK_off((SV*)cv);                /* forget prototype */
        LEAVE;
     }
     SvPOK_off((SV*)cv);                /* forget prototype */
-    CvGV(cv) = Nullgv;
+    CvGV(cv) = NULL;
 
     pad_undef(cv);
 
 
     pad_undef(cv);
 
@@ -4255,14 +4298,14 @@ Perl_cv_undef(pTHX_ CV *cv)
     if (!SvREFCNT(cv) && CvOUTSIDE(cv)) {
        if (!CvWEAKOUTSIDE(cv))
            SvREFCNT_dec(CvOUTSIDE(cv));
     if (!SvREFCNT(cv) && CvOUTSIDE(cv)) {
        if (!CvWEAKOUTSIDE(cv))
            SvREFCNT_dec(CvOUTSIDE(cv));
-       CvOUTSIDE(cv) = Nullcv;
+       CvOUTSIDE(cv) = NULL;
     }
     if (CvCONST(cv)) {
        SvREFCNT_dec((SV*)CvXSUBANY(cv).any_ptr);
        CvCONST_off(cv);
     }
     }
     if (CvCONST(cv)) {
        SvREFCNT_dec((SV*)CvXSUBANY(cv).any_ptr);
        CvCONST_off(cv);
     }
-    if (CvXSUB(cv)) {
-        CvXSUB(cv) = 0;
+    if (CvISXSUB(cv) && CvXSUB(cv)) {
+       CvXSUB(cv) = NULL;
     }
     /* delete all flags except WEAKOUTSIDE */
     CvFLAGS(cv) &= CVf_WEAKOUTSIDE;
     }
     /* delete all flags except WEAKOUTSIDE */
     CvFLAGS(cv) &= CVf_WEAKOUTSIDE;
@@ -4273,22 +4316,22 @@ Perl_cv_ckproto(pTHX_ const CV *cv, const GV *gv, const char *p)
 {
     if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX_const(cv)))) && ckWARN_d(WARN_PROTOTYPE)) {
        SV* const msg = sv_newmortal();
 {
     if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX_const(cv)))) && ckWARN_d(WARN_PROTOTYPE)) {
        SV* const msg = sv_newmortal();
-       SV* name = Nullsv;
+       SV* name = NULL;
 
        if (gv)
 
        if (gv)
-           gv_efullname3(name = sv_newmortal(), gv, Nullch);
+           gv_efullname3(name = sv_newmortal(), gv, NULL);
        sv_setpv(msg, "Prototype mismatch:");
        if (name)
            Perl_sv_catpvf(aTHX_ msg, " sub %"SVf, name);
        if (SvPOK(cv))
            Perl_sv_catpvf(aTHX_ msg, " (%"SVf")", (const SV *)cv);
        else
        sv_setpv(msg, "Prototype mismatch:");
        if (name)
            Perl_sv_catpvf(aTHX_ msg, " sub %"SVf, name);
        if (SvPOK(cv))
            Perl_sv_catpvf(aTHX_ msg, " (%"SVf")", (const SV *)cv);
        else
-           Perl_sv_catpv(aTHX_ msg, ": none");
-       sv_catpv(msg, " vs ");
+           sv_catpvs(msg, ": none");
+       sv_catpvs(msg, " vs ");
        if (p)
            Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
        else
        if (p)
            Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
        else
-           sv_catpv(msg, "none");
+           sv_catpvs(msg, "none");
        Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE), "%"SVf, msg);
     }
 }
        Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE), "%"SVf, msg);
     }
 }
@@ -4312,9 +4355,12 @@ L<perlsub/"Constant Functions">.
 SV *
 Perl_cv_const_sv(pTHX_ CV *cv)
 {
 SV *
 Perl_cv_const_sv(pTHX_ CV *cv)
 {
-    if (!cv || !CvCONST(cv))
-       return Nullsv;
-    return (SV*)CvXSUBANY(cv).any_ptr;
+    PERL_UNUSED_CONTEXT;
+    if (!cv)
+       return NULL;
+    if (!(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM))
+       return NULL;
+    return CvCONST(cv) ? (SV*)CvXSUBANY(cv).any_ptr : NULL;
 }
 
 /* op_const_sv:  examine an optree to determine whether it's in-lineable.
 }
 
 /* op_const_sv:  examine an optree to determine whether it's in-lineable.
@@ -4340,10 +4386,11 @@ Perl_cv_const_sv(pTHX_ CV *cv)
 SV *
 Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 {
 SV *
 Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 {
-    SV *sv = Nullsv;
+    dVAR;
+    SV *sv = NULL;
 
     if (!o)
 
     if (!o)
-       return Nullsv;
+       return NULL;
 
     if (o->op_type == OP_LINESEQ && cLISTOPo->op_first)
        o = cLISTOPo->op_first->op_sibling;
 
     if (o->op_type == OP_LINESEQ && cLISTOPo->op_first)
        o = cLISTOPo->op_first->op_sibling;
@@ -4362,13 +4409,13 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
        if (type == OP_LEAVESUB || type == OP_RETURN)
            break;
        if (sv)
        if (type == OP_LEAVESUB || type == OP_RETURN)
            break;
        if (sv)
-           return Nullsv;
+           return NULL;
        if (type == OP_CONST && cSVOPo->op_sv)
            sv = cSVOPo->op_sv;
        else if (cv && type == OP_CONST) {
            sv = PAD_BASE_SV(CvPADLIST(cv), o->op_targ);
            if (!sv)
        if (type == OP_CONST && cSVOPo->op_sv)
            sv = cSVOPo->op_sv;
        else if (cv && type == OP_CONST) {
            sv = PAD_BASE_SV(CvPADLIST(cv), o->op_targ);
            if (!sv)
-               return Nullsv;
+               return NULL;
        }
        else if (cv && type == OP_PADSV) {
            if (CvCONST(cv)) { /* newly cloned anon */
        }
        else if (cv && type == OP_PADSV) {
            if (CvCONST(cv)) { /* newly cloned anon */
@@ -4376,7 +4423,7 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
                /* the candidate should have 1 ref from this pad and 1 ref
                 * from the parent */
                if (!sv || SvREFCNT(sv) != 2)
                /* the candidate should have 1 ref from this pad and 1 ref
                 * from the parent */
                if (!sv || SvREFCNT(sv) != 2)
-                   return Nullsv;
+                   return NULL;
                sv = newSVsv(sv);
                SvREADONLY_on(sv);
                return sv;
                sv = newSVsv(sv);
                SvREADONLY_on(sv);
                return sv;
@@ -4387,7 +4434,7 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
            }
        }
        else {
            }
        }
        else {
-           return Nullsv;
+           return NULL;
        }
     }
     return sv;
        }
     }
     return sv;
@@ -4412,7 +4459,7 @@ Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 CV *
 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
 {
 CV *
 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
 {
-    return Perl_newATTRSUB(aTHX_ floor, o, proto, Nullop, block);
+    return Perl_newATTRSUB(aTHX_ floor, o, proto, NULL, block);
 }
 
 CV *
 }
 
 CV *
@@ -4423,18 +4470,24 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
     GV *gv;
     const char *ps;
     STRLEN ps_len;
     GV *gv;
     const char *ps;
     STRLEN ps_len;
-    register CV *cv=0;
+    register CV *cv = NULL;
     SV *const_sv;
     SV *const_sv;
-    I32 gv_fetch_flags;
-
-    const char * const name = o ? SvPVx_nolen_const(cSVOPo->op_sv) : Nullch;
+    /* If the subroutine has no body, no attributes, and no builtin attributes
+       then it's just a sub declaration, and we may be able to get away with
+       storing with a placeholder scalar in the symbol table, rather than a
+       full GV and CV.  If anything is present then it will take a full CV to
+       store it.  */
+    const I32 gv_fetch_flags
+       = (block || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
+       ? GV_ADDMULTI : GV_ADDMULTI | GV_NOINIT;
+    const char * const name = o ? SvPVx_nolen_const(cSVOPo->op_sv) : NULL;
 
     if (proto) {
        assert(proto->op_type == OP_CONST);
        ps = SvPVx_const(((SVOP*)proto)->op_sv, ps_len);
     }
     else
 
     if (proto) {
        assert(proto->op_type == OP_CONST);
        ps = SvPVx_const(((SVOP*)proto)->op_sv, ps_len);
     }
     else
-       ps = Nullch;
+       ps = NULL;
 
     if (!name && PERLDB_NAMEANON && CopLINE(PL_curcop)) {
        SV * const sv = sv_newmortal();
 
     if (!name && PERLDB_NAMEANON && CopLINE(PL_curcop)) {
        SV * const sv = sv_newmortal();
@@ -4444,10 +4497,8 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
        aname = SvPVX_const(sv);
     }
     else
        aname = SvPVX_const(sv);
     }
     else
-       aname = Nullch;
+       aname = NULL;
 
 
-    gv_fetch_flags = (block || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
-       ? GV_ADDMULTI : GV_ADDMULTI | GV_NOINIT;
     gv = name ? gv_fetchsv(cSVOPo->op_sv, gv_fetch_flags, SVt_PVCV)
        : gv_fetchpv(aname ? aname
                     : (PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
     gv = name ? gv_fetchsv(cSVOPo->op_sv, gv_fetch_flags, SVt_PVCV)
        : gv_fetchpv(aname ? aname
                     : (PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
@@ -4480,7 +4531,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
        goto done;
     }
 
        goto done;
     }
 
-    cv = (!name || GvCVGEN(gv)) ? Nullcv : GvCV(gv);
+    cv = (!name || GvCVGEN(gv)) ? NULL : GvCV(gv);
 
 #ifdef GV_UNIQUE_CHECK
     if (cv && GvUNIQUE(gv) && SvREADONLY(cv)) {
 
 #ifdef GV_UNIQUE_CHECK
     if (cv && GvUNIQUE(gv) && SvREADONLY(cv)) {
@@ -4489,9 +4540,9 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 #endif
 
     if (!block || !ps || *ps || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
 #endif
 
     if (!block || !ps || *ps || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
-       const_sv = Nullsv;
+       const_sv = NULL;
     else
     else
-       const_sv = op_const_sv(block, Nullcv);
+       const_sv = op_const_sv(block, NULL);
 
     if (cv) {
         const bool exists = CvROOT(cv) || CvXSUB(cv);
 
     if (cv) {
         const bool exists = CvROOT(cv) || CvXSUB(cv);
@@ -4533,21 +4584,22 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
                    CopLINE_set(PL_curcop, oldline);
                }
                SvREFCNT_dec(cv);
                    CopLINE_set(PL_curcop, oldline);
                }
                SvREFCNT_dec(cv);
-               cv = Nullcv;
+               cv = NULL;
            }
        }
     }
     if (const_sv) {
            }
        }
     }
     if (const_sv) {
-       (void)SvREFCNT_inc(const_sv);
+       SvREFCNT_inc_void_NN(const_sv);
        if (cv) {
            assert(!CvROOT(cv) && !CvCONST(cv));
            sv_setpvn((SV*)cv, "", 0);  /* prototype is "" */
            CvXSUBANY(cv).any_ptr = const_sv;
            CvXSUB(cv) = const_sv_xsub;
            CvCONST_on(cv);
        if (cv) {
            assert(!CvROOT(cv) && !CvCONST(cv));
            sv_setpvn((SV*)cv, "", 0);  /* prototype is "" */
            CvXSUBANY(cv).any_ptr = const_sv;
            CvXSUB(cv) = const_sv_xsub;
            CvCONST_on(cv);
+           CvISXSUB_on(cv);
        }
        else {
        }
        else {
-           GvCV(gv) = Nullcv;
+           GvCV(gv) = NULL;
            cv = newCONSTSUB(NULL, name, const_sv);
        }
        op_free(block);
            cv = newCONSTSUB(NULL, name, const_sv);
        }
        op_free(block);
@@ -4625,7 +4677,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 
     if (PL_error_count) {
        op_free(block);
 
     if (PL_error_count) {
        op_free(block);
-       block = Nullop;
+       block = NULL;
        if (name) {
            const char *s = strrchr(name, ':');
            s = s ? s+1 : name;
        if (name) {
            const char *s = strrchr(name, ':');
            s = s ? s+1 : name;
@@ -4653,7 +4705,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
        /* This makes sub {}; work as expected.  */
        if (block->op_type == OP_STUB) {
            op_free(block);
        /* This makes sub {}; work as expected.  */
        if (block->op_type == OP_STUB) {
            op_free(block);
-           block = newSTATEOP(0, Nullch, 0);
+           block = newSTATEOP(0, NULL, 0);
        }
        CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
     }
        }
        CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
     }
@@ -4678,15 +4730,16 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
        const char * const tname = (name ? name : aname);
 
        if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
        const char * const tname = (name ? name : aname);
 
        if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
-           SV * const sv = NEWSV(0,0);
+           SV * const sv = newSV(0);
            SV * const tmpstr = sv_newmortal();
            SV * const tmpstr = sv_newmortal();
-           GV * const db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
+           GV * const db_postponed = gv_fetchpvs("DB::postponed",
+                                                 GV_ADDMULTI, SVt_PVHV);
            HV *hv;
 
            Perl_sv_setpvf(aTHX_ sv, "%s:%ld-%ld",
                           CopFILE(PL_curcop),
                           (long)PL_subline, (long)CopLINE(PL_curcop));
            HV *hv;
 
            Perl_sv_setpvf(aTHX_ sv, "%s:%ld-%ld",
                           CopFILE(PL_curcop),
                           (long)PL_subline, (long)CopLINE(PL_curcop));
-           gv_efullname3(tmpstr, gv, Nullch);
+           gv_efullname3(tmpstr, gv, NULL);
            hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr), SvCUR(tmpstr), sv, 0);
            hv = GvHVn(db_postponed);
            if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvCUR(tmpstr))) {
            hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr), SvCUR(tmpstr), sv, 0);
            hv = GvHVn(db_postponed);
            if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvCUR(tmpstr))) {
@@ -4817,6 +4870,7 @@ Used by C<xsubpp> to hook up XSUBs as Perl subs.
 CV *
 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
 {
 CV *
 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
 {
+    dVAR;
     GV * const gv = gv_fetchpv(name ? name :
                        (PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
                        GV_ADDMULTI, SVt_PVCV);
     GV * const gv = gv_fetchpv(name ? name :
                        (PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
                        GV_ADDMULTI, SVt_PVCV);
@@ -4825,11 +4879,11 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
     if (!subaddr)
        Perl_croak(aTHX_ "panic: no address for '%s' in '%s'", name, filename);
 
     if (!subaddr)
        Perl_croak(aTHX_ "panic: no address for '%s' in '%s'", name, filename);
 
-    if ((cv = (name ? GvCV(gv) : Nullcv))) {
+    if ((cv = (name ? GvCV(gv) : NULL))) {
        if (GvCVGEN(gv)) {
            /* just a cached method */
            SvREFCNT_dec(cv);
        if (GvCVGEN(gv)) {
            /* just a cached method */
            SvREFCNT_dec(cv);
-           cv = Nullcv;
+           cv = NULL;
        }
        else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
            /* already defined (or promised) */
        }
        else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
            /* already defined (or promised) */
@@ -4839,8 +4893,8 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
                if (gvcv) {
                    HV * const stash = GvSTASH(gvcv);
                    if (stash) {
                if (gvcv) {
                    HV * const stash = GvSTASH(gvcv);
                    if (stash) {
-                       const char *name = HvNAME_get(stash);
-                       if ( strEQ(name,"autouse") ) {
+                       const char *redefined_name = HvNAME_get(stash);
+                       if ( strEQ(redefined_name,"autouse") ) {
                            const line_t oldline = CopLINE(PL_curcop);
                            if (PL_copline != NOLINE)
                                CopLINE_set(PL_curcop, PL_copline);
                            const line_t oldline = CopLINE(PL_curcop);
                            if (PL_copline != NOLINE)
                                CopLINE_set(PL_curcop, PL_copline);
@@ -4854,14 +4908,14 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
                }
            }
            SvREFCNT_dec(cv);
                }
            }
            SvREFCNT_dec(cv);
-           cv = Nullcv;
+           cv = NULL;
        }
     }
 
     if (cv)                            /* must reuse cv if autoloaded */
        cv_undef(cv);
     else {
        }
     }
 
     if (cv)                            /* must reuse cv if autoloaded */
        cv_undef(cv);
     else {
-       cv = (CV*)NEWSV(1105,0);
+       cv = (CV*)newSV(0);
        sv_upgrade((SV *)cv, SVt_PVCV);
        if (name) {
            GvCV(gv) = cv;
        sv_upgrade((SV *)cv, SVt_PVCV);
        if (name) {
            GvCV(gv) = cv;
@@ -4873,6 +4927,7 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
     (void)gv_fetchfile(filename);
     CvFILE(cv) = (char *)filename; /* NOTE: not copied, as it is expected to be
                                   an external constant string */
     (void)gv_fetchfile(filename);
     CvFILE(cv) = (char *)filename; /* NOTE: not copied, as it is expected to be
                                   an external constant string */
+    CvISXSUB_on(cv);
     CvXSUB(cv) = subaddr;
 
     if (name) {
     CvXSUB(cv) = subaddr;
 
     if (name) {
@@ -4926,11 +4981,12 @@ done:
 void
 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
 {
 void
 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
 {
+    dVAR;
     register CV *cv;
 
     GV * const gv = o
     register CV *cv;
 
     GV * const gv = o
-       ? gv_fetchsv(cSVOPo->op_sv, TRUE, SVt_PVFM)
-       : gv_fetchpv("STDOUT", TRUE, SVt_PVFM);
+       ? gv_fetchsv(cSVOPo->op_sv, GV_ADD, SVt_PVFM)
+       : gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVFM);
 
 #ifdef GV_UNIQUE_CHECK
     if (GvUNIQUE(gv)) {
 
 #ifdef GV_UNIQUE_CHECK
     if (GvUNIQUE(gv)) {
@@ -4985,7 +5041,7 @@ Perl_newANONHASH(pTHX_ OP *o)
 OP *
 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
 {
 OP *
 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
 {
-    return newANONATTRSUB(floor, proto, Nullop, block);
+    return newANONATTRSUB(floor, proto, NULL, block);
 }
 
 OP *
 }
 
 OP *
@@ -5117,13 +5173,14 @@ OP *
 Perl_ck_anoncode(pTHX_ OP *o)
 {
     cSVOPo->op_targ = pad_add_anon(cSVOPo->op_sv, o->op_type);
 Perl_ck_anoncode(pTHX_ OP *o)
 {
     cSVOPo->op_targ = pad_add_anon(cSVOPo->op_sv, o->op_type);
-    cSVOPo->op_sv = Nullsv;
+    cSVOPo->op_sv = NULL;
     return o;
 }
 
 OP *
 Perl_ck_bitop(pTHX_ OP *o)
 {
     return o;
 }
 
 OP *
 Perl_ck_bitop(pTHX_ OP *o)
 {
+    dVAR;
 #define OP_IS_NUMCOMPARE(op) \
        ((op) == OP_LT   || (op) == OP_I_LT || \
         (op) == OP_GT   || (op) == OP_I_GT || \
 #define OP_IS_NUMCOMPARE(op) \
        ((op) == OP_LT   || (op) == OP_I_LT || \
         (op) == OP_GT   || (op) == OP_I_GT || \
@@ -5158,6 +5215,7 @@ OP *
 Perl_ck_concat(pTHX_ OP *o)
 {
     const OP * const kid = cUNOPo->op_first;
 Perl_ck_concat(pTHX_ OP *o)
 {
     const OP * const kid = cUNOPo->op_first;
+    PERL_UNUSED_CONTEXT;
     if (kid->op_type == OP_CONCAT && !(kid->op_private & OPpTARGET_MY) &&
            !(kUNOP->op_first->op_flags & OPf_MOD))
         o->op_flags |= OPf_STACKED;
     if (kid->op_type == OP_CONCAT && !(kid->op_private & OPpTARGET_MY) &&
            !(kUNOP->op_first->op_flags & OPf_MOD))
         o->op_flags |= OPf_STACKED;
@@ -5230,6 +5288,7 @@ Perl_ck_die(pTHX_ OP *o)
 OP *
 Perl_ck_eof(pTHX_ OP *o)
 {
 OP *
 Perl_ck_eof(pTHX_ OP *o)
 {
+    dVAR;
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_KIDS) {
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_KIDS) {
@@ -5284,8 +5343,7 @@ Perl_ck_eval(pTHX_ OP *o)
        o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
     }
     o->op_targ = (PADOFFSET)PL_hints;
        o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
     }
     o->op_targ = (PADOFFSET)PL_hints;
-    if ((PL_hints & HINT_HH_FOR_EVAL) != 0 && GvHV(PL_hintgv))
-    {
+    if ((PL_hints & HINT_LOCALIZE_HH) != 0 && GvHV(PL_hintgv)) {
        /* Store a copy of %^H that pp_entereval can pick up */
        OP *hhop = newSVOP(OP_CONST, 0, (SV*)newHVhv(GvHV(PL_hintgv)));
        cUNOPo->op_first->op_sibling = hhop;
        /* Store a copy of %^H that pp_entereval can pick up */
        OP *hhop = newSVOP(OP_CONST, 0, (SV*)newHVhv(GvHV(PL_hintgv)));
        cUNOPo->op_first->op_sibling = hhop;
@@ -5300,7 +5358,7 @@ Perl_ck_exit(pTHX_ OP *o)
 #ifdef VMS
     HV * const table = GvHV(PL_hintgv);
     if (table) {
 #ifdef VMS
     HV * const table = GvHV(PL_hintgv);
     if (table) {
-       SV * const * const svp = hv_fetch(table, "vmsish_exit", 11, FALSE);
+       SV * const * const svp = hv_fetchs(table, "vmsish_exit", FALSE);
        if (svp && *svp && SvTRUE(*svp))
            o->op_private |= OPpEXIT_VMSISH;
     }
        if (svp && *svp && SvTRUE(*svp))
            o->op_private |= OPpEXIT_VMSISH;
     }
@@ -5327,6 +5385,7 @@ Perl_ck_exec(pTHX_ OP *o)
 OP *
 Perl_ck_exists(pTHX_ OP *o)
 {
 OP *
 Perl_ck_exists(pTHX_ OP *o)
 {
+    dVAR;
     o = ck_fun(o);
     if (o->op_flags & OPf_KIDS) {
        OP * const kid = cUNOPo->op_first;
     o = ck_fun(o);
     if (o->op_flags & OPf_KIDS) {
        OP * const kid = cUNOPo->op_first;
@@ -5354,6 +5413,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
     SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
     SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
+    if (o->op_type == OP_RV2CV)
+       o->op_private &= ~1;
+
     if (kid->op_type == OP_CONST) {
        int iscv;
        GV *gv;
     if (kid->op_type == OP_CONST) {
        int iscv;
        GV *gv;
@@ -5363,7 +5425,7 @@ Perl_ck_rvconst(pTHX_ register OP *o)
        if (SvROK(kidsv) && SvREADONLY(kidsv)) {
            SV * const rsv = SvRV(kidsv);
            const int svtype = SvTYPE(rsv);
        if (SvROK(kidsv) && SvREADONLY(kidsv)) {
            SV * const rsv = SvRV(kidsv);
            const int svtype = SvTYPE(rsv);
-            const char *badtype = Nullch;
+            const char *badtype = NULL;
 
            switch (o->op_type) {
            case OP_RV2SV:
 
            switch (o->op_type) {
            case OP_RV2SV:
@@ -5387,8 +5449,19 @@ Perl_ck_rvconst(pTHX_ register OP *o)
                Perl_croak(aTHX_ "Constant is not %s reference", badtype);
            return o;
        }
                Perl_croak(aTHX_ "Constant is not %s reference", badtype);
            return o;
        }
-       if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
-            const char *badthing = Nullch;
+       else if ((o->op_type == OP_RV2HV || o->op_type == OP_RV2SV) &&
+               (PL_hints & HINT_STRICT_REFS) && SvPOK(kidsv)) {
+           /* If this is an access to a stash, disable "strict refs", because
+            * stashes aren't auto-vivified at compile-time (unless we store
+            * symbols in them), and we don't want to produce a run-time
+            * stricture error when auto-vivifying the stash. */
+           const char *s = SvPV_nolen(kidsv);
+           const STRLEN l = SvCUR(kidsv);
+           if (l > 1 && s[l-1] == ':' && s[l-2] == ':')
+               o->op_private &= ~HINT_STRICT_REFS;
+       }
+       if ((o->op_private & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
+           const char *badthing;
            switch (o->op_type) {
            case OP_RV2SV:
                badthing = "a SCALAR";
            switch (o->op_type) {
            case OP_RV2SV:
                badthing = "a SCALAR";
@@ -5399,6 +5472,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
            case OP_RV2HV:
                badthing = "a HASH";
                break;
            case OP_RV2HV:
                badthing = "a HASH";
                break;
+           default:
+               badthing = NULL;
+               break;
            }
            if (badthing)
                Perl_croak(aTHX_
            }
            if (badthing)
                Perl_croak(aTHX_
@@ -5435,9 +5511,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
            kPADOP->op_padix = pad_alloc(OP_GV, SVs_PADTMP);
            SvREFCNT_dec(PAD_SVl(kPADOP->op_padix));
            GvIN_PAD_on(gv);
            kPADOP->op_padix = pad_alloc(OP_GV, SVs_PADTMP);
            SvREFCNT_dec(PAD_SVl(kPADOP->op_padix));
            GvIN_PAD_on(gv);
-           PAD_SETSV(kPADOP->op_padix, (SV*) SvREFCNT_inc(gv));
+           PAD_SETSV(kPADOP->op_padix, (SV*) SvREFCNT_inc_simple_NN(gv));
 #else
 #else
-           kid->op_sv = SvREFCNT_inc(gv);
+           kid->op_sv = SvREFCNT_inc_simple_NN(gv);
 #endif
            kid->op_private = 0;
            kid->op_ppaddr = PL_ppaddr[OP_GV];
 #endif
            kid->op_private = 0;
            kid->op_ppaddr = PL_ppaddr[OP_GV];
@@ -5453,14 +5529,14 @@ Perl_ck_ftst(pTHX_ OP *o)
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_REF) {
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_REF) {
-       /* nothing */
+       /*EMPTY*/;
     }
     else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
        SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
        if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
            OP * const newop = newGVOP(type, OPf_REF,
     }
     else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
        SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
        if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
            OP * const newop = newGVOP(type, OPf_REF,
-               gv_fetchsv(kid->op_sv, TRUE, SVt_PVIO));
+               gv_fetchsv(kid->op_sv, GV_ADD, SVt_PVIO));
            op_free(o);
            o = newop;
            return o;
            op_free(o);
            o = newop;
            return o;
@@ -5487,6 +5563,7 @@ Perl_ck_ftst(pTHX_ OP *o)
 OP *
 Perl_ck_fun(pTHX_ OP *o)
 {
 OP *
 Perl_ck_fun(pTHX_ OP *o)
 {
+    dVAR;
     const int type = o->op_type;
     register I32 oa = PL_opargs[type] >> OASHIFT;
 
     const int type = o->op_type;
     register I32 oa = PL_opargs[type] >> OASHIFT;
 
@@ -5544,7 +5621,7 @@ Perl_ck_fun(pTHX_ OP *o)
                    (kid->op_private & OPpCONST_BARE))
                {
                    OP * const newop = newAVREF(newGVOP(OP_GV, 0,
                    (kid->op_private & OPpCONST_BARE))
                {
                    OP * const newop = newAVREF(newGVOP(OP_GV, 0,
-                       gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVAV) ));
+                       gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVAV) ));
                    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
                        Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
                            "Array @%"SVf" missing the @ in argument %"IVdf" of %s()",
                    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
                        Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
                            "Array @%"SVf" missing the @ in argument %"IVdf" of %s()",
@@ -5563,7 +5640,7 @@ Perl_ck_fun(pTHX_ OP *o)
                    (kid->op_private & OPpCONST_BARE))
                {
                    OP * const newop = newHVREF(newGVOP(OP_GV, 0,
                    (kid->op_private & OPpCONST_BARE))
                {
                    OP * const newop = newHVREF(newGVOP(OP_GV, 0,
-                       gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVHV) ));
+                       gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVHV) ));
                    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
                        Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
                            "Hash %%%"SVf" missing the %% in argument %"IVdf" of %s()",
                    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
                        Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
                            "Hash %%%"SVf" missing the %% in argument %"IVdf" of %s()",
@@ -5594,7 +5671,7 @@ Perl_ck_fun(pTHX_ OP *o)
                        (kid->op_private & OPpCONST_BARE))
                    {
                        OP * const newop = newGVOP(OP_GV, 0,
                        (kid->op_private & OPpCONST_BARE))
                    {
                        OP * const newop = newGVOP(OP_GV, 0,
-                           gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVIO) );
+                           gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVIO));
                        if (!(o->op_private & 1) && /* if not unop */
                            kid == cLISTOPo->op_last)
                            cLISTOPo->op_last = newop;
                        if (!(o->op_private & 1) && /* if not unop */
                            kid == cLISTOPo->op_last)
                            cLISTOPo->op_last = newop;
@@ -5612,7 +5689,7 @@ Perl_ck_fun(pTHX_ OP *o)
 
                        /* is this op a FH constructor? */
                        if (is_handle_constructor(o,numargs)) {
 
                        /* is this op a FH constructor? */
                        if (is_handle_constructor(o,numargs)) {
-                            const char *name = Nullch;
+                            const char *name = NULL;
                            STRLEN len = 0;
 
                            flags = 0;
                            STRLEN len = 0;
 
                            flags = 0;
@@ -5641,9 +5718,9 @@ Perl_ck_fun(pTHX_ OP *o)
                                     || kid->op_type == OP_HELEM)
                            {
                                 OP *op = ((BINOP*)kid)->op_first;
                                     || kid->op_type == OP_HELEM)
                            {
                                 OP *op = ((BINOP*)kid)->op_first;
-                                name = 0;
+                                name = NULL;
                                 if (op) {
                                 if (op) {
-                                     SV *tmpstr = Nullsv;
+                                     SV *tmpstr = NULL;
                                      const char * const a =
                                           kid->op_type == OP_AELEM ?
                                           "[]" : "{}";
                                      const char * const a =
                                           kid->op_type == OP_AELEM ?
                                           "[]" : "{}";
@@ -5740,10 +5817,10 @@ Perl_ck_glob(pTHX_ OP *o)
     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
        append_elem(OP_GLOB, o, newDEFSVOP());
 
     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
        append_elem(OP_GLOB, o, newDEFSVOP());
 
-    if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV))
+    if (!((gv = gv_fetchpvs("glob", GV_NOTQUAL, SVt_PVCV))
          && GvCVu(gv) && GvIMPORTED_CV(gv)))
     {
          && GvCVu(gv) && GvIMPORTED_CV(gv)))
     {
-       gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
+       gv = gv_fetchpvs("CORE::GLOBAL::glob", 0, SVt_PVCV);
     }
 
 #if !defined(PERL_EXTERNAL_GLOB)
     }
 
 #if !defined(PERL_EXTERNAL_GLOB)
@@ -5752,11 +5829,11 @@ Perl_ck_glob(pTHX_ OP *o)
        GV *glob_gv;
        ENTER;
        Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
        GV *glob_gv;
        ENTER;
        Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-               newSVpvn("File::Glob", 10), Nullsv, Nullsv, Nullsv);
-       gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
-       glob_gv = gv_fetchpv("File::Glob::csh_glob", FALSE, SVt_PVCV);
+               newSVpvs("File::Glob"), NULL, NULL, NULL);
+       gv = gv_fetchpvs("CORE::GLOBAL::glob", 0, SVt_PVCV);
+       glob_gv = gv_fetchpvs("File::Glob::csh_glob", 0, SVt_PVCV);
        GvCV(gv) = GvCV(glob_gv);
        GvCV(gv) = GvCV(glob_gv);
-       (void)SvREFCNT_inc((SV*)GvCV(gv));
+       SvREFCNT_inc_void((SV*)GvCV(gv));
        GvIMPORTED_CV_on(gv);
        LEAVE;
     }
        GvIMPORTED_CV_on(gv);
        LEAVE;
     }
@@ -5829,7 +5906,7 @@ Perl_ck_grep(pTHX_ OP *o)
     gwop->op_other = LINKLIST(kid);
     kid->op_next = (OP*)gwop;
     offset = pad_findmy("$_");
     gwop->op_other = LINKLIST(kid);
     kid->op_next = (OP*)gwop;
     offset = pad_findmy("$_");
-    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
        o->op_private = gwop->op_private = 0;
        gwop->op_targ = pad_alloc(type, SVs_PADTMP);
     }
        o->op_private = gwop->op_private = 0;
        gwop->op_targ = pad_alloc(type, SVs_PADTMP);
     }
@@ -5955,19 +6032,20 @@ Perl_ck_say(pTHX_ OP *o)
     o = ck_listiob(o);
     o->op_type = OP_PRINT;
     cLISTOPo->op_last = cLISTOPo->op_last->op_sibling
     o = ck_listiob(o);
     o->op_type = OP_PRINT;
     cLISTOPo->op_last = cLISTOPo->op_last->op_sibling
-       = newSVOP(OP_CONST, 0, newSVpvn("\n", 1));
+       = newSVOP(OP_CONST, 0, newSVpvs("\n"));
     return o;
 }
 
 OP *
 Perl_ck_smartmatch(pTHX_ OP *o)
 {
     return o;
 }
 
 OP *
 Perl_ck_smartmatch(pTHX_ OP *o)
 {
+    dVAR;
     if (0 == (o->op_flags & OPf_SPECIAL)) {
        OP *first  = cBINOPo->op_first;
        OP *second = first->op_sibling;
        
        /* Implicitly take a reference to an array or hash */
     if (0 == (o->op_flags & OPf_SPECIAL)) {
        OP *first  = cBINOPo->op_first;
        OP *second = first->op_sibling;
        
        /* Implicitly take a reference to an array or hash */
-       first->op_sibling = Nullop;
+       first->op_sibling = NULL;
        first = cBINOPo->op_first = ref_array_or_hash(first);
        second = first->op_sibling = ref_array_or_hash(second);
        
        first = cBINOPo->op_first = ref_array_or_hash(first);
        second = first->op_sibling = ref_array_or_hash(second);
        
@@ -6019,9 +6097,10 @@ Perl_ck_sassign(pTHX_ OP *o)
 OP *
 Perl_ck_match(pTHX_ OP *o)
 {
 OP *
 Perl_ck_match(pTHX_ OP *o)
 {
+    dVAR;
     if (o->op_type != OP_QR && PL_compcv) {
        const I32 offset = pad_findmy("$_");
     if (o->op_type != OP_QR && PL_compcv) {
        const I32 offset = pad_findmy("$_");
-       if (offset != NOT_IN_PAD && !(PAD_COMPNAME_FLAGS(offset) & SVpad_OUR)) {
+       if (offset != NOT_IN_PAD && !(PAD_COMPNAME_FLAGS_isOUR(offset))) {
            o->op_targ = offset;
            o->op_private |= OPpTARGET_MY;
        }
            o->op_targ = offset;
            o->op_private |= OPpTARGET_MY;
        }
@@ -6037,13 +6116,14 @@ Perl_ck_method(pTHX_ OP *o)
     OP * const kid = cUNOPo->op_first;
     if (kid->op_type == OP_CONST) {
        SV* sv = kSVOP->op_sv;
     OP * const kid = cUNOPo->op_first;
     if (kid->op_type == OP_CONST) {
        SV* sv = kSVOP->op_sv;
-       if (!(strchr(SvPVX_const(sv), ':') || strchr(SvPVX_const(sv), '\''))) {
+       const char * const method = SvPVX_const(sv);
+       if (!(strchr(method, ':') || strchr(method, '\''))) {
            OP *cmop;
            if (!SvREADONLY(sv) || !SvFAKE(sv)) {
            OP *cmop;
            if (!SvREADONLY(sv) || !SvFAKE(sv)) {
-               sv = newSVpvn_share(SvPVX_const(sv), SvCUR(sv), 0);
+               sv = newSVpvn_share(method, SvCUR(sv), 0);
            }
            else {
            }
            else {
-               kSVOP->op_sv = Nullsv;
+               kSVOP->op_sv = NULL;
            }
            cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
            op_free(o);
            }
            cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
            op_free(o);
@@ -6056,15 +6136,17 @@ Perl_ck_method(pTHX_ OP *o)
 OP *
 Perl_ck_null(pTHX_ OP *o)
 {
 OP *
 Perl_ck_null(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     return o;
 }
 
 OP *
 Perl_ck_open(pTHX_ OP *o)
 {
     return o;
 }
 
 OP *
 Perl_ck_open(pTHX_ OP *o)
 {
+    dVAR;
     HV * const table = GvHV(PL_hintgv);
     if (table) {
     HV * const table = GvHV(PL_hintgv);
     if (table) {
-       SV **svp = hv_fetch(table, "open_IN", 7, FALSE);
+       SV **svp = hv_fetchs(table, "open_IN", FALSE);
        if (svp && *svp) {
            const I32 mode = mode_from_discipline(*svp);
            if (mode & O_BINARY)
        if (svp && *svp) {
            const I32 mode = mode_from_discipline(*svp);
            if (mode & O_BINARY)
@@ -6073,7 +6155,7 @@ Perl_ck_open(pTHX_ OP *o)
                o->op_private |= OPpOPEN_IN_CRLF;
        }
 
                o->op_private |= OPpOPEN_IN_CRLF;
        }
 
-       svp = hv_fetch(table, "open_OUT", 8, FALSE);
+       svp = hv_fetchs(table, "open_OUT", FALSE);
        if (svp && *svp) {
            const I32 mode = mode_from_discipline(*svp);
            if (mode & O_BINARY)
        if (svp && *svp) {
            const I32 mode = mode_from_discipline(*svp);
            if (mode & O_BINARY)
@@ -6122,7 +6204,8 @@ Perl_ck_repeat(pTHX_ OP *o)
 OP *
 Perl_ck_require(pTHX_ OP *o)
 {
 OP *
 Perl_ck_require(pTHX_ OP *o)
 {
-    GV* gv = Nullgv;
+    dVAR;
+    GV* gv = NULL;
 
     if (o->op_flags & OPf_KIDS) {      /* Shall we supply missing .pm? */
        SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
     if (o->op_flags & OPf_KIDS) {      /* Shall we supply missing .pm? */
        SVOP * const kid = (SVOP*)cUNOPo->op_first;
@@ -6150,17 +6233,17 @@ Perl_ck_require(pTHX_ OP *o)
                    SvCUR_set(sv, SvCUR(sv) - 1);
                }
            }
                    SvCUR_set(sv, SvCUR(sv) - 1);
                }
            }
-           sv_catpvn(sv, ".pm", 3);
+           sv_catpvs(sv, ".pm");
            SvFLAGS(sv) |= was_readonly;
        }
     }
 
     if (!(o->op_flags & OPf_SPECIAL)) { /* Wasn't written as CORE::require */
        /* handle override, if any */
            SvFLAGS(sv) |= was_readonly;
        }
     }
 
     if (!(o->op_flags & OPf_SPECIAL)) { /* Wasn't written as CORE::require */
        /* handle override, if any */
-       gv = gv_fetchpv("require", FALSE, SVt_PVCV);
+       gv = gv_fetchpvs("require", GV_NOTQUAL, SVt_PVCV);
        if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
        if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-           GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "require", 7, FALSE);
-           gv = gvp ? *gvp : Nullgv;
+           GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "require", FALSE);
+           gv = gvp ? *gvp : NULL;
        }
     }
 
        }
     }
 
@@ -6181,6 +6264,7 @@ Perl_ck_require(pTHX_ OP *o)
 OP *
 Perl_ck_return(pTHX_ OP *o)
 {
 OP *
 Perl_ck_return(pTHX_ OP *o)
 {
+    dVAR;
     if (CvLVALUE(PL_compcv)) {
         OP *kid;
        for (kid = cLISTOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
     if (CvLVALUE(PL_compcv)) {
         OP *kid;
        for (kid = cLISTOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
@@ -6213,6 +6297,7 @@ Perl_ck_select(pTHX_ OP *o)
 OP *
 Perl_ck_shift(pTHX_ OP *o)
 {
 OP *
 Perl_ck_shift(pTHX_ OP *o)
 {
+    dVAR;
     const I32 type = o->op_type;
 
     if (!(o->op_flags & OPf_KIDS)) {
     const I32 type = o->op_type;
 
     if (!(o->op_flags & OPf_KIDS)) {
@@ -6229,15 +6314,16 @@ Perl_ck_shift(pTHX_ OP *o)
 OP *
 Perl_ck_sort(pTHX_ OP *o)
 {
 OP *
 Perl_ck_sort(pTHX_ OP *o)
 {
+    dVAR;
     OP *firstkid;
 
     if (o->op_type == OP_SORT && (PL_hints & HINT_LOCALIZE_HH) != 0)
     {
     OP *firstkid;
 
     if (o->op_type == OP_SORT && (PL_hints & HINT_LOCALIZE_HH) != 0)
     {
-       HV *hinthv = GvHV(PL_hintgv);
+       HV * const hinthv = GvHV(PL_hintgv);
        if (hinthv) {
        if (hinthv) {
-           SV **svp = hv_fetch(hinthv, "sort", 4, 0);
+           SV ** const svp = hv_fetchs(hinthv, "sort", FALSE);
            if (svp) {
            if (svp) {
-               I32 sorthints = (I32)SvIV(*svp);
+               const I32 sorthints = (I32)SvIV(*svp);
                if ((sorthints & HINT_SORT_QUICKSORT) != 0)
                    o->op_private |= OPpSORT_QSORT;
                if ((sorthints & HINT_SORT_STABLE) != 0)
                if ((sorthints & HINT_SORT_QUICKSORT) != 0)
                    o->op_private |= OPpSORT_QSORT;
                if ((sorthints & HINT_SORT_STABLE) != 0)
@@ -6307,6 +6393,7 @@ Perl_ck_sort(pTHX_ OP *o)
 STATIC void
 S_simplify_sort(pTHX_ OP *o)
 {
 STATIC void
 S_simplify_sort(pTHX_ OP *o)
 {
+    dVAR;
     register OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
     OP *k;
     int descending;
     register OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
     OP *k;
     int descending;
@@ -6314,8 +6401,8 @@ S_simplify_sort(pTHX_ OP *o)
     const char *gvname;
     if (!(o->op_flags & OPf_STACKED))
        return;
     const char *gvname;
     if (!(o->op_flags & OPf_STACKED))
        return;
-    GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV));
-    GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV));
+    GvMULTI_on(gv_fetchpvs("a", GV_ADD|GV_NOTQUAL, SVt_PV));
+    GvMULTI_on(gv_fetchpvs("b", GV_ADD|GV_NOTQUAL, SVt_PV));
     kid = kUNOP->op_first;                             /* get past null */
     if (kid->op_type != OP_SCOPE)
        return;
     kid = kUNOP->op_first;                             /* get past null */
     if (kid->op_type != OP_SCOPE)
        return;
@@ -6389,7 +6476,7 @@ Perl_ck_split(pTHX_ OP *o)
     op_free(cLISTOPo->op_first);
     cLISTOPo->op_first = kid;
     if (!kid) {
     op_free(cLISTOPo->op_first);
     cLISTOPo->op_first = kid;
     if (!kid) {
-       cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1));
+       cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvs(" "));
        cLISTOPo->op_last = kid; /* There was only one element previously */
     }
 
        cLISTOPo->op_last = kid; /* There was only one element previously */
     }
 
@@ -6448,17 +6535,18 @@ Perl_ck_join(pTHX_ OP *o)
 OP *
 Perl_ck_subr(pTHX_ OP *o)
 {
 OP *
 Perl_ck_subr(pTHX_ OP *o)
 {
+    dVAR;
     OP *prev = ((cUNOPo->op_first->op_sibling)
             ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
     OP *o2 = prev->op_sibling;
     OP *cvop;
     OP *prev = ((cUNOPo->op_first->op_sibling)
             ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
     OP *o2 = prev->op_sibling;
     OP *cvop;
-    char *proto = 0;
-    CV *cv = 0;
-    GV *namegv = 0;
+    char *proto = NULL;
+    CV *cv = NULL;
+    GV *namegv = NULL;
     int optional = 0;
     I32 arg = 0;
     I32 contextclass = 0;
     int optional = 0;
     I32 arg = 0;
     I32 contextclass = 0;
-    char *e = 0;
+    char *e = NULL;
     bool delete_op = 0;
 
     o->op_private |= OPpENTERSUB_HASTARG;
     bool delete_op = 0;
 
     o->op_private |= OPpENTERSUB_HASTARG;
@@ -6498,9 +6586,9 @@ Perl_ck_subr(pTHX_ OP *o)
        if (o2->op_type == OP_CONST)
            o2->op_private &= ~OPpCONST_STRICT;
        else if (o2->op_type == OP_LIST) {
        if (o2->op_type == OP_CONST)
            o2->op_private &= ~OPpCONST_STRICT;
        else if (o2->op_type == OP_LIST) {
-           OP * const o = ((UNOP*)o2)->op_first->op_sibling;
-           if (o && o->op_type == OP_CONST)
-               o->op_private &= ~OPpCONST_STRICT;
+           OP * const sib = ((UNOP*)o2)->op_first->op_sibling;
+           if (sib && sib->op_type == OP_CONST)
+               sib->op_private &= ~OPpCONST_STRICT;
        }
     }
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
        }
     }
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
@@ -6556,7 +6644,7 @@ Perl_ck_subr(pTHX_ OP *o)
                            {
                                GV * const gv = cGVOPx_gv(gvop);
                                OP * const sibling = o2->op_sibling;
                            {
                                GV * const gv = cGVOPx_gv(gvop);
                                OP * const sibling = o2->op_sibling;
-                               SV * const n = newSVpvn("",0);
+                               SV * const n = newSVpvs("");
                                op_free(o2);
                                gv_fullname4(n, gv, "", FALSE);
                                o2 = newSVOP(OP_CONST, 0, n);
                                op_free(o2);
                                gv_fullname4(n, gv, "", FALSE);
                                o2 = newSVOP(OP_CONST, 0, n);
@@ -6683,11 +6771,28 @@ Perl_ck_subr(pTHX_ OP *o)
 OP *
 Perl_ck_svconst(pTHX_ OP *o)
 {
 OP *
 Perl_ck_svconst(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     SvREADONLY_on(cSVOPo->op_sv);
     return o;
 }
 
 OP *
     SvREADONLY_on(cSVOPo->op_sv);
     return o;
 }
 
 OP *
+Perl_ck_chdir(pTHX_ OP *o)
+{
+    if (o->op_flags & OPf_KIDS) {
+       SVOP *kid = (SVOP*)cUNOPo->op_first;
+
+       if (kid && kid->op_type == OP_CONST &&
+           (kid->op_private & OPpCONST_BARE))
+       {
+           o->op_flags |= OPf_SPECIAL;
+           kid->op_private &= ~OPpCONST_STRICT;
+       }
+    }
+    return ck_fun(o);
+}
+
+OP *
 Perl_ck_trunc(pTHX_ OP *o)
 {
     if (o->op_flags & OPf_KIDS) {
 Perl_ck_trunc(pTHX_ OP *o)
 {
     if (o->op_flags & OPf_KIDS) {
@@ -6741,7 +6846,7 @@ void
 Perl_peep(pTHX_ register OP *o)
 {
     dVAR;
 Perl_peep(pTHX_ register OP *o)
 {
     dVAR;
-    register OP* oldop = 0;
+    register OP* oldop = NULL;
 
     if (!o || o->op_opt)
        return;
 
     if (!o || o->op_opt)
        return;
@@ -6777,6 +6882,18 @@ Perl_peep(pTHX_ register OP *o)
                    SvREADONLY_on(PAD_SVl(ix));
                    SvREFCNT_dec(cSVOPo->op_sv);
                }
                    SvREADONLY_on(PAD_SVl(ix));
                    SvREFCNT_dec(cSVOPo->op_sv);
                }
+               else if (o->op_type == OP_CONST
+                        && cSVOPo->op_sv == &PL_sv_undef) {
+                   /* PL_sv_undef is hack - it's unsafe to store it in the
+                      AV that is the pad, because av_fetch treats values of
+                      PL_sv_undef as a "free" AV entry and will merrily
+                      replace them with a new SV, causing pad_alloc to think
+                      that this pad slot is free. (When, clearly, it is not)
+                   */
+                   SvOK_off(PAD_SVl(ix));
+                   SvPADTMP_on(PAD_SVl(ix));
+                   SvREADONLY_on(PAD_SVl(ix));
+               }
                else {
                    SvREFCNT_dec(PAD_SVl(ix));
                    SvPADTMP_on(cSVOPo->op_sv);
                else {
                    SvREFCNT_dec(PAD_SVl(ix));
                    SvPADTMP_on(cSVOPo->op_sv);
@@ -6784,7 +6901,7 @@ Perl_peep(pTHX_ register OP *o)
                    /* XXX I don't know how this isn't readonly already. */
                    SvREADONLY_on(PAD_SVl(ix));
                }
                    /* XXX I don't know how this isn't readonly already. */
                    SvREADONLY_on(PAD_SVl(ix));
                }
-               cSVOPo->op_sv = Nullsv;
+               cSVOPo->op_sv = NULL;
                o->op_targ = ix;
            }
 #endif
                o->op_targ = ix;
            }
 #endif
@@ -6895,7 +7012,7 @@ Perl_peep(pTHX_ register OP *o)
                if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
                    /* XXX could check prototype here instead of just carping */
                    SV * const sv = sv_newmortal();
                if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
                    /* XXX could check prototype here instead of just carping */
                    SV * const sv = sv_newmortal();
-                   gv_efullname3(sv, gv, Nullch);
+                   gv_efullname3(sv, gv, NULL);
                    Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
                                "%"SVf"() called too early to check prototype",
                                sv);
                    Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
                                "%"SVf"() called too early to check prototype",
                                sv);
@@ -7008,9 +7125,9 @@ Perl_peep(pTHX_ register OP *o)
            if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
                break;
            lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
            if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
                break;
            lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
-           if (!(SvFLAGS(lexname) & SVpad_TYPED))
+           if (!SvPAD_TYPED(lexname))
                break;
                break;
-           fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
+           fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
            if (!fields || !GvHV(*fields))
                break;
            key = SvPV_const(*svp, keylen);
            if (!fields || !GvHV(*fields))
                break;
            key = SvPV_const(*svp, keylen);
@@ -7057,9 +7174,9 @@ Perl_peep(pTHX_ register OP *o)
            }
                    
            lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
            }
                    
            lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
-           if (!(SvFLAGS(lexname) & SVpad_TYPED))
+           if (!SvPAD_TYPED(lexname))
                break;
                break;
-           fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
+           fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
            if (!fields || !GvHV(*fields))
                break;
            /* Again guessing that the pushmark can be jumped over.... */
            if (!fields || !GvHV(*fields))
                break;
            /* Again guessing that the pushmark can be jumped over.... */
@@ -7290,6 +7407,58 @@ Perl_peep(pTHX_ register OP *o)
            
            break;
        }
            
            break;
        }
+
+       case OP_SASSIGN: {
+           OP *rv2gv;
+           UNOP *refgen, *rv2cv;
+           LISTOP *exlist;
+
+           /* I do not understand this, but if o->op_opt isn't set to 1,
+              various tests in ext/B/t/bytecode.t fail with no readily
+              apparent cause.  */
+
+           o->op_opt = 1;
+
+
+           if ((o->op_flags && OPf_WANT) != OPf_WANT_VOID)
+               break;
+
+           if ((o->op_private & ~OPpASSIGN_BACKWARDS) != 2)
+               break;
+
+           rv2gv = ((BINOP *)o)->op_last;
+           if (!rv2gv || rv2gv->op_type != OP_RV2GV)
+               break;
+
+           refgen = (UNOP *)((BINOP *)o)->op_first;
+
+           if (!refgen || refgen->op_type != OP_REFGEN)
+               break;
+
+           exlist = (LISTOP *)refgen->op_first;
+           if (!exlist || exlist->op_type != OP_NULL
+               || exlist->op_targ != OP_LIST)
+               break;
+
+           if (exlist->op_first->op_type != OP_PUSHMARK)
+               break;
+
+           rv2cv = (UNOP*)exlist->op_last;
+
+           if (rv2cv->op_type != OP_RV2CV)
+               break;
+
+           assert ((rv2gv->op_private & OPpDONT_INIT_GV) == 0);
+           assert ((o->op_private & OPpASSIGN_CV_TO_GV) == 0);
+           assert ((rv2cv->op_private & OPpMAY_RETURN_CONSTANT) == 0);
+
+           o->op_private |= OPpASSIGN_CV_TO_GV;
+           rv2gv->op_private |= OPpDONT_INIT_GV;
+           rv2cv->op_private |= OPpMAY_RETURN_CONSTANT;
+
+           break;
+       }
+
        
        default:
            o->op_opt = 1;
        
        default:
            o->op_opt = 1;
@@ -7303,6 +7472,7 @@ Perl_peep(pTHX_ register OP *o)
 char*
 Perl_custom_op_name(pTHX_ const OP* o)
 {
 char*
 Perl_custom_op_name(pTHX_ const OP* o)
 {
+    dVAR;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
@@ -7322,6 +7492,7 @@ Perl_custom_op_name(pTHX_ const OP* o)
 char*
 Perl_custom_op_desc(pTHX_ const OP* o)
 {
 char*
 Perl_custom_op_desc(pTHX_ const OP* o)
 {
+    dVAR;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
@@ -7344,8 +7515,10 @@ Perl_custom_op_desc(pTHX_ const OP* o)
 static void
 const_sv_xsub(pTHX_ CV* cv)
 {
 static void
 const_sv_xsub(pTHX_ CV* cv)
 {
+    dVAR;
     dXSARGS;
     if (items != 0) {
     dXSARGS;
     if (items != 0) {
+       /*EMPTY*/;
 #if 0
         Perl_croak(aTHX_ "usage: %s::%s()",
                    HvNAME_get(GvSTASH(CvGV(cv))), GvNAME(CvGV(cv)));
 #if 0
         Perl_croak(aTHX_ "usage: %s::%s()",
                    HvNAME_get(GvSTASH(CvGV(cv))), GvNAME(CvGV(cv)));
Unnamed repository; edit this file 'description' to name the repository.