X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=cop.h;h=effdbf34ae7f179fb4c9c16ec0c212ad76d6f32f;hb=04838ceaee8e1344b7b5599b60f8b5fc6a1f385f;hp=b1273ac2ff695cd639a8323f4f60e9d352e024f0;hpb=e22ae1e278fa878ce0da6700e97da49f0dacf636;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/cop.h b/cop.h
index b1273ac..effdbf3 100644
--- a/cop.h
+++ b/cop.h
@@ -143,14 +143,14 @@ struct cop {
     HV *	cop_stash;	/* package line was compiled in */
     GV *	cop_filegv;	/* file the following line # is from */
 #endif
+    U32		cop_hints;	/* hints bits from pragmata */
     U32		cop_seq;	/* parse sequence number */
     line_t      cop_line;       /* line # of this command */
     /* Beware. mg.c and warnings.pl assume the type of this is STRLEN *:  */
     STRLEN *	cop_warnings;	/* lexical warnings bitmask */
-    SV *	cop_io;		/* lexical IO defaults */
     /* compile time state of %^H.  See the comment in op.c for how this is
        used to recreate a hash to return from caller.  */
-    struct refcounted_he * cop_hints;
+    struct refcounted_he * cop_hints_hash;
 };
 
 #ifdef USE_ITHREADS
