X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/c6ae76470e6575530141df6c32cf71111bc2e391..8e7d0c4b4f9a32461518a61c3643c060cadc7b52:/scope.c diff --git a/scope.c b/scope.c index 88fb53a..95fe5f7 100644 --- a/scope.c +++ b/scope.c @@ -77,7 +77,7 @@ Perl_cxinc(pTHX) dVAR; const IV old_max = cxstack_max; cxstack_max = GROW(cxstack_max); - Renew(cxstack, cxstack_max + 1, PERL_CONTEXT); /* XXX should fix CXINC macro */ + Renew(cxstack, cxstack_max + 1, PERL_CONTEXT); /* Without any kind of initialising deep enough recursion * will end up reading uninitialised PERL_CONTEXTs. */ PoisonNew(cxstack + old_max + 1, cxstack_max - old_max, PERL_CONTEXT); @@ -91,7 +91,13 @@ Perl_push_scope(pTHX) if (PL_scopestack_ix == PL_scopestack_max) { PL_scopestack_max = GROW(PL_scopestack_max); Renew(PL_scopestack, PL_scopestack_max, I32); +#ifdef DEBUGGING + Renew(PL_scopestack_name, PL_scopestack_max, const char*); +#endif } +#ifdef DEBUGGING + PL_scopestack_name[PL_scopestack_ix] = "unknown"; +#endif PL_scopestack[PL_scopestack_ix++] = PL_savestack_ix; } @@ -167,11 +173,14 @@ STATIC SV * S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) { dVAR; - SV * const osv = *sptr; - register SV * const sv = *sptr = newSV(0); + SV * osv; + register SV *sv; PERL_ARGS_ASSERT_SAVE_SCALAR_AT; + osv = *sptr; + sv = (flags & SAVEf_KEEPOLDELEM) ? osv : (*sptr = newSV(0)); + if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) { if (SvGMAGICAL(osv)) { const bool oldtainted = PL_tainted; @@ -179,11 +188,23 @@ S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; PL_tainted = oldtainted; } - mg_localize(osv, sv, (flags & SAVEf_SETMAGIC) != 0); + if (!(flags & SAVEf_KEEPOLDELEM)) + mg_localize(osv, sv, (flags & SAVEf_SETMAGIC) != 0); } + return sv; } +void +Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type) +{ + dVAR; + SSCHECK(3); + SSPUSHPTR(ptr1); + SSPUSHPTR(ptr2); + SSPUSHUV(type); +} + SV * Perl_save_scalar(pTHX_ GV *gv) { @@ -195,10 +216,7 @@ Perl_save_scalar(pTHX_ GV *gv) PL_localizing = 1; SvGETMAGIC(*sptr); PL_localizing = 0; - SSCHECK(3); - SSPUSHPTR(SvREFCNT_inc_simple(gv)); - SSPUSHPTR(SvREFCNT_inc(*sptr)); - SSPUSHINT(SAVEt_SV); + save_pushptrptr(SvREFCNT_inc_simple(gv), SvREFCNT_inc(*sptr), SAVEt_SV); return save_scalar_at(sptr, SAVEf_SETMAGIC); /* XXX - FIXME - see #60360 */ } @@ -211,10 +229,7 @@ Perl_save_generic_svref(pTHX_ SV **sptr) PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF; - SSCHECK(3); - SSPUSHPTR(sptr); - SSPUSHPTR(SvREFCNT_inc(*sptr)); - SSPUSHINT(SAVEt_GENERIC_SVREF); + save_pushptrptr(sptr, SvREFCNT_inc(*sptr), SAVEt_GENERIC_SVREF); } /* Like save_pptr(), but also Safefree()s the new value if it is different @@ -227,10 +242,7 @@ Perl_save_generic_pvref(pTHX_ char **str) PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF; - SSCHECK(3); - SSPUSHPTR(*str); - SSPUSHPTR(str); - SSPUSHINT(SAVEt_GENERIC_PVREF); + save_pushptrptr(*str, str, SAVEt_GENERIC_PVREF); } /* Like save_generic_pvref(), but uses PerlMemShared_free() rather than Safefree(). @@ -243,10 +255,7 @@ Perl_save_shared_pvref(pTHX_ char **str) PERL_ARGS_ASSERT_SAVE_SHARED_PVREF; - SSCHECK(3); - SSPUSHPTR(str); - SSPUSHPTR(*str); - SSPUSHINT(SAVEt_SHARED_PVREF); + save_pushptrptr(str, *str, SAVEt_SHARED_PVREF); } /* set the SvFLAGS specified by mask to the values in val */ @@ -262,7 +271,7 @@ Perl_save_set_svflags(pTHX_ SV* sv, U32 mask, U32 val) SSPUSHPTR(sv); SSPUSHINT(mask); SSPUSHINT(val); - SSPUSHINT(SAVEt_SET_SVFLAGS); + SSPUSHUV(SAVEt_SET_SVFLAGS); } void @@ -272,10 +281,15 @@ Perl_save_gp(pTHX_ GV *gv, I32 empty) PERL_ARGS_ASSERT_SAVE_GP; - SSGROW(3); - SSPUSHPTR(SvREFCNT_inc(gv)); + SSCHECK(4); + SSPUSHINT(SvFAKE(gv)); SSPUSHPTR(GvGP(gv)); - SSPUSHINT(SAVEt_GP); + SSPUSHPTR(SvREFCNT_inc(gv)); + SSPUSHUV(SAVEt_GP); + + /* Don't let the localized GV coerce into non-glob, otherwise we would + * not be able to restore GP upon leave from context if that happened */ + SvFAKE_off(gv); if (empty) { GP *gp = Perl_newGP(aTHX_ gv); @@ -313,10 +327,7 @@ Perl_save_ary(pTHX_ GV *gv) if (!AvREAL(oav) && AvREIFY(oav)) av_reify(oav); - SSCHECK(3); - SSPUSHPTR(gv); - SSPUSHPTR(oav); - SSPUSHINT(SAVEt_AV); + save_pushptrptr(gv, oav, SAVEt_AV); GvAV(gv) = NULL; av = GvAVn(gv); @@ -333,10 +344,7 @@ Perl_save_hash(pTHX_ GV *gv) PERL_ARGS_ASSERT_SAVE_HASH; - SSCHECK(3); - SSPUSHPTR(gv); - SSPUSHPTR(ohv = GvHVn(gv)); - SSPUSHINT(SAVEt_HV); + save_pushptrptr(gv, (ohv = GvHVn(gv)), SAVEt_HV); GvHV(gv) = NULL; hv = GvHVn(gv); @@ -353,36 +361,47 @@ Perl_save_item(pTHX_ register SV *item) PERL_ARGS_ASSERT_SAVE_ITEM; - SSCHECK(3); - SSPUSHPTR(item); /* remember the pointer */ - SSPUSHPTR(sv); /* remember the value */ - SSPUSHINT(SAVEt_ITEM); + save_pushptrptr(item, /* remember the pointer */ + sv, /* remember the value */ + SAVEt_ITEM); } void -Perl_save_int(pTHX_ int *intp) +Perl_save_bool(pTHX_ bool *boolp) { dVAR; - PERL_ARGS_ASSERT_SAVE_INT; + PERL_ARGS_ASSERT_SAVE_BOOL; + SSCHECK(2); + SSPUSHPTR(boolp); + SSPUSHUV(SAVEt_BOOL | (*boolp << 8)); +} + +void +Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type) +{ + dVAR; SSCHECK(3); - SSPUSHINT(*intp); - SSPUSHPTR(intp); - SSPUSHINT(SAVEt_INT); + SSPUSHINT(i); + SSPUSHPTR(ptr); + SSPUSHUV(type); } void -Perl_save_bool(pTHX_ bool *boolp) +Perl_save_int(pTHX_ int *intp) { dVAR; + const UV shifted = (UV)*intp << SAVE_TIGHT_SHIFT; - PERL_ARGS_ASSERT_SAVE_BOOL; + PERL_ARGS_ASSERT_SAVE_INT; - SSCHECK(3); - SSPUSHBOOL(*boolp); - SSPUSHPTR(boolp); - SSPUSHINT(SAVEt_BOOL); + if ((int)(shifted >> SAVE_TIGHT_SHIFT) == *intp) { + SSCHECK(2); + SSPUSHPTR(intp); + SSPUSHUV(SAVEt_INT_SMALL | shifted); + } else + save_pushi32ptr(*intp, intp, SAVEt_INT); } void @@ -392,10 +411,9 @@ Perl_save_I8(pTHX_ I8 *bytep) PERL_ARGS_ASSERT_SAVE_I8; - SSCHECK(3); - SSPUSHINT(*bytep); + SSCHECK(2); SSPUSHPTR(bytep); - SSPUSHINT(SAVEt_I8); + SSPUSHUV(SAVEt_I8 | ((UV)*bytep << 8)); } void @@ -405,23 +423,25 @@ Perl_save_I16(pTHX_ I16 *intp) PERL_ARGS_ASSERT_SAVE_I16; - SSCHECK(3); - SSPUSHINT(*intp); + SSCHECK(2); SSPUSHPTR(intp); - SSPUSHINT(SAVEt_I16); + SSPUSHUV(SAVEt_I16 | ((UV)*intp << 8)); } void Perl_save_I32(pTHX_ I32 *intp) { dVAR; + const UV shifted = (UV)*intp << SAVE_TIGHT_SHIFT; PERL_ARGS_ASSERT_SAVE_I32; - SSCHECK(3); - SSPUSHINT(*intp); - SSPUSHPTR(intp); - SSPUSHINT(SAVEt_I32); + if ((I32)(shifted >> SAVE_TIGHT_SHIFT) == *intp) { + SSCHECK(2); + SSPUSHPTR(intp); + SSPUSHUV(SAVEt_I32_SMALL | shifted); + } else + save_pushi32ptr(*intp, intp, SAVEt_I32); } /* Cannot use save_sptr() to store a char* since the SV** cast will @@ -434,10 +454,7 @@ Perl_save_pptr(pTHX_ char **pptr) PERL_ARGS_ASSERT_SAVE_PPTR; - SSCHECK(3); - SSPUSHPTR(*pptr); - SSPUSHPTR(pptr); - SSPUSHINT(SAVEt_PPTR); + save_pushptrptr(*pptr, pptr, SAVEt_PPTR); } void @@ -447,10 +464,7 @@ Perl_save_vptr(pTHX_ void *ptr) PERL_ARGS_ASSERT_SAVE_VPTR; - SSCHECK(3); - SSPUSHPTR(*(char**)ptr); - SSPUSHPTR(ptr); - SSPUSHINT(SAVEt_VPTR); + save_pushptrptr(*(char**)ptr, ptr, SAVEt_VPTR); } void @@ -460,10 +474,7 @@ Perl_save_sptr(pTHX_ SV **sptr) PERL_ARGS_ASSERT_SAVE_SPTR; - SSCHECK(3); - SSPUSHPTR(*sptr); - SSPUSHPTR(sptr); - SSPUSHINT(SAVEt_SPTR); + save_pushptrptr(*sptr, sptr, SAVEt_SPTR); } void @@ -475,7 +486,7 @@ Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off) SSPUSHPTR(SvREFCNT_inc_simple_NN(PL_curpad[off])); SSPUSHPTR(PL_comppad); SSPUSHLONG((long)off); - SSPUSHINT(SAVEt_PADSV_AND_MORTALIZE); + SSPUSHUV(SAVEt_PADSV_AND_MORTALIZE); } void @@ -485,10 +496,7 @@ Perl_save_hptr(pTHX_ HV **hptr) PERL_ARGS_ASSERT_SAVE_HPTR; - SSCHECK(3); - SSPUSHPTR(*hptr); - SSPUSHPTR(hptr); - SSPUSHINT(SAVEt_HPTR); + save_pushptrptr(*hptr, hptr, SAVEt_HPTR); } void @@ -498,77 +506,71 @@ Perl_save_aptr(pTHX_ AV **aptr) PERL_ARGS_ASSERT_SAVE_APTR; - SSCHECK(3); - SSPUSHPTR(*aptr); - SSPUSHPTR(aptr); - SSPUSHINT(SAVEt_APTR); + save_pushptrptr(*aptr, aptr, SAVEt_APTR); } void -Perl_save_freesv(pTHX_ SV *sv) +Perl_save_pushptr(pTHX_ void *const ptr, const int type) { dVAR; SSCHECK(2); - SSPUSHPTR(sv); - SSPUSHINT(SAVEt_FREESV); + SSPUSHPTR(ptr); + SSPUSHUV(type); } void -Perl_save_mortalizesv(pTHX_ SV *sv) +Perl_save_clearsv(pTHX_ SV **svp) { dVAR; + const UV offset = svp - PL_curpad; + const UV offset_shifted = offset << SAVE_TIGHT_SHIFT; - PERL_ARGS_ASSERT_SAVE_MORTALIZESV; + PERL_ARGS_ASSERT_SAVE_CLEARSV; - SSCHECK(2); - SSPUSHPTR(sv); - SSPUSHINT(SAVEt_MORTALIZESV); -} + ASSERT_CURPAD_ACTIVE("save_clearsv"); + if ((offset_shifted >> SAVE_TIGHT_SHIFT) != offset) + Perl_croak(aTHX_ "panic: pad offset %"UVuf" out of range (%p-%p)", + offset, svp, PL_curpad); -void -Perl_save_freeop(pTHX_ OP *o) -{ - dVAR; - SSCHECK(2); - SSPUSHPTR(o); - SSPUSHINT(SAVEt_FREEOP); + SSCHECK(1); + SSPUSHUV(offset_shifted | SAVEt_CLEARSV); + SvPADSTALE_off(*svp); /* mark lexical as active */ } void -Perl_save_freepv(pTHX_ char *pv) +Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) { dVAR; - SSCHECK(2); - SSPUSHPTR(pv); - SSPUSHINT(SAVEt_FREEPV); + + PERL_ARGS_ASSERT_SAVE_DELETE; + + save_pushptri32ptr(key, klen, SvREFCNT_inc_simple(hv), SAVEt_DELETE); } void -Perl_save_clearsv(pTHX_ SV **svp) +Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) { - dVAR; + STRLEN len; + I32 klen; + const char *key; - PERL_ARGS_ASSERT_SAVE_CLEARSV; + PERL_ARGS_ASSERT_SAVE_HDELETE; - ASSERT_CURPAD_ACTIVE("save_clearsv"); - SSCHECK(2); - SSPUSHLONG((long)(svp-PL_curpad)); - SSPUSHINT(SAVEt_CLEARSV); - SvPADSTALE_off(*svp); /* mark lexical as active */ + key = SvPV_const(keysv, len); + klen = SvUTF8(keysv) ? -(I32)len : (I32)len; + SvREFCNT_inc_simple_void_NN(hv); + save_pushptri32ptr(savepvn(key, len), klen, hv, SAVEt_DELETE); } void -Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) +Perl_save_adelete(pTHX_ AV *av, I32 key) { dVAR; - PERL_ARGS_ASSERT_SAVE_DELETE; + PERL_ARGS_ASSERT_SAVE_ADELETE; - SSCHECK(4); - SSPUSHINT(klen); - SSPUSHPTR(key); - SSPUSHPTR(SvREFCNT_inc_simple(hv)); - SSPUSHINT(SAVEt_DELETE); + SvREFCNT_inc_void(av); + save_pushi32ptr(key, av, SAVEt_ADELETE); } void @@ -581,7 +583,7 @@ Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) SSCHECK(3); SSPUSHDPTR(f); SSPUSHPTR(p); - SSPUSHINT(SAVEt_DESTRUCTOR); + SSPUSHUV(SAVEt_DESTRUCTOR); } void @@ -591,33 +593,61 @@ Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p) SSCHECK(3); SSPUSHDXPTR(f); SSPUSHPTR(p); - SSPUSHINT(SAVEt_DESTRUCTOR_X); + SSPUSHUV(SAVEt_DESTRUCTOR_X); +} + +void +Perl_save_hints(pTHX) +{ + dVAR; + if (PL_compiling.cop_hints_hash) { + HINTS_REFCNT_LOCK; + PL_compiling.cop_hints_hash->refcounted_he_refcnt++; + HINTS_REFCNT_UNLOCK; + } + if (PL_hints & HINT_LOCALIZE_HH) { + save_pushptri32ptr(GvHV(PL_hintgv), PL_hints, + PL_compiling.cop_hints_hash, SAVEt_HINTS); + GvHV(PL_hintgv) = hv_copy_hints_hv(GvHV(PL_hintgv)); + } else { + save_pushi32ptr(PL_hints, PL_compiling.cop_hints_hash, SAVEt_HINTS); + } +} + +static void +S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, + const int type) +{ + SSCHECK(4); + SSPUSHPTR(ptr1); + SSPUSHINT(i); + SSPUSHPTR(ptr2); + SSPUSHUV(type); } void -Perl_save_aelem(pTHX_ AV *av, I32 idx, SV **sptr) +Perl_save_aelem_flags(pTHX_ AV *av, I32 idx, SV **sptr, const U32 flags) { dVAR; SV *sv; - PERL_ARGS_ASSERT_SAVE_AELEM; + PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS; SvGETMAGIC(*sptr); - SSCHECK(4); - SSPUSHPTR(SvREFCNT_inc_simple(av)); - SSPUSHINT(idx); - SSPUSHPTR(SvREFCNT_inc(*sptr)); - SSPUSHINT(SAVEt_AELEM); + save_pushptri32ptr(SvREFCNT_inc_simple(av), idx, SvREFCNT_inc(*sptr), + SAVEt_AELEM); /* if it gets reified later, the restore will have the wrong refcnt */ if (!AvREAL(av) && AvREIFY(av)) SvREFCNT_inc_void(*sptr); - save_scalar_at(sptr, SAVEf_SETMAGIC); /* XXX - FIXME - see #60360 */ + save_scalar_at(sptr, flags); /* XXX - FIXME - see #60360 */ + if (flags & SAVEf_KEEPOLDELEM) + return; sv = *sptr; /* If we're localizing a tied array element, this new sv * won't actually be stored in the array - so it won't get * reaped when the localize ends. Ensure it gets reaped by * mortifying it instead. DAPM */ - if (SvTIED_mg(sv, PERL_MAGIC_tiedelem)) + if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied)) sv_2mortal(sv); } @@ -634,14 +664,16 @@ Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) SSPUSHPTR(SvREFCNT_inc_simple(hv)); SSPUSHPTR(newSVsv(key)); SSPUSHPTR(SvREFCNT_inc(*sptr)); - SSPUSHINT(SAVEt_HELEM); + SSPUSHUV(SAVEt_HELEM); save_scalar_at(sptr, flags); + if (flags & SAVEf_KEEPOLDELEM) + return; sv = *sptr; /* If we're localizing a tied hash element, this new sv * won't actually be stored in the hash - so it won't get * reaped when the localize ends. Ensure it gets reaped by * mortifying it instead. DAPM */ - if (SvTIED_mg(sv, PERL_MAGIC_tiedelem)) + if (SvTIED_mg((const SV *)hv, PERL_MAGIC_tied)) sv_2mortal(sv); } @@ -653,35 +685,27 @@ Perl_save_svref(pTHX_ SV **sptr) PERL_ARGS_ASSERT_SAVE_SVREF; SvGETMAGIC(*sptr); - SSCHECK(3); - SSPUSHPTR(sptr); - SSPUSHPTR(SvREFCNT_inc(*sptr)); - SSPUSHINT(SAVEt_SVREF); + save_pushptrptr(sptr, SvREFCNT_inc(*sptr), SAVEt_SVREF); return save_scalar_at(sptr, SAVEf_SETMAGIC); /* XXX - FIXME - see #60360 */ } -void -Perl_save_op(pTHX) -{ - dVAR; - SSCHECK(2); - SSPUSHPTR(PL_op); - SSPUSHINT(SAVEt_OP); -} - I32 Perl_save_alloc(pTHX_ I32 size, I32 pad) { dVAR; register const I32 start = pad + ((char*)&PL_savestack[PL_savestack_ix] - (char*)PL_savestack); - register const I32 elems = 1 + ((size + pad - 1) / sizeof(*PL_savestack)); + const UV elems = 1 + ((size + pad - 1) / sizeof(*PL_savestack)); + const UV elems_shifted = elems << SAVE_TIGHT_SHIFT; + + if ((elems_shifted >> SAVE_TIGHT_SHIFT) != elems) + Perl_croak(aTHX_ "panic: save_alloc elems %"UVuf" out of range (%ld-%ld)", + elems, size, pad); - SSGROW(elems + 2); + SSGROW(elems + 1); PL_savestack_ix += elems; - SSPUSHINT(elems); - SSPUSHINT(SAVEt_ALLOC); + SSPUSHUV(SAVEt_ALLOC | elems_shifted); return start; } @@ -697,13 +721,19 @@ Perl_leave_scope(pTHX_ I32 base) void* ptr; register char* str; I32 i; + /* Localise the effects of the TAINT_NOT inside the loop. */ + const bool was = PL_tainted; if (base < -1) Perl_croak(aTHX_ "panic: corrupt saved stack index"); + DEBUG_l(Perl_deb(aTHX_ "savestack: releasing items %ld -> %ld\n", + (long)PL_savestack_ix, (long)base)); while (PL_savestack_ix > base) { + UV uv = SSPOPUV; + const U8 type = (U8)uv & SAVE_MASK; TAINT_NOT; - switch (SSPOPINT) { + switch (type) { case SAVEt_ITEM: /* normal string */ value = MUTABLE_SV(SSPOPPTR); sv = MUTABLE_SV(SSPOPPTR); @@ -748,9 +778,15 @@ Perl_leave_scope(pTHX_ I32 base) *(char**)ptr = str; } break; + case SAVEt_GVSV: /* scalar slot in GV */ + value = MUTABLE_SV(SSPOPPTR); + gv = MUTABLE_GV(SSPOPPTR); + ptr = &GvSV(gv); + goto restore_svp; case SAVEt_GENERIC_SVREF: /* generic sv */ value = MUTABLE_SV(SSPOPPTR); ptr = SSPOPPTR; + restore_svp: sv = *(SV**)ptr; *(SV**)ptr = value; SvREFCNT_dec(sv); @@ -759,9 +795,7 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_AV: /* array reference */ av = MUTABLE_AV(SSPOPPTR); gv = MUTABLE_GV(SSPOPPTR); - if (GvAV(gv)) { - SvREFCNT_dec(GvAV(gv)); - } + SvREFCNT_dec(GvAV(gv)); GvAV(gv) = av; if (SvMAGICAL(av)) { PL_localizing = 2; @@ -772,9 +806,7 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_HV: /* hash reference */ hv = MUTABLE_HV(SSPOPPTR); gv = MUTABLE_GV(SSPOPPTR); - if (GvHV(gv)) { - SvREFCNT_dec(GvHV(gv)); - } + SvREFCNT_dec(GvHV(gv)); GvHV(gv) = hv; if (SvMAGICAL(hv)) { PL_localizing = 2; @@ -782,13 +814,21 @@ Perl_leave_scope(pTHX_ I32 base) PL_localizing = 0; } break; + case SAVEt_INT_SMALL: + ptr = SSPOPPTR; + *(int*)ptr = (int)(uv >> SAVE_TIGHT_SHIFT); + break; case SAVEt_INT: /* int reference */ ptr = SSPOPPTR; *(int*)ptr = (int)SSPOPINT; break; case SAVEt_BOOL: /* bool reference */ ptr = SSPOPPTR; - *(bool*)ptr = (bool)SSPOPBOOL; + *(bool*)ptr = cBOOL(uv >> 8); + break; + case SAVEt_I32_SMALL: + ptr = SSPOPPTR; + *(I32*)ptr = (I32)(uv >> SAVE_TIGHT_SHIFT); break; case SAVEt_I32: /* I32 reference */ ptr = SSPOPPTR; @@ -820,10 +860,11 @@ Perl_leave_scope(pTHX_ I32 base) *(AV**)ptr = MUTABLE_AV(SSPOPPTR); break; case SAVEt_GP: /* scalar reference */ - ptr = SSPOPPTR; gv = MUTABLE_GV(SSPOPPTR); gp_free(gv); - GvGP(gv) = (GP*)ptr; + GvGP(gv) = (GP*)SSPOPPTR; + if (SSPOPINT) + SvFAKE_on(gv); /* putting a method back into circulation ("local")*/ if (GvCVu(gv) && (hv=GvSTASH(gv)) && HvNAME_get(hv)) mro_method_changed_in(hv); @@ -847,7 +888,7 @@ Perl_leave_scope(pTHX_ I32 base) Safefree(ptr); break; case SAVEt_CLEARSV: - ptr = (void*)&PL_curpad[SSPOPLONG]; + ptr = (void*)&PL_curpad[uv >> SAVE_TIGHT_SHIFT]; sv = *(SV**)ptr; DEBUG_Xv(PerlIO_printf(Perl_debug_log, @@ -905,19 +946,27 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_DELETE: ptr = SSPOPPTR; hv = MUTABLE_HV(ptr); + i = SSPOPINT; ptr = SSPOPPTR; - (void)hv_delete(hv, (char*)ptr, (I32)SSPOPINT, G_DISCARD); + (void)hv_delete(hv, (char*)ptr, i, G_DISCARD); SvREFCNT_dec(hv); Safefree(ptr); break; + case SAVEt_ADELETE: + ptr = SSPOPPTR; + av = MUTABLE_AV(ptr); + i = SSPOPINT; + (void)av_delete(av, i, G_DISCARD); + SvREFCNT_dec(av); + break; case SAVEt_DESTRUCTOR_X: ptr = SSPOPPTR; (*SSPOPDXPTR)(aTHX_ ptr); break; case SAVEt_REGCONTEXT: + /* regexp must have croaked */ case SAVEt_ALLOC: - i = SSPOPINT; - PL_savestack_ix -= i; /* regexp must have croaked */ + PL_savestack_ix -= uv >> SAVE_TIGHT_SHIFT; break; case SAVEt_STACK_POS: /* Position on Perl stack */ i = SSPOPINT; @@ -950,19 +999,18 @@ Perl_leave_scope(pTHX_ I32 base) sv = MUTABLE_SV(SSPOPPTR); hv = MUTABLE_HV(SSPOPPTR); ptr = hv_fetch_ent(hv, sv, 1, 0); + SvREFCNT_dec(sv); if (ptr) { const SV * const oval = HeVAL((HE*)ptr); if (oval && oval != &PL_sv_undef) { ptr = &HeVAL((HE*)ptr); if (SvTIED_mg((const SV *)hv, PERL_MAGIC_tied)) SvREFCNT_inc_void(*(SV**)ptr); - SvREFCNT_dec(sv); av = MUTABLE_AV(hv); /* what to refcnt_dec */ goto restore_sv; } } SvREFCNT_dec(hv); - SvREFCNT_dec(sv); SvREFCNT_dec(value); break; case SAVEt_OP: @@ -973,9 +1021,9 @@ Perl_leave_scope(pTHX_ I32 base) SvREFCNT_dec(MUTABLE_SV(GvHV(PL_hintgv))); GvHV(PL_hintgv) = NULL; } - *(I32*)&PL_hints = (I32)SSPOPINT; Perl_refcounted_he_free(aTHX_ PL_compiling.cop_hints_hash); PL_compiling.cop_hints_hash = (struct refcounted_he *) SSPOPPTR; + *(I32*)&PL_hints = (I32)SSPOPINT; if (PL_hints & HINT_LOCALIZE_HH) { SvREFCNT_dec(MUTABLE_SV(GvHV(PL_hintgv))); GvHV(PL_hintgv) = MUTABLE_HV(SSPOPPTR); @@ -1066,11 +1114,11 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_I16: /* I16 reference */ ptr = SSPOPPTR; - *(I16*)ptr = (I16)SSPOPINT; + *(I16*)ptr = (I16)(uv >> 8); break; case SAVEt_I8: /* I8 reference */ ptr = SSPOPPTR; - *(I8*)ptr = (I8)SSPOPINT; + *(I8*)ptr = (I8)(uv >> 8); break; case SAVEt_DESTRUCTOR: ptr = SSPOPPTR; @@ -1114,6 +1162,10 @@ Perl_leave_scope(pTHX_ I32 base) Perl_croak(aTHX_ "panic: leave_scope inconsistency"); } } + + PL_tainted = was; + + PERL_ASYNC_CHECK(); } void @@ -1186,8 +1238,6 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) (long)cx->blk_loop.resetsp); PerlIO_printf(Perl_debug_log, "BLK_LOOP.MY_OP = 0x%"UVxf"\n", PTR2UV(cx->blk_loop.my_op)); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.NEXT_OP = 0x%"UVxf"\n", - PTR2UV(CX_LOOP_NEXTOP_GET(cx))); /* XXX: not accurate for LAZYSV/IV */ PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERARY = 0x%"UVxf"\n", PTR2UV(cx->blk_loop.state_u.ary.ary));