pp_iter(): jump directly to op after OP_AND

AN OP_ITER's op_next field always points to an OP_AND node. Rather than
pushing &PL_sv_yes or &PL_sv_no and then passing control to the OP_AND,
make pp_iter() return the OP_AND's op_next or op_other directly, depending
on whether this is the last iteration or not.

For an empty body, this cuts about 20% off the time of an iteration.

It's possible that some weird optree-munging XS module may break this
assumption. For now I've just added asserts that the next op is OP_AND
with an op_ppaddr of Perl_pp_and; if that assertion fails, it may be
necessary to convert pp_iter()s' asserts into conditional statements.

In the longer term it might be worthwhile converting OP_ITER from a
BASEOP into a LOGOP and eliminate the OP_AND from the optree altogether.

Alternatively, perhaps pp_iter could just tail call Perl_op_leavesub
directly after the last iteration?

Author: iabyn

pod/perlcdelta.pod

@@ -163,6 +163,14 @@ the "Attempt to access disallowed key %s in the restricted hash
 %CLASS::" errors. Stash lookup now got a B<GV_CLASS> flag and C<hv_fetch*_ifexists>
 macros, which does the EXISTS and FETCH hash actions in the stash on one.
 
+=item *
+
+Optimized the loop op ITER to jump directly to the subsequent AND op.
+For an empty body, this cuts about 20% off the time of an iteration.
+Backported from perl-5.27.3. This is a simplier implementation of
+the cperl F<feature/gh138-iter-and> branch from L<[cperl
+#138]|https://github.com/perl11/cperl/issues/138>.
+
 =back
 
 =head1 Modules and Pragmata

pp_hot.c

@@ -3177,7 +3177,6 @@ PP(pp_iter)
     PERL_CONTEXT *cx;
     SV *oldsv;
     SV **itersvp;
-    SV *retsv;
 
     SV *sv;
     AV *av;
@@ -3349,18 +3348,28 @@ PP(pp_iter)
 	DIE(aTHX_ "panic: pp_iter, type=%u", CxTYPE(cx));
     }
 
-    retsv = SV_YES;
-    if (0) {
-      retno:
-        retsv = SV_NO;
-    }
+    /* Bypass pushing &PL_sv_yes and calling pp_and(); instead
+     * jump straight to the AND op's op_other */
+    assert(OpNEXT(PL_op)->op_type == OP_AND);
+    assert(OpNEXT(PL_op)->op_ppaddr == Perl_pp_and);
+    return OpOTHER(OpNEXT(PL_op));
+
+  retno:
+    /* Bypass pushing &PL_sv_no and calling pp_and(); instead
+     * jump straight to the AND op's op_next */
+    assert(OpNEXT(PL_op)->op_type == OP_AND);
+    assert(OpNEXT(PL_op)->op_ppaddr == Perl_pp_and);
     /* pp_enteriter should have pre-extended the stack */
     assert(PL_stack_sp < PL_stack_max);
-    *++PL_stack_sp =retsv;
-
-    return PL_op->op_next;
+    /* we only need this for the rare case where the OP_AND isn't
+     * in void context, e.g. $x = do { for (..) {...} };
+     * but its cheaper to just push it rather than testing first
+     */
+    *++PL_stack_sp = SV_NO;
+    return OpNEXT(OpNEXT(PL_op));
 }
 
+
 /*
 A description of how taint works in pattern matching and substitution.