@@ -235,26 +235,25 @@ struct cop {
    using $[ is highly discouraged, no sane Perl code will be using it.  */
 #define CopARYBASE_get(c)	\
 	((CopHINTS_get(c) & HINT_ARYBASE)				\
-	 ? SvIV(Perl_refcounted_he_fetch(aTHX_ (c)->cop_hints, 0, "$[", 2, 0, \
-					 0))				\
+	 ? SvIV(Perl_refcounted_he_fetch(aTHX_ (c)->cop_hints_hash, 0,	\
+					 "$[", 2, 0, 0))		\
 	 : 0)
 #define CopARYBASE_set(c, b) STMT_START { \
-	if (b || ((c)->op_private & HINT_ARYBASE)) {			\
-	    (c)->op_private |= HINT_ARYBASE;				\
+	if (b || ((c)->cop_hints & HINT_ARYBASE)) {			\
+	    (c)->cop_hints |= HINT_ARYBASE;				\
 	    if ((c) == &PL_compiling)					\
 		PL_hints |= HINT_LOCALIZE_HH | HINT_ARYBASE;		\
-	    (c)->cop_hints						\
-	       = Perl_refcounted_he_new(aTHX_ (c)->cop_hints,		\
+	    (c)->cop_hints_hash						\
+	       = Perl_refcounted_he_new(aTHX_ (c)->cop_hints_hash,	\
 					sv_2mortal(newSVpvs("$[")),	\
 					sv_2mortal(newSViv(b)));	\
 	}								\
     } STMT_END
 
 /* FIXME NATIVE_HINTS if this is changed from op_private (see perl.h)  */
-#define CopHINTS_get(c)		((c)->op_private + 0)
+#define CopHINTS_get(c)		((c)->cop_hints + 0)
 #define CopHINTS_set(c, h)	STMT_START {				\
-				    (c)->op_private			\
-					 = (U8)((h) & HINT_PRIVATE_MASK); \
+				    (c)->cop_hints = (h);		\
 				} STMT_END
 
 /*
@@ -331,7 +330,7 @@ struct block_sub {
 	    POP_SAVEARRAY();						\
 	    /* abandon @_ if it got reified */				\
 	    if (AvREAL(cx->blk_sub.argarray)) {				\
-		SSize_t fill = AvFILLp(cx->blk_sub.argarray);		\
+		const SSize_t fill = AvFILLp(cx->blk_sub.argarray);	\
 		SvREFCNT_dec(cx->blk_sub.argarray);			\
 		cx->blk_sub.argarray = newAV();				\
 		av_extend(cx->blk_sub.argarray, fill);			\
@@ -359,8 +358,8 @@ struct block_sub {
 
 /* eval context */
 struct block_eval {
-    I32		old_in_eval;
-    I32		old_op_type;
+    U8		old_in_eval;
+    U16		old_op_type;
     SV *	old_namesv;
     OP *	old_eval_root;
     SV *	cur_text;
@@ -394,21 +393,39 @@ struct block_eval {
 struct block_loop {
     char *	label;
     I32		resetsp;
-    OP *	redo_op;
-    OP *	next_op;
-    OP *	last_op;
+    LOOP *	my_op;	/* My op, that contains redo, next and last ops.  */
+    /* (except for non_ithreads we need to modify next_op in pp_ctl.c, hence
+	why next_op is conditionally defined below.)  */
 #ifdef USE_ITHREADS
     void *	iterdata;
     PAD		*oldcomppad;
 #else
+    OP *	next_op;
     SV **	itervar;
 #endif
     SV *	itersave;
+    /* (from inspection of source code) for a .. range of strings this is the
+       current string.  */
     SV *	iterlval;
+    /* (from inspection of source code) for a foreach loop this is the array
+       being iterated over. For a .. range of numbers it's the current value.
+       A check is often made on the SvTYPE of iterary to determine whether
+       we are iterating over an array or a range. (numbers or strings)  */
     AV *	iterary;
     IV		iterix;
+    /* (from inspection of source code) for a .. range of numbers this is the
+       maximum value.  */
     IV		itermax;
 };
+/* It might be possible to squeeze this structure further. As best I can tell
+   itermax and iterlval are never used at the same time, so it might be possible
+   to make them into a union. However, I'm not confident that there are enough
+   flag bits/NULLable pointers in this structure alone to encode which is
+   active. There is, however, U8 of space free in struct block, which could be
+   used. Right now it may not be worth squeezing this structure further, as it's
+   the largest part of struct block, and currently struct block is 64 bytes on
+   an ILP32 system, which will give good cache alignment.
+*/
 
 #ifdef USE_ITHREADS
 #  define CxITERVAR(c)							\
@@ -433,12 +450,19 @@ struct block_loop {
 	    cx->blk_loop.itersave = NULL;
 #endif
 
+#ifdef USE_ITHREADS
+#  define PUSHLOOP_OP_NEXT		/* No need to do anything.  */
+#  define CX_LOOP_NEXTOP_GET(cx)	((cx)->blk_loop.my_op->op_nextop + 0)
+#else
+#  define PUSHLOOP_OP_NEXT		cx->blk_loop.next_op = cLOOP->op_nextop
+#  define CX_LOOP_NEXTOP_GET(cx)	((cx)->blk_loop.next_op + 0)
+#endif
+
 #define PUSHLOOP(cx, dat, s)						\
 	cx->blk_loop.label = PL_curcop->cop_label;			\
 	cx->blk_loop.resetsp = s - PL_stack_base;			\
-	cx->blk_loop.redo_op = cLOOP->op_redoop;			\
-	cx->blk_loop.next_op = cLOOP->op_nextop;			\
-	cx->blk_loop.last_op = cLOOP->op_lastop;			\
+	cx->blk_loop.my_op = cLOOP;					\
+	PUSHLOOP_OP_NEXT;						\
 	cx->blk_loop.iterlval = NULL;					\
 	cx->blk_loop.iterary = NULL;					\
 	cx->blk_loop.iterix = -1;					\
@@ -471,12 +495,13 @@ struct block_givwhen {
 
 /* context common to subroutines, evals and loops */
 struct block {
+    U16		blku_type;	/* what kind of context this is */
+    U8		blku_gimme;	/* is this block running in list context? */
     I32		blku_oldsp;	/* stack pointer to copy stuff down to */
     COP *	blku_oldcop;	/* old curcop pointer */
     I32		blku_oldmarksp;	/* mark stack index */
     I32		blku_oldscopesp;	/* scope stack index */
     PMOP *	blku_oldpm;	/* values of pattern match vars */
-    U8		blku_gimme;	/* is this block running in list context? */
 
     union {
 	struct block_sub	blku_sub;
@@ -530,12 +555,13 @@ struct block {
 
 /* substitution context */
 struct subst {
+    U16		sbu_type;	/* what kind of context this is */
+    bool	sbu_once;
+    bool	sbu_rxtainted;
     I32		sbu_iters;
     I32		sbu_maxiters;
     I32		sbu_rflags;
     I32		sbu_oldsave;
-    bool	sbu_once;
-    bool	sbu_rxtainted;
     char *	sbu_orig;
     SV *	sbu_dstr;
     SV *	sbu_targ;
@@ -577,19 +603,19 @@ struct subst {
 	cx->sb_rx		= rx,					\
 	cx->cx_type		= CXt_SUBST;				\
 	rxres_save(&cx->sb_rxres, rx);					\
-	ReREFCNT_inc(rx)
+	(void)ReREFCNT_inc(rx)
 
 #define POPSUBST(cx) cx = &cxstack[cxstack_ix--];			\
 	rxres_free(&cx->sb_rxres);					\
 	ReREFCNT_dec(cx->sb_rx)
 
 struct context {
-    U32		cx_type;	/* what kind of context this is */
     union {
 	struct block	cx_blk;
 	struct subst	cx_subst;
     } cx_u;
 };
+#define cx_type cx_u.cx_subst.sbu_type
 
 #define CXTYPEMASK	0xff
 #define CXt_NULL	0