/* free all savestack items back to the watermark of the specified context */
-#define CX_LEAVE_SCOPE(cx) \
- LEAVE_SCOPE(cx->cx_u.cx_blk.blku_old_savestack_ix)
+#define CX_LEAVE_SCOPE(cx) LEAVE_SCOPE(cx->cx_old_savestack_ix)
+
+#ifdef DEBUGGING
+/* on debugging builds, poison cx afterwards so we know no code
+ * uses it - because after doing cxstack_ix--, any ties, exceptions etc
+ * may overwrite the current stack frame */
+# define CX_POP(cx) \
+ assert(&cxstack[cxstack_ix] == cx); \
+ cxstack_ix--; \
+ cx = NULL;
+#else
+# define CX_POP(cx) cxstack_ix--;
+#endif
+
/* base for the next two macros. Don't use directly.
* The context frame holds a reference to the CV so that it can't be
cx->blk_sub.prevcomppad = PL_comppad; \
cx->cx_type |= (hasargs) ? CXp_HASARGS : 0; \
cx->blk_sub.retop = NULL; \
- SvREFCNT_inc_simple_void_NN(cv); \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix;
+ SvREFCNT_inc_simple_void_NN(cv);
#define PUSHSUB_GET_LVALUE_MASK(func) \
/* If the context is indeterminate, then only the lvalue */ \
cx->blk_format.dfoutgv = PL_defoutgv; \
cx->blk_format.prevcomppad = PL_comppad; \
cx->blk_u16 = 0; \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
SvREFCNT_inc_simple_void_NN(cv); \
CvDEPTH(cv)++; \
SvREFCNT_inc_void(cx->blk_format.dfoutgv)
AvFILLp(ary) = -1; \
} STMT_END
+
+/* subsets of POPSUB */
+
+#define POPSUB_COMMON(cx) \
+ PL_comppad = cx->blk_sub.prevcomppad; \
+ PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
+ CvDEPTH((const CV*)cx->blk_sub.cv) = cx->blk_sub.olddepth; \
+ SvREFCNT_dec_NN(cx->blk_sub.cv);
+
+/* handle the @_ part of leaving a sub */
+
+#define POPSUB_ARGS(cx) \
+ STMT_START { \
+ AV *av; \
+ assert(AvARRAY(MUTABLE_AV( \
+ PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[ \
+ CvDEPTH(cx->blk_sub.cv)])) == PL_curpad); \
+ POP_SAVEARRAY(); \
+ /* abandon @_ if it got reified */ \
+ av = MUTABLE_AV(PAD_SVl(0)); \
+ if (UNLIKELY(AvREAL(av))) \
+ clear_defarray(av, 0); \
+ else { \
+ CLEAR_ARGARRAY(av); \
+ } \
+ } STMT_END
+
#define POPSUB(cx) \
STMT_START { \
- CX_LEAVE_SCOPE(cx); \
if (!(cx->blk_u16 & CxPOPSUB_DONE)) { \
cx->blk_u16 |= CxPOPSUB_DONE; \
RETURN_PROBE(CvNAMED(cx->blk_sub.cv) \
CopSTASHPV((COP*)CvSTART((const CV*)cx->blk_sub.cv))); \
\
if (CxHASARGS(cx)) { \
- AV *av; \
- assert(AvARRAY(MUTABLE_AV( \
- PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[ \
- CvDEPTH(cx->blk_sub.cv)])) == PL_curpad); \
- POP_SAVEARRAY(); \
- /* abandon @_ if it got reified */ \
- av = MUTABLE_AV(PAD_SVl(0)); \
- if (UNLIKELY(AvREAL(av))) \
- clear_defarray(av, 0); \
- else { \
- CLEAR_ARGARRAY(av); \
- } \
+ POPSUB_ARGS(cx); \
} \
} \
- PL_comppad = cx->blk_sub.prevcomppad; \
- PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
- CvDEPTH((const CV*)cx->blk_sub.cv) = cx->blk_sub.olddepth; \
- SvREFCNT_dec_NN(cx->blk_sub.cv); \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
+ POPSUB_COMMON(cx); \
} STMT_END
#define POPFORMAT(cx) \
STMT_START { \
- CX_LEAVE_SCOPE(cx); \
if (!(cx->blk_u16 & CxPOPSUB_DONE)) { \
CV * const cv = cx->blk_format.cv; \
GV * const dfuot = cx->blk_format.dfoutgv; \
SvREFCNT_dec_NN(cx->blk_format.cv); \
SvREFCNT_dec_NN(dfuot); \
} \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
} STMT_END
/* eval context */
assert(!(PL_in_eval & ~0x7F)); \
assert(!(PL_op->op_type & ~0x1FF)); \
cx->blk_u16 = (PL_in_eval & 0x7F) | ((U16)PL_op->op_type << 7); \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix; \
cx->blk_eval.old_namesv = (n ? newSVpv(n,0) : NULL); \
cx->blk_eval.old_eval_root = PL_eval_root; \
cx->blk_eval.cur_text = PL_parser ? PL_parser->linestr : NULL; \
#define POPEVAL(cx) \
STMT_START { \
- CX_LEAVE_SCOPE(cx); \
PL_in_eval = CxOLD_IN_EVAL(cx); \
- optype = CxOLD_OP_TYPE(cx); \
PL_eval_root = cx->blk_eval.old_eval_root; \
if (cx->blk_eval.cur_text && SvSCREAM(cx->blk_eval.cur_text)) \
SvREFCNT_dec_NN(cx->blk_eval.cur_text); \
if (cx->blk_eval.old_namesv) \
sv_2mortal(cx->blk_eval.old_namesv); \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
} STMT_END
/* loop context */
cx->blk_loop.my_op = cLOOP; \
cx->blk_loop.state_u.ary.ary = NULL; \
cx->blk_loop.state_u.ary.ix = 0; \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
cx->blk_loop.itervar_u.svp = NULL; \
cx->blk_loop.itersave = NULL;
cx->blk_loop.state_u.ary.ary = NULL; \
cx->blk_loop.state_u.ary.ix = 0; \
cx->blk_loop.itervar_u.svp = (SV**)(ivar); \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
cx->blk_loop.itersave = isave; \
PUSHLOOP_FOR_setpad(cx);
#define POPLOOP(cx) \
- CX_LEAVE_SCOPE(cx); \
if (CxTYPE(cx) == CXt_LOOP_LAZYSV) { \
SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.cur); \
SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.end); \
cursv = *svp; \
*svp = cx->blk_loop.itersave; \
SvREFCNT_dec(cursv); \
- } \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor;
+ }
/* given/when context */
struct block_givwhen {
};
#define PUSHWHEN(cx) \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
cx->blk_givwhen.leave_op = cLOGOP->op_other;
#define PUSHGIVEN(cx, orig_var) \
cx->blk_givwhen.defsv_save = orig_var;
#define POPWHEN(cx) \
- CX_LEAVE_SCOPE(cx); \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor;
+ NOOP;
#define POPGIVEN(cx) \
- CX_LEAVE_SCOPE(cx); \
SvREFCNT_dec(GvSV(PL_defgv)); \
- GvSV(PL_defgv) = cx->blk_givwhen.defsv_save; \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor;
+ GvSV(PL_defgv) = cx->blk_givwhen.defsv_save;
/* basic block, i.e. pp_enter/leave */
#define PUSHBASICBLK(cx) \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix;
+ cx->cx_old_savestack_ix = PL_savestack_ix;
#define POPBASICBLK(cx) \
- CX_LEAVE_SCOPE(cx); \
- PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor;
+ NOOP;
/* context common to subroutines, evals and loops */
I32 blku_oldscopesp; /* scope stack index */
PMOP * blku_oldpm; /* values of pattern match vars */
SSize_t blku_old_tmpsfloor; /* saved PL_tmps_floor */
- I32 blku_old_savestack_ix; /* saved PL_savestack_ix */
union {
struct block_sub blku_sub;
(long)PL_scopestack_ix, \
(long)(cxstack[cxstack_ix].blk_oldscopesp), \
(long)PL_savestack_ix, \
- (long)(cxstack[cxstack_ix].cx_u.cx_blk.blku_old_savestack_ix),\
+ (long)(cxstack[cxstack_ix].cx_old_savestack_ix), \
__FILE__, __LINE__));
/* Enter a block. */
cx->blk_oldscopesp = PL_scopestack_ix, \
cx->blk_oldpm = PL_curpm, \
cx->blk_gimme = (U8)gimme; \
+ cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
+ PL_tmps_floor = PL_tmps_ix; \
DEBUG_CX("PUSH");
/* Exit a block (RETURN and LAST). */
/* LEAVE_SCOPE() should have made this true. /(?{})/ cheats
* and leaves a CX entry lying around for repeated use, so
* skip for multicall */ \
- assert((CxTYPE(cx) == CXt_SUB && CxMULTICALL(cx)) || \
- PL_savestack_ix == cx->cx_u.cx_blk.blku_old_savestack_ix); \
+ assert( (CxTYPE(cx) == CXt_SUB && CxMULTICALL(cx)) \
+ || PL_savestack_ix == cx->cx_old_savestack_ix); \
+ PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
PL_curpm = cx->blk_oldpm;
/* Continue a block elsewhere (NEXT and REDO). */
U8 sbu_type; /* what kind of context this is */
U8 sbu_rflags;
U16 sbu_rxtainted; /* matches struct block */
- I32 sbu_oldsave;
SSize_t sbu_iters;
SSize_t sbu_maxiters;
char * sbu_orig;
#define sb_iters cx_u.cx_subst.sbu_iters
#define sb_maxiters cx_u.cx_subst.sbu_maxiters
#define sb_rflags cx_u.cx_subst.sbu_rflags
-#define sb_oldsave cx_u.cx_subst.sbu_oldsave
#define sb_rxtainted cx_u.cx_subst.sbu_rxtainted
#define sb_orig cx_u.cx_subst.sbu_orig
#define sb_dstr cx_u.cx_subst.sbu_dstr
#ifdef PERL_CORE
# define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix], \
+ cx->cx_old_savestack_ix = oldsave, \
cx->sb_iters = iters, \
cx->sb_maxiters = maxiters, \
cx->sb_rflags = r_flags, \
- cx->sb_oldsave = oldsave, \
cx->sb_rxtainted = rxtainted, \
cx->sb_orig = orig, \
cx->sb_dstr = dstr, \
(void)ReREFCNT_inc(rx); \
SvREFCNT_inc_void_NN(targ)
-# define POPSUBST(cx) cx = &cxstack[cxstack_ix--]; \
+# define POPSUBST(cx) \
rxres_free(&cx->sb_rxres); \
ReREFCNT_dec(cx->sb_rx); \
SvREFCNT_dec_NN(cx->sb_targ)
#define CxONCE(cx) ((cx)->cx_type & CXp_ONCE)
struct context {
+ I32 cx_old_savestack_ix; /* saved PL_savestack_ix */
union {
struct block cx_blk;
struct subst cx_subst;
PUSHSTACKi(PERLSI_MULTICALL); \
PUSHBLOCK(cx, (CXt_SUB|CXp_MULTICALL|flags), PL_stack_sp); \
PUSHSUB(cx); \
- cx->cx_u.cx_blk.blku_old_savestack_ix = PL_savestack_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
SAVEVPTR(PL_op); \
if (!(flags & CXp_SUB_RE_FAKE)) \
CvDEPTH(cv)++; \
} \
PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv)); \
multicall_cv = cv; \
+ PERL_UNUSED_VAR(multicall_cv); /* for API */ \
multicall_cop = CvSTART(cv); \
} STMT_END
#define POP_MULTICALL \
STMT_START { \
cx = &cxstack[cxstack_ix]; \
- CvDEPTH(multicall_cv) = cx->blk_sub.olddepth; \
- /* includes partial unrolled POPSUB(): */ \
CX_LEAVE_SCOPE(cx); \
- PL_comppad = cx->blk_sub.prevcomppad; \
- PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
- SvREFCNT_dec_NN(multicall_cv); \
- /* these two set for backcompat by callers */ \
+ POPSUB_COMMON(cx); \
newsp = PL_stack_base + cx->blk_oldsp; \
gimme = cx->blk_gimme; \
- POPBLOCK(cx); \
- cxstack_ix--; \
+ PERL_UNUSED_VAR(newsp); /* for API */ \
+ PERL_UNUSED_VAR(gimme); /* for API */ \
+ POPBLOCK(cx); \
+ CX_POP(cx); \
POPSTACK; \
CATCH_SET(multicall_oldcatch); \
SPAGAIN; \
PADLIST * const padlist = CvPADLIST(cv); \
cx = &cxstack[cxstack_ix]; \
assert(CxMULTICALL(cx)); \
- CvDEPTH(multicall_cv) = cx->blk_sub.olddepth; \
- SvREFCNT_dec_NN(multicall_cv); \
+ POPSUB_COMMON(cx); \
cx->cx_type = (CXt_SUB|CXp_MULTICALL|flags); \
- { \
- /* save a few things that we don't want PUSHSUB to zap */ \
- PAD * const prevcomppad = cx->blk_sub.prevcomppad; \
- SSize_t old_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
- SSize_t floor = PL_tmps_floor; \
- PUSHSUB(cx); \
- /* undo the stuff that PUSHSUB zapped */ \
- cx->blk_sub.prevcomppad = prevcomppad ; \
- cx->cx_u.cx_blk.blku_old_tmpsfloor = old_floor; \
- PL_tmps_floor = floor; \
- } \
+ PUSHSUB(cx); \
if (!(flags & CXp_SUB_RE_FAKE)) \
CvDEPTH(cv)++; \
if (CvDEPTH(cv) >= 2) { \