X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/e4090ce886275aecfe2478d139a6e0a7781d824e..2c165900ba8cdc82020bd482e32a3445138c9bc0:/scope.c diff --git a/scope.c b/scope.c index 8a32017..af10b71 100644 --- a/scope.c +++ b/scope.c @@ -1,6 +1,7 @@ /* scope.c * - * Copyright (c) 1991-2001, Larry Wall + * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + * 2000, 2001, 2002, 2003, 2004, 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. @@ -12,6 +13,13 @@ * levels..." */ +/* This file contains functions to manipulate several of Perl's stacks; + * in particular it contains code to push various types of things onto + * the savestack, then to pop them off and perform the correct restorative + * action for each one. This corresponds to the cleanup Perl does at + * each scope exit. + */ + #include "EXTERN.h" #define PERL_IN_SCOPE_C #include "perl.h" @@ -50,20 +58,12 @@ Perl_vdefault_protect(pTHX_ volatile JMPENV *pcur_env, int *excpt, SV** Perl_stack_grow(pTHX_ SV **sp, SV **p, int n) { -#if defined(DEBUGGING) && !defined(USE_THREADS) - static int growing = 0; - if (growing++) - abort(); -#endif PL_stack_sp = sp; #ifndef STRESS_REALLOC av_extend(PL_curstack, (p - PL_stack_base) + (n) + 128); #else av_extend(PL_curstack, (p - PL_stack_base) + (n) + 1); #endif -#if defined(DEBUGGING) && !defined(USE_THREADS) - growing--; -#endif return PL_stack_sp; } @@ -89,37 +89,25 @@ Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) si->si_cxix = -1; si->si_type = PERLSI_UNDEF; New(56, si->si_cxstack, cxitems, PERL_CONTEXT); + /* Without any kind of initialising PUSHSUBST() + * in pp_subst() will read uninitialised heap. */ + Poison(si->si_cxstack, cxitems, PERL_CONTEXT); return si; } I32 Perl_cxinc(pTHX) { + IV old_max = cxstack_max; cxstack_max = GROW(cxstack_max); Renew(cxstack, cxstack_max + 1, PERL_CONTEXT); /* XXX should fix CXINC macro */ + /* Without any kind of initialising deep enough recursion + * will end up reading uninitialised PERL_CONTEXTs. */ + Poison(cxstack + old_max + 1, cxstack_max - old_max, PERL_CONTEXT); return cxstack_ix + 1; } void -Perl_push_return(pTHX_ OP *retop) -{ - if (PL_retstack_ix == PL_retstack_max) { - PL_retstack_max = GROW(PL_retstack_max); - Renew(PL_retstack, PL_retstack_max, OP*); - } - PL_retstack[PL_retstack_ix++] = retop; -} - -OP * -Perl_pop_return(pTHX) -{ - if (PL_retstack_ix > 0) - return PL_retstack[--PL_retstack_ix]; - else - return Nullop; -} - -void Perl_push_scope(pTHX) { if (PL_scopestack_ix == PL_scopestack_max) { @@ -151,7 +139,14 @@ Perl_markstack_grow(pTHX) void Perl_savestack_grow(pTHX) { - PL_savestack_max = GROW(PL_savestack_max) + 4; + PL_savestack_max = GROW(PL_savestack_max) + 4; + Renew(PL_savestack, PL_savestack_max, ANY); +} + +void +Perl_savestack_grow_cnt(pTHX_ I32 need) +{ + PL_savestack_max = PL_savestack_ix + need; Renew(PL_savestack, PL_savestack_max, ANY); } @@ -177,7 +172,7 @@ Perl_free_tmps(pTHX) while (PL_tmps_ix > myfloor) { /* clean up after last statement */ SV* sv = PL_tmps_stack[PL_tmps_ix]; PL_tmps_stack[PL_tmps_ix--] = Nullsv; - if (sv) { + if (sv && sv != &PL_sv_undef) { SvTEMP_off(sv); SvREFCNT_dec(sv); /* note, can modify tmps_ix!!! */ } @@ -192,21 +187,35 @@ S_save_scalar_at(pTHX_ SV **sptr) sv = *sptr = NEWSV(0,0); if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) { + MAGIC *mg; sv_upgrade(sv, SvTYPE(osv)); if (SvGMAGICAL(osv)) { - MAGIC* mg; bool oldtainted = PL_tainted; - mg_get(osv); - if (PL_tainting && PL_tainted && (mg = mg_find(osv, 't'))) { + mg_get(osv); /* note, can croak! */ + if (PL_tainting && PL_tainted && + (mg = mg_find(osv, PERL_MAGIC_taint))) { SAVESPTR(mg->mg_obj); mg->mg_obj = osv; } SvFLAGS(osv) |= (SvFLAGS(osv) & - (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; + (SVp_NOK|SVp_POK)) >> PRIVSHIFT; PL_tainted = oldtainted; } SvMAGIC(sv) = SvMAGIC(osv); + /* if it's a special scalar or if it has no 'set' magic, + * propagate the SvREADONLY flag. --rgs 20030922 */ + for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) { + if (mg->mg_type == '\0' + || !(mg->mg_virtual && mg->mg_virtual->svt_set)) + { + SvFLAGS(sv) |= SvREADONLY(osv); + break; + } + } SvFLAGS(sv) |= SvMAGICAL(osv); + /* XXX SvMAGIC() is *shared* between osv and sv. This can + * lead to coredumps when both SVs are destroyed without one + * of their SvMAGIC() slots being NULLed. */ PL_localizing = 1; SvSETMAGIC(sv); PL_localizing = 0; @@ -258,10 +267,34 @@ Perl_save_generic_pvref(pTHX_ char **str) SSPUSHINT(SAVEt_GENERIC_PVREF); } +/* Like save_generic_pvref(), but uses PerlMemShared_free() rather than Safefree(). + * Can be used to restore a shared global char* to its prior + * contents, freeing new value. */ +void +Perl_save_shared_pvref(pTHX_ char **str) +{ + SSCHECK(3); + SSPUSHPTR(str); + SSPUSHPTR(*str); + SSPUSHINT(SAVEt_SHARED_PVREF); +} + +/* set the SvFLAGS specified by mask to the values in val */ + +void +Perl_save_set_svflags(pTHX_ SV* sv, U32 mask, U32 val) +{ + SSCHECK(4); + SSPUSHPTR(sv); + SSPUSHINT(mask); + SSPUSHINT(val); + SSPUSHINT(SAVEt_SET_SVFLAGS); +} + void Perl_save_gp(pTHX_ GV *gv, I32 empty) { - SSCHECK(6); + SSGROW(6); SSPUSHIV((IV)SvLEN(gv)); SvLEN(gv) = 0; /* forget that anything was allocated here */ SSPUSHIV((IV)SvCUR(gv)); @@ -376,6 +409,15 @@ Perl_save_long(pTHX_ long int *longp) } void +Perl_save_bool(pTHX_ bool *boolp) +{ + SSCHECK(3); + SSPUSHBOOL(*boolp); + SSPUSHPTR(boolp); + SSPUSHINT(SAVEt_BOOL); +} + +void Perl_save_I32(pTHX_ I32 *intp) { SSCHECK(3); @@ -445,8 +487,9 @@ void Perl_save_padsv(pTHX_ PADOFFSET off) { SSCHECK(4); + ASSERT_CURPAD_ACTIVE("save_padsv"); SSPUSHPTR(PL_curpad[off]); - SSPUSHPTR(PL_curpad); + SSPUSHPTR(PL_comppad); SSPUSHLONG((long)off); SSPUSHINT(SAVEt_PADSV); } @@ -454,16 +497,8 @@ Perl_save_padsv(pTHX_ PADOFFSET off) SV ** Perl_save_threadsv(pTHX_ PADOFFSET i) { -#ifdef USE_THREADS - SV **svp = &THREADSV(i); /* XXX Change to save by offset */ - DEBUG_S(PerlIO_printf(Perl_debug_log, "save_threadsv %"UVuf": %p %p:%s\n", - (UV)i, svp, *svp, SvPEEK(*svp))); - save_svref(svp); - return svp; -#else Perl_croak(aTHX_ "panic: save_threadsv called in non-threaded perl"); return 0; -#endif /* USE_THREADS */ } void @@ -501,6 +536,14 @@ Perl_save_freesv(pTHX_ SV *sv) } void +Perl_save_mortalizesv(pTHX_ SV *sv) +{ + SSCHECK(2); + SSPUSHPTR(sv); + SSPUSHINT(SAVEt_MORTALIZESV); +} + +void Perl_save_freeop(pTHX_ OP *o) { SSCHECK(2); @@ -519,9 +562,11 @@ Perl_save_freepv(pTHX_ char *pv) void Perl_save_clearsv(pTHX_ SV **svp) { + ASSERT_CURPAD_ACTIVE("save_clearsv"); SSCHECK(2); SSPUSHLONG((long)(svp-PL_curpad)); SSPUSHINT(SAVEt_CLEARSV); + SvPADSTALE_off(*svp); /* mark lexical as active */ } void @@ -571,23 +616,42 @@ Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p) void Perl_save_aelem(pTHX_ AV *av, I32 idx, SV **sptr) { + SV *sv; SSCHECK(4); SSPUSHPTR(SvREFCNT_inc(av)); SSPUSHINT(idx); SSPUSHPTR(SvREFCNT_inc(*sptr)); SSPUSHINT(SAVEt_AELEM); + /* if it gets reified later, the restore will have the wrong refcnt */ + if (!AvREAL(av) && AvREIFY(av)) + SvREFCNT_inc(*sptr); save_scalar_at(sptr); + 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)) + sv_2mortal(sv); } void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) { + SV *sv; SSCHECK(4); SSPUSHPTR(SvREFCNT_inc(hv)); SSPUSHPTR(SvREFCNT_inc(key)); SSPUSHPTR(SvREFCNT_inc(*sptr)); SSPUSHINT(SAVEt_HELEM); save_scalar_at(sptr); + 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)) + sv_2mortal(sv); } void @@ -602,12 +666,12 @@ I32 Perl_save_alloc(pTHX_ I32 size, I32 pad) { register I32 start = pad + ((char*)&PL_savestack[PL_savestack_ix] - - (char*)PL_savestack); + - (char*)PL_savestack); register I32 elems = 1 + ((size + pad - 1) / sizeof(*PL_savestack)); /* SSCHECK may not be good enough */ while (PL_savestack_ix + elems + 2 > PL_savestack_max) - savestack_grow(); + savestack_grow(); PL_savestack_ix += elems; SSPUSHINT(elems); @@ -639,13 +703,13 @@ Perl_leave_scope(pTHX_ I32 base) SvSETMAGIC(sv); PL_localizing = 0; break; - case SAVEt_SV: /* scalar reference */ + case SAVEt_SV: /* scalar reference */ value = (SV*)SSPOPPTR; gv = (GV*)SSPOPPTR; ptr = &GvSV(gv); - SvREFCNT_dec(gv); + av = (AV*)gv; /* what to refcnt_dec */ goto restore_sv; - case SAVEt_GENERIC_PVREF: /* generic pv */ + case SAVEt_GENERIC_PVREF: /* generic pv */ str = (char*)SSPOPPTR; ptr = SSPOPPTR; if (*(char**)ptr != str) { @@ -653,7 +717,19 @@ Perl_leave_scope(pTHX_ I32 base) *(char**)ptr = str; } break; - case SAVEt_GENERIC_SVREF: /* generic sv */ + case SAVEt_SHARED_PVREF: /* shared pv */ + str = (char*)SSPOPPTR; + ptr = SSPOPPTR; + if (*(char**)ptr != str) { +#ifdef NETWARE + PerlMem_free(*(char**)ptr); +#else + PerlMemShared_free(*(char**)ptr); +#endif + *(char**)ptr = str; + } + break; + case SAVEt_GENERIC_SVREF: /* generic sv */ value = (SV*)SSPOPPTR; ptr = SSPOPPTR; sv = *(SV**)ptr; @@ -661,14 +737,15 @@ Perl_leave_scope(pTHX_ I32 base) SvREFCNT_dec(sv); SvREFCNT_dec(value); break; - case SAVEt_SVREF: /* scalar reference */ + case SAVEt_SVREF: /* scalar reference */ value = (SV*)SSPOPPTR; ptr = SSPOPPTR; + av = Nullav; /* what to refcnt_dec */ restore_sv: sv = *(SV**)ptr; DEBUG_S(PerlIO_printf(Perl_debug_log, "restore svref: %p %p:%s -> %p:%s\n", - ptr, sv, SvPEEK(sv), value, SvPEEK(value))); + ptr, sv, SvPEEK(sv), value, SvPEEK(value))); if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv) && SvTYPE(sv) != SVt_PVGV) { @@ -678,22 +755,31 @@ Perl_leave_scope(pTHX_ I32 base) SvMAGICAL_off(sv); SvMAGIC(sv) = 0; } + /* XXX This branch is pretty bogus. This code irretrievably + * clears(!) the magic on the SV (either to avoid further + * croaking that might ensue when the SvSETMAGIC() below is + * called, or to avoid two different SVs pointing at the same + * SvMAGIC()). This needs a total rethink. --GSAR */ else if (SvTYPE(value) >= SVt_PVMG && SvMAGIC(value) && SvTYPE(value) != SVt_PVGV) { SvFLAGS(value) |= (SvFLAGS(value) & - (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; + (SVp_NOK|SVp_POK)) >> PRIVSHIFT; SvMAGICAL_off(value); + /* XXX this is a leak when we get here because the + * mg_get() in save_scalar_at() croaked */ SvMAGIC(value) = 0; } - SvREFCNT_dec(sv); *(SV**)ptr = value; + SvREFCNT_dec(sv); PL_localizing = 2; SvSETMAGIC(value); PL_localizing = 0; SvREFCNT_dec(value); - break; - case SAVEt_AV: /* array reference */ + if (av) /* actually an av, hv or gv */ + SvREFCNT_dec(av); + break; + case SAVEt_AV: /* array reference */ av = (AV*)SSPOPPTR; gv = (GV*)SSPOPPTR; if (GvAV(gv)) { @@ -704,14 +790,14 @@ Perl_leave_scope(pTHX_ I32 base) SvMAGIC(goner) = 0; SvREFCNT_dec(goner); } - GvAV(gv) = av; + GvAV(gv) = av; if (SvMAGICAL(av)) { PL_localizing = 2; SvSETMAGIC((SV*)av); PL_localizing = 0; } - break; - case SAVEt_HV: /* hash reference */ + break; + case SAVEt_HV: /* hash reference */ hv = (HV*)SSPOPPTR; gv = (GV*)SSPOPPTR; if (GvHV(gv)) { @@ -722,13 +808,13 @@ Perl_leave_scope(pTHX_ I32 base) SvMAGIC(goner) = 0; SvREFCNT_dec(goner); } - GvHV(gv) = hv; + GvHV(gv) = hv; if (SvMAGICAL(hv)) { PL_localizing = 2; SvSETMAGIC((SV*)hv); PL_localizing = 0; } - break; + break; case SAVEt_INT: /* int reference */ ptr = SSPOPPTR; *(int*)ptr = (int)SSPOPINT; @@ -737,6 +823,10 @@ Perl_leave_scope(pTHX_ I32 base) ptr = SSPOPPTR; *(long*)ptr = (long)SSPOPLONG; break; + case SAVEt_BOOL: /* bool reference */ + ptr = SSPOPPTR; + *(bool*)ptr = (bool)SSPOPBOOL; + break; case SAVEt_I32: /* I32 reference */ ptr = SSPOPPTR; *(I32*)ptr = (I32)SSPOPINT; @@ -777,26 +867,29 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_GP: /* scalar reference */ ptr = SSPOPPTR; gv = (GV*)SSPOPPTR; - if (SvPVX(gv) && SvLEN(gv) > 0) { - Safefree(SvPVX(gv)); - } - SvPVX(gv) = (char *)SSPOPPTR; - SvCUR(gv) = (STRLEN)SSPOPIV; - SvLEN(gv) = (STRLEN)SSPOPIV; - gp_free(gv); - GvGP(gv) = (GP*)ptr; + if (SvPVX(gv) && SvLEN(gv) > 0) { + Safefree(SvPVX(gv)); + } + SvPVX(gv) = (char *)SSPOPPTR; + SvCUR(gv) = (STRLEN)SSPOPIV; + SvLEN(gv) = (STRLEN)SSPOPIV; + gp_free(gv); + GvGP(gv) = (GP*)ptr; if (GvCVu(gv)) PL_sub_generation++; /* putting a method back into circulation */ SvREFCNT_dec(gv); - break; + break; case SAVEt_FREESV: ptr = SSPOPPTR; SvREFCNT_dec((SV*)ptr); break; + case SAVEt_MORTALIZESV: + ptr = SSPOPPTR; + sv_2mortal((SV*)ptr); + break; case SAVEt_FREEOP: ptr = SSPOPPTR; - if (PL_comppad) - PL_curpad = AvARRAY(PL_comppad); + ASSERT_CURPAD_LEGAL("SAVEt_FREEOP"); /* XXX DAPM tmp */ op_free((OP*)ptr); break; case SAVEt_FREEPV: @@ -806,8 +899,24 @@ Perl_leave_scope(pTHX_ I32 base) case SAVEt_CLEARSV: ptr = (void*)&PL_curpad[SSPOPLONG]; sv = *(SV**)ptr; + + DEBUG_Xv(PerlIO_printf(Perl_debug_log, + "Pad 0x%"UVxf"[0x%"UVxf"] clearsv: %ld sv=0x%"UVxf"<%"IVdf"> %s\n", + PTR2UV(PL_comppad), PTR2UV(PL_curpad), + (long)((SV **)ptr-PL_curpad), PTR2UV(sv), (IV)SvREFCNT(sv), + (SvREFCNT(sv) <= 1 && !SvOBJECT(sv)) ? "clear" : "abandon" + )); + /* Can clear pad variable in place? */ if (SvREFCNT(sv) <= 1 && !SvOBJECT(sv)) { + /* + * if a my variable that was made readonly is going out of + * scope, we want to remove the readonlyness so that it can + * go out of scope quietly + */ + if (SvPADMY(sv) && !SvFAKE(sv)) + SvREADONLY_off(sv); + if (SvTHINKFIRST(sv)) sv_force_normal_flags(sv, SV_IMMEDIATE_UNREF); if (SvMAGICAL(sv)) @@ -824,26 +933,23 @@ Perl_leave_scope(pTHX_ I32 base) break; case SVt_PVCV: Perl_croak(aTHX_ "panic: leave_scope pad code"); - case SVt_RV: - case SVt_IV: - case SVt_NV: - (void)SvOK_off(sv); - break; default: - (void)SvOK_off(sv); - (void)SvOOK_off(sv); + SvOK_off(sv); break; } + SvPADSTALE_on(sv); /* mark as no longer live */ } else { /* Someone has a claim on this, so abandon it. */ - U32 padflags = SvFLAGS(sv) & (SVs_PADBUSY|SVs_PADMY|SVs_PADTMP); + U32 padflags = SvFLAGS(sv) & (SVs_PADMY|SVs_PADTMP); switch (SvTYPE(sv)) { /* Console ourselves with a new value */ case SVt_PVAV: *(SV**)ptr = (SV*)newAV(); break; case SVt_PVHV: *(SV**)ptr = (SV*)newHV(); break; default: *(SV**)ptr = NEWSV(0,0); break; } SvREFCNT_dec(sv); /* Cast current value to the winds. */ - SvFLAGS(*(SV**)ptr) |= padflags; /* preserve pad nature */ + /* preserve pad nature, but also mark as not live + * for any closure capturing */ + SvFLAGS(*(SV**)ptr) |= padflags | SVs_PADSTALE; } break; case SAVEt_DELETE: @@ -860,7 +966,7 @@ Perl_leave_scope(pTHX_ I32 base) break; case SAVEt_DESTRUCTOR_X: ptr = SSPOPPTR; - (*SSPOPDXPTR)(aTHXo_ ptr); + (*SSPOPDXPTR)(aTHX_ ptr); break; case SAVEt_REGCONTEXT: case SAVEt_ALLOC: @@ -875,13 +981,14 @@ Perl_leave_scope(pTHX_ I32 base) value = (SV*)SSPOPPTR; i = SSPOPINT; av = (AV*)SSPOPPTR; + if (!AvREAL(av) && AvREIFY(av)) /* undo reify guard */ + SvREFCNT_dec(value); ptr = av_fetch(av,i,1); if (ptr) { sv = *(SV**)ptr; if (sv && sv != &PL_sv_undef) { - if (SvTIED_mg((SV*)av, 'P')) + if (SvTIED_mg((SV*)av, PERL_MAGIC_tied)) (void)SvREFCNT_inc(sv); - SvREFCNT_dec(av); goto restore_sv; } } @@ -897,10 +1004,10 @@ Perl_leave_scope(pTHX_ I32 base) SV *oval = HeVAL((HE*)ptr); if (oval && oval != &PL_sv_undef) { ptr = &HeVAL((HE*)ptr); - if (SvTIED_mg((SV*)hv, 'P')) + if (SvTIED_mg((SV*)hv, PERL_MAGIC_tied)) (void)SvREFCNT_inc(*(SV**)ptr); - SvREFCNT_dec(hv); SvREFCNT_dec(sv); + av = (AV*)hv; /* what to refcnt_dec */ goto restore_sv; } } @@ -912,14 +1019,19 @@ Perl_leave_scope(pTHX_ I32 base) PL_op = (OP*)SSPOPPTR; break; case SAVEt_HINTS: - if (GvHV(PL_hintgv)) { + if ((PL_hints & HINT_LOCALIZE_HH) && GvHV(PL_hintgv)) { SvREFCNT_dec((SV*)GvHV(PL_hintgv)); GvHV(PL_hintgv) = NULL; } *(I32*)&PL_hints = (I32)SSPOPINT; + if (PL_hints & HINT_LOCALIZE_HH) { + SvREFCNT_dec((SV*)GvHV(PL_hintgv)); + GvHV(PL_hintgv) = (HV*)SSPOPPTR; + } + break; case SAVEt_COMPPAD: - PL_comppad = (AV*)SSPOPPTR; + PL_comppad = (PAD*)SSPOPPTR; if (PL_comppad) PL_curpad = AvARRAY(PL_comppad); else @@ -930,7 +1042,25 @@ Perl_leave_scope(pTHX_ I32 base) PADOFFSET off = (PADOFFSET)SSPOPLONG; ptr = SSPOPPTR; if (ptr) - ((SV**)ptr)[off] = (SV*)SSPOPPTR; + AvARRAY((PAD*)ptr)[off] = (SV*)SSPOPPTR; + } + break; + case SAVEt_SAVESWITCHSTACK: + { + dSP; + AV* t = (AV*)SSPOPPTR; + AV* f = (AV*)SSPOPPTR; + SWITCHSTACK(t,f); + PL_curstackinfo->si_stack = f; + } + break; + case SAVEt_SET_SVFLAGS: + { + U32 val = (U32)SSPOPINT; + U32 mask = (U32)SSPOPINT; + sv = (SV*)SSPOPPTR; + SvFLAGS(sv) &= ~mask; + SvFLAGS(sv) |= val; } break; default: @@ -950,7 +1080,6 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) PTR2UV(cx->blk_oldcop)); PerlIO_printf(Perl_debug_log, "BLK_OLDMARKSP = %ld\n", (long)cx->blk_oldmarksp); PerlIO_printf(Perl_debug_log, "BLK_OLDSCOPESP = %ld\n", (long)cx->blk_oldscopesp); - PerlIO_printf(Perl_debug_log, "BLK_OLDRETSP = %ld\n", (long)cx->blk_oldretsp); PerlIO_printf(Perl_debug_log, "BLK_OLDPM = 0x%"UVxf"\n", PTR2UV(cx->blk_oldpm)); PerlIO_printf(Perl_debug_log, "BLK_GIMME = %s\n", cx->blk_gimme ? "LIST" : "SCALAR"); @@ -968,6 +1097,8 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) PTR2UV(cx->blk_sub.dfoutgv)); PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n", (int)cx->blk_sub.hasargs); + PerlIO_printf(Perl_debug_log, "BLK_SUB.RETOP = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.retop)); break; case CXt_SUB: PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n", @@ -978,6 +1109,8 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) (int)cx->blk_sub.hasargs); PerlIO_printf(Perl_debug_log, "BLK_SUB.LVAL = %d\n", (int)cx->blk_sub.lval); + PerlIO_printf(Perl_debug_log, "BLK_SUB.RETOP = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.retop)); break; case CXt_EVAL: PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_IN_EVAL = %ld\n", @@ -990,6 +1123,8 @@ Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) SvPVX(cx->blk_eval.old_namesv)); PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%"UVxf"\n", PTR2UV(cx->blk_eval.old_eval_root)); + PerlIO_printf(Perl_debug_log, "BLK_EVAL.RETOP = 0x%"UVxf"\n", + PTR2UV(cx->blk_eval.retop)); break; case CXt_LOOP: