[ViewVC] Diff of: cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.406 by root, Sat Jun 11 13:49:00 2011 UTC vs.
Revision 1.454 by root, Tue Jul 7 00:38:03 2015 UTC

 /* this works around a bug in mingw32 providing a non-working setjmp */
 #define USE_NO_MINGW_SETJMP_TWO_ARGS
-#define NDEBUG 1
+#define NDEBUG 1 /* perl usually disables NDEBUG later */
 #include "libcoro/coro.c"
 #define PERL_NO_GET_CONTEXT
 #define PERL_EXT
 #include "perl.h"
 #include "XSUB.h"
 #include "perliol.h"
 #include "schmorp.h"
+#define ECB_NO_THREADS 1
+#define ECB_NO_LIBM 1
 #include "ecb.h"
 #include <stddef.h>
 #include <stdio.h>
 #include <errno.h>
 #include <assert.h>
+#ifndef SvREFCNT_dec_NN
+  #define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
+#endif
+#ifndef SvREFCNT_inc_NN
+  #define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
+#endif
 #ifndef SVs_PADSTALE
 # define SVs_PADSTALE 0
+#endif
+#ifdef PadARRAY
+# define NEWPADAPI 1
+# define newPADLIST(var)	(Newz (0, var, 1, PADLIST), Newx (PadlistARRAY (var), 2, PAD *))
+#else
+typedef AV PADNAMELIST;
+# if !PERL_VERSION_ATLEAST(5,8,0)
+typedef AV PADLIST;
+typedef AV PAD;
+# endif
+# define PadlistARRAY(pl)	((PAD **)AvARRAY (pl))
+# define PadlistMAX(pl)		AvFILLp (pl)
+# define PadlistNAMES(pl)	(*PadlistARRAY (pl))
+# define PadARRAY		AvARRAY
+# define PadMAX			AvFILLp
+# define newPADLIST(var)	((var) = newAV (), av_extend (var, 1))
+#endif
+#ifndef PadnamelistREFCNT
+# define PadnamelistREFCNT(pnl) SvREFCNT (pnl)
+#endif
+#ifndef PadnamelistREFCNT_dec
+# define PadnamelistREFCNT_dec(pnl) SvREFCNT_dec (pnl)
+#endif
+/* 5.19.something has replaced SVt_BIND by SVt_INVLIST */
+/* we just alias it to SVt_IV, as that is sufficient for swap_sv for now */
+#if PERL_VERSION_ATLEAST(5,19,0)
+# define SVt_BIND SVt_IV
 #endif
 #if defined(_WIN32)
 # undef HAS_GETTIMEOFDAY
 # undef setjmp
 # define setjmp _setjmp /* deep magic */
 #else
 # include <inttypes.h> /* most portable stdint.h */
 #endif
-#ifdef HAVE_MMAP
-# include <unistd.h>
-# include <sys/mman.h>
-# ifndef MAP_ANONYMOUS
-#  ifdef MAP_ANON
-#   define MAP_ANONYMOUS MAP_ANON
-#  else
-#   undef HAVE_MMAP
-#  endif
-# endif
-# include <limits.h>
-# ifndef PAGESIZE
-#  define PAGESIZE pagesize
-#  define BOOT_PAGESIZE pagesize = sysconf (_SC_PAGESIZE)
-static long pagesize;
-# else
-#  define BOOT_PAGESIZE (void)0
-# endif
-#else
-# define PAGESIZE 0
-# define BOOT_PAGESIZE (void)0
-#endif
-#if CORO_USE_VALGRIND
-# include <valgrind/valgrind.h>
-#endif
 /* the maximum number of idle cctx that will be pooled */
 static int cctx_max_idle = 4;
-#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64
+#if defined(DEBUGGING) && PERL_VERSION_ATLEAST(5,12,0)
-# undef CORO_STACKGUARD
+# define HAS_SCOPESTACK_NAME 1
-#endif
-#ifndef CORO_STACKGUARD
-# define CORO_STACKGUARD 0
 #endif
 /* prefer perl internal functions over our own? */
 #ifndef CORO_PREFER_PERL_FUNCTIONS
 # define CORO_PREFER_PERL_FUNCTIONS 0
 # if CORO_PTHREAD
 static void *coro_thx;
 # endif
 #endif
-/* used in state.h */
-#define VAR(name,type) VARx(name, PL_ ## name, type)
 #ifdef __linux
 # include <time.h> /* for timespec */
 # include <syscall.h> /* for SYS_* */
 # ifdef SYS_clock_gettime
 #  define coro_clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
 typedef struct coro_cctx
 {
   struct coro_cctx *next;
   /* the stack */
-  void *sptr;
+  struct coro_stack stack;
-  size_t ssize;
   /* cpu state */
   void *idle_sp;   /* sp of top-level transfer/schedule/cede call */
+#ifndef NDEBUG
-  JMPENV *idle_te; /* same as idle_sp, but for top_env, TODO: remove once stable */
+  JMPENV *idle_te; /* same as idle_sp, but for top_env */
+#endif
   JMPENV *top_env;
   coro_context cctx;
   U32 gen;
 #if CORO_USE_VALGRIND
 };
 /* the structure where most of the perl state is stored, overlaid on the cxstack */
 typedef struct
 {
-#define VARx(name,expr,type) type name;
+  #define VARx(name,expr,type) type name;
-# include "state.h"
+  #include "state.h"
-#undef VARx
 } perl_slots;
-// how many context stack entries do we need for perl_slots
+/* how many context stack entries do we need for perl_slots */
 #define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
 /* this is a structure representing a perl-level coroutine */
 struct coro
 {
   SV *saved_deffh;
   SV *invoke_cb;
   AV *invoke_av;
   /* on_enter/on_leave */
-  AV *on_enter;
+  AV *on_enter; AV *on_enter_xs;
-  AV *on_leave;
+  AV *on_leave; AV *on_leave_xs;
   /* swap_sv */
   AV *swap_sv;
   /* times */
 #define coro_nready coroapi.nready
 /** JIT *********************************************************************/
 #if CORO_JIT
+  /* APPLE doesn't have mmap though */
+  #define CORO_JIT_UNIXY (__linux || __FreeBSD__ || __OpenBSD__ || __NetBSD__ || __solaris || __APPLE__)
   #ifndef CORO_JIT_TYPE
-    #if __x86_64 && (__linux || __FreeBSD__ || __OpenBSD__ || __NetBSD__ || __solaris)
+    #if ECB_AMD64 && CORO_JIT_UNIXY
       #define CORO_JIT_TYPE "amd64-unix"
-      typedef void (*load_save_perl_slots_type)(perl_slots *);
+    #elif __i386 && CORO_JIT_UNIXY
-    #else
+      #define CORO_JIT_TYPE "x86-unix"
-      #undef CORO_JIT
     #endif
   #endif
 #endif
+#if !defined(CORO_JIT_TYPE) || _POSIX_MEMORY_PROTECTION <= 0
+  #undef CORO_JIT
+#endif
 #if CORO_JIT
+  typedef void (*load_save_perl_slots_type)(perl_slots *);
-static load_save_perl_slots_type load_perl_slots, save_perl_slots;
+  static load_save_perl_slots_type load_perl_slots, save_perl_slots;
 #endif
 /** Coro::Select ************************************************************/
 static OP *(*coro_old_pp_sselect) (pTHX);
 /** time stuff **************************************************************/
 #ifdef HAS_GETTIMEOFDAY
-ECB_INLINE void
+ecb_inline void
 coro_u2time (pTHX_ UV ret[2])
 {
   struct timeval tv;
   gettimeofday (&tv, 0);
   ret [0] = tv.tv_sec;
   ret [1] = tv.tv_usec;
 }
-ECB_INLINE double
+ecb_inline double
-coro_nvtime ()
+coro_nvtime (void)
 {
   struct timeval tv;
   gettimeofday (&tv, 0);
   return tv.tv_sec + tv.tv_usec * 1e-6;
 }
-ECB_INLINE void
+ecb_inline void
 time_init (pTHX)
 {
   nvtime = coro_nvtime;
   u2time = coro_u2time;
 }
 #else
-ECB_INLINE void
+ecb_inline void
 time_init (pTHX)
 {
   SV **svp;
   require_pv ("Time/HiRes.pm");
   svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
   if (!svp)          croak ("Time::HiRes is required, but missing. Caught");
   if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer. Caught");
          get_hv (name, create);
 #endif
   return get_hv (name, create);
 }
-ECB_INLINE void
+ecb_inline void
-coro_times_update ()
+coro_times_update (void)
 {
 #ifdef coro_clock_gettime
   struct timespec ts;
   ts.tv_sec  = ts.tv_nsec = 0;
   time_real [0] = tv [0];
   time_real [1] = tv [1] * 1000;
 #endif
 }
-ECB_INLINE void
+ecb_inline void
 coro_times_add (struct coro *c)
 {
   c->t_real [1] += time_real [1];
   if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }
   c->t_real [0] += time_real [0];
   c->t_cpu  [1] += time_cpu  [1];
   if (c->t_cpu  [1] > 1000000000) { c->t_cpu  [1] -= 1000000000; ++c->t_cpu  [0]; }
   c->t_cpu  [0] += time_cpu  [0];
 }
-ECB_INLINE void
+ecb_inline void
 coro_times_sub (struct coro *c)
 {
   if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }
   c->t_real [1] -= time_real [1];
   c->t_real [0] -= time_real [0];
     : 0)
 #define CORO_MAGIC_cv(cv)    CORO_MAGIC    (((SV *)(cv)), CORO_MAGIC_type_cv)
 #define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)
-ECB_INLINE MAGIC *
+ecb_inline MAGIC *
 SvSTATEhv_p (pTHX_ SV *coro)
 {
   MAGIC *mg;
   if (ecb_expect_true (
     return mg;
   return 0;
 }
-ECB_INLINE struct coro *
+ecb_inline struct coro *
-SvSTATE_ (pTHX_ SV *coro)
+SvSTATE_ (pTHX_ SV *coro_sv)
 {
   MAGIC *mg;
-  if (SvROK (coro))
+  if (SvROK (coro_sv))
-    coro = SvRV (coro);
+    coro_sv = SvRV (coro_sv);
-  mg = SvSTATEhv_p (aTHX_ coro);
+  mg = SvSTATEhv_p (aTHX_ coro_sv);
   if (!mg)
     croak ("Coro::State object required");
   return (struct coro *)mg->mg_ptr;
 }
 #define SvSTATE_current SvSTATE_hv (SvRV (coro_current))
 /*****************************************************************************/
 /* padlist management and caching */
-ECB_INLINE AV *
+ecb_inline PADLIST *
 coro_derive_padlist (pTHX_ CV *cv)
 {
-  AV *padlist = CvPADLIST (cv);
+  PADLIST *padlist = CvPADLIST (cv);
-  AV *newpadlist, *newpad;
+  PADLIST *newpadlist;
+  PADNAMELIST *padnames;
+  PAD *newpad;
+  PADOFFSET off = PadlistMAX (padlist) + 1;
-  newpadlist = newAV ();
+#if NEWPADAPI
+  /* if we had the original CvDEPTH, we might be able to steal the CvDEPTH+1 entry instead */
+  /* 20131102194744.GA6705@schmorp.de, 20131102195825.2013.qmail@lists-nntp.develooper.com */
+  while (!PadlistARRAY (padlist)[off - 1])
+    --off;
+  Perl_pad_push (aTHX_ padlist, off);
+  newpad = PadlistARRAY (padlist)[off];
+  PadlistARRAY (padlist)[off] = 0;
+#else
+#if PERL_VERSION_ATLEAST (5,10,0)
+  Perl_pad_push (aTHX_ padlist, off);
+#else
+  Perl_pad_push (aTHX_ padlist, off, 1);
+#endif
+  newpad = PadlistARRAY (padlist)[off];
+  PadlistMAX (padlist) = off - 1;
+#endif
+  newPADLIST (newpadlist);
+#if !PERL_VERSION_ATLEAST(5,15,3)
+  /* Padlists are AvREAL as of 5.15.3. See perl bug #98092 and perl commit 7d953ba. */
   AvREAL_off (newpadlist);
-#if PERL_VERSION_ATLEAST (5,10,0)
-  Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
-#else
-  Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
 #endif
-  newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
-  --AvFILLp (padlist);
-  av_store (newpadlist, 0, SvREFCNT_inc_NN (AvARRAY (padlist)[0]));
+  /* Already extended to 2 elements by newPADLIST. */
-  av_store (newpadlist, 1, (SV *)newpad);
+  PadlistMAX (newpadlist) = 1;
+  padnames = PadlistNAMES (padlist);
+  ++PadnamelistREFCNT (padnames);
+  PadlistNAMES (newpadlist) = padnames;
+  PadlistARRAY (newpadlist)[1] = newpad;
   return newpadlist;
 }
-ECB_INLINE void
+ecb_inline void
-free_padlist (pTHX_ AV *padlist)
+free_padlist (pTHX_ PADLIST *padlist)
 {
   /* may be during global destruction */
   if (!IN_DESTRUCT)
     {
-      I32 i = AvFILLp (padlist);
+      I32 i = PadlistMAX (padlist);
       while (i > 0) /* special-case index 0 */
         {
           /* we try to be extra-careful here */
-          AV *av = (AV *)AvARRAY (padlist)[i--];
+          PAD *pad = PadlistARRAY (padlist)[i--];
-          I32 j = AvFILLp (av);
+          if (pad)
+            {
+              I32 j = PadMAX (pad);
-          while (j >= 0)
+              while (j >= 0)
-            SvREFCNT_dec (AvARRAY (av)[j--]);
+                SvREFCNT_dec (PadARRAY (pad)[j--]);
-          AvFILLp (av) = -1;
+              PadMAX (pad) = -1;
-          SvREFCNT_dec (av);
+              SvREFCNT_dec (pad);
+            }
         }
-      SvREFCNT_dec (AvARRAY (padlist)[0]);
+      PadnamelistREFCNT_dec (PadlistNAMES (padlist));
+#if NEWPADAPI
+      Safefree (PadlistARRAY (padlist));
+      Safefree (padlist);
+#else
       AvFILLp (padlist) = -1;
+      AvREAL_off (padlist);
       SvREFCNT_dec ((SV*)padlist);
+#endif
     }
 }
 static int
 coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
 {
-  AV *padlist;
+  PADLIST *padlist;
-  AV *av = (AV *)mg->mg_obj;
+  PADLIST **padlists = (PADLIST **)(mg->mg_ptr + sizeof(size_t));
+  size_t len = *(size_t *)mg->mg_ptr;
   /* perl manages to free our internal AV and _then_ call us */
   if (IN_DESTRUCT)
     return 0;
-  /* casting is fun. */
+  while (len--)
-  while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
-    free_padlist (aTHX_ padlist);
+    free_padlist (aTHX_ padlists[len]);
-  SvREFCNT_dec (av); /* sv_magicext increased the refcount */
   return 0;
 }
 static MGVTBL coro_cv_vtbl = {
   0, 0, 0, 0,
   coro_cv_free
 };
 /* the next two functions merely cache the padlists */
-ECB_INLINE void
+ecb_inline void
 get_padlist (pTHX_ CV *cv)
 {
   MAGIC *mg = CORO_MAGIC_cv (cv);
-  AV *av;
+  size_t *lenp;
-  if (ecb_expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
+  if (ecb_expect_true (mg && *(lenp = (size_t *)mg->mg_ptr)))
-    CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
+    CvPADLIST (cv) = ((PADLIST **)(mg->mg_ptr + sizeof(size_t)))[--*lenp];
   else
    {
 #if CORO_PREFER_PERL_FUNCTIONS
      /* this is probably cleaner? but also slower! */
      /* in practise, it seems to be less stable */
      CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);
 #endif
    }
 }
-ECB_INLINE void
+ecb_inline void
 put_padlist (pTHX_ CV *cv)
 {
   MAGIC *mg = CORO_MAGIC_cv (cv);
-  AV *av;
   if (ecb_expect_false (!mg))
+    {
-    mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
+      mg = sv_magicext ((SV *)cv, 0, CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
+      Newz (0, mg->mg_ptr ,sizeof (size_t) + sizeof (PADLIST *), char);
+      mg->mg_len = 1; /* so mg_free frees mg_ptr */
+    }
+  else
+    Renew (mg->mg_ptr,
+           sizeof(size_t) + (*(size_t *)mg->mg_ptr + 1) * sizeof(PADLIST *),
+           char);
-  av = (AV *)mg->mg_obj;
+  ((PADLIST **)(mg->mg_ptr + sizeof (size_t))) [(*(size_t *)mg->mg_ptr)++] = CvPADLIST (cv);
-  if (ecb_expect_false (AvFILLp (av) >= AvMAX (av)))
-    av_extend (av, AvFILLp (av) + 1);
-  AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
 }
 /** load & save, init *******************************************************/
+ecb_inline void
+swap_sv (SV *a, SV *b)
+{
+  const U32 keep = SVs_PADSTALE | SVs_PADTMP | SVs_PADMY; /* keep these flags */
+  SV tmp;
+  /* swap sv_any */
+  SvANY (&tmp) = SvANY (a); SvANY (a) = SvANY (b); SvANY (b) = SvANY (&tmp);
+  /* swap sv_flags */
+  SvFLAGS (&tmp) = SvFLAGS (a);
+  SvFLAGS (a)    = (SvFLAGS (a) & keep) | (SvFLAGS (b   ) & ~keep);
+  SvFLAGS (b)    = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep);
+#if PERL_VERSION_ATLEAST (5,10,0)
+  /* perl 5.10 and later complicates this _quite_ a bit, but it also
+   * is much faster, so no quarrels here. alternatively, we could
+   * sv_upgrade to avoid this.
+   */
+  {
+    /* swap sv_u */
+    tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u;
+    /* if SvANY points to the head, we need to adjust the pointers,
+     * as the pointer for a still points to b, and maybe vice versa.
+     */
+    U32 svany_in_head_set = (1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV);
+    #if NVSIZE <= IVSIZE && PERL_VERSION_ATLEAST(5,22,0)
+      svany_in_head_set |= 1 << SVt_NV;
+    #endif
+    #define svany_in_head(type) (svany_in_head_set & (1 << (type)))
+    if (svany_in_head (SvTYPE (a)))
+      SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a);
+    if (svany_in_head (SvTYPE (b)))
+      SvANY (b) = (void *)((PTRV)SvANY (b) - (PTRV)a + (PTRV)b);
+  }
+#endif
+}
 /* swap sv heads, at least logically */
 static void
 swap_svs (pTHX_ Coro__State c)
 {
   int i;
-  for (i = 0; i <= AvFILLp (c->swap_sv); )
+  for (i = 0; i <= AvFILLp (c->swap_sv); i += 2)
-    {
+    swap_sv (AvARRAY (c->swap_sv)[i], AvARRAY (c->swap_sv)[i + 1]);
-      SV *a = AvARRAY (c->swap_sv)[i++];
-      SV *b = AvARRAY (c->swap_sv)[i++];
-      const U32 keep = SVs_PADSTALE | SVs_PADTMP | SVs_PADMY; /* keep these flags */
-      SV tmp;
-      /* swap sv_any */
-      SvANY (&tmp) = SvANY (a); SvANY (a) = SvANY (b); SvANY (b) = SvANY (&tmp);
-      /* swap sv_flags */
-      SvFLAGS (&tmp) = SvFLAGS (a);
-      SvFLAGS (a)    = (SvFLAGS (a) & keep) | (SvFLAGS (b   ) & ~keep);
-      SvFLAGS (b)    = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep);
-#if PERL_VERSION_ATLEAST (5,10,0)
-      /* perl 5.10 complicates this _quite_ a bit, but it also is
-       * much faster, so no quarrels here. alternatively, we could
-       * sv_upgrade to avoid this.
-       */
-      {
-        /* swap sv_u */
-        tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u;
-        /* if SvANY points to the head, we need to adjust the pointers,
-         * as the pointer for a still points to b, and maybe vice versa.
-         */
-        #define svany_in_head(type) \
-           (((1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV)) & (1 << (type)))
-        if (svany_in_head (SvTYPE (a)))
-          SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a);
-        if (svany_in_head (SvTYPE (b)))
-          SvANY (b) = (void *)((PTRV)SvANY (b) - (PTRV)a + (PTRV)b);
-      }
-#endif
-    }
 }
 #define SWAP_SVS(coro)				\
   if (ecb_expect_false ((coro)->swap_sv))	\
     swap_svs (aTHX_ (coro))
 #if CORO_JIT
   load_perl_slots (slot);
 #else
   #define VARx(name,expr,type) expr = slot->name;
-  # include "state.h"
+  #include "state.h"
-  #undef VARx
 #endif
   {
     dSP;
     /* now do the ugly restore mess */
     while (ecb_expect_true (cv = (CV *)POPs))
       {
         put_padlist (aTHX_ cv); /* mark this padlist as available */
         CvDEPTH (cv) = PTR2IV (POPs);
-        CvPADLIST (cv) = (AV *)POPs;
+        CvPADLIST (cv) = (PADLIST *)POPs;
       }
     PUTBACK;
   }
       for (i = 0; i <= AvFILLp (c->on_enter); ++i)
         on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
     }
+  if (ecb_expect_false (c->on_enter_xs))
+    {
+      int i;
+      for (i = 0; i <= AvFILLp (c->on_enter_xs); i += 2)
+        ((coro_enterleave_hook)AvARRAY (c->on_enter_xs)[i]) (aTHX_ AvARRAY (c->on_enter_xs)[i + 1]);
+    }
   SWAP_SVS (c);
 }
 static void
 save_perl (pTHX_ Coro__State c)
 {
   SWAP_SVS (c);
+  if (ecb_expect_false (c->on_leave_xs))
+    {
+      int i;
+      for (i = AvFILLp (c->on_leave_xs) - 1; i >= 0; i -= 2)
+        ((coro_enterleave_hook)AvARRAY (c->on_leave_xs)[i]) (aTHX_ AvARRAY (c->on_leave_xs)[i + 1]);
+    }
   if (ecb_expect_false (c->on_leave))
     {
       int i;
     PUTBACK;
   }
   /* allocate some space on the context stack for our purposes */
-  if (ecb_expect_false (cxstack_ix + SLOT_COUNT >= cxstack_max))
+  if (ecb_expect_false (cxstack_ix + (int)SLOT_COUNT >= cxstack_max))
     {
       unsigned int i;
       for (i = 0; i < SLOT_COUNT; ++i)
         CXINC;
 #if CORO_JIT
     save_perl_slots (slot);
 #else
     #define VARx(name,expr,type) slot->name = expr;
-    # include "state.h"
+    #include "state.h"
-    #undef VARx
 #endif
   }
 }
 /*
 #endif
     New(54,PL_scopestack,8,I32);
     PL_scopestack_ix = 0;
     PL_scopestack_max = 8;
+#if HAS_SCOPESTACK_NAME
+    New(54,PL_scopestack_name,8,const char*);
+#endif
     New(54,PL_savestack,24,ANY);
     PL_savestack_ix = 0;
     PL_savestack_max = 24;
   }
   Safefree (PL_tmps_stack);
   Safefree (PL_markstack);
   Safefree (PL_scopestack);
+#if HAS_SCOPESTACK_NAME
+  Safefree (PL_scopestack_name);
+#endif
   Safefree (PL_savestack);
 #if !PERL_VERSION_ATLEAST (5,10,0)
   Safefree (PL_retstack);
 #endif
 }
     {
       SV **svp = 0;
       if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
       if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
       if (svp)
         {
-          sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
+          SV *ssv;
+          if (!*svp)
+            ssv = &PL_sv_undef;
+          else if (SvTYPE (*svp) == SVt_PVCV) /* perlio directly stores a CV in warnhook. ugh. */
+            ssv = sv_2mortal (newRV_inc (*svp));
+          else
+            ssv = *svp;
+          sv_setsv (sv, ssv);
           return 0;
         }
     }
   return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
   PL_hints      = 0;
   /* recreate the die/warn hooks */
   PL_diehook  = SvREFCNT_inc (rv_diehook);
   PL_warnhook = SvREFCNT_inc (rv_warnhook);
   GvSV (PL_defgv)    = newSV (0);
   GvAV (PL_defgv)    = coro->args; coro->args = 0;
   GvSV (PL_errgv)    = newSV (0);
   GvSV (irsgv)       = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
-  GvHV (PL_hintgv)   = 0;
+  GvHV (PL_hintgv)   = newHV ();
+#if PERL_VERSION_ATLEAST (5,10,0)
+  hv_magic (GvHV (PL_hintgv), 0, PERL_MAGIC_hints);
+#endif
   PL_rs              = newSVsv (GvSV (irsgv));
   PL_defoutgv        = (GV *)SvREFCNT_inc_NN (stdoutgv);
   {
     dSP;
     /* restore swapped sv's */
     SWAP_SVS (coro);
     coro_destruct_stacks (aTHX);
-    // now save some sv's to be free'd later
+    /* now save some sv's to be free'd later */
     svf    [0] =       GvSV (PL_defgv);
     svf    [1] = (SV *)GvAV (PL_defgv);
     svf    [2] =       GvSV (PL_errgv);
     svf    [3] = (SV *)PL_defoutgv;
     svf    [4] =       PL_rs;
     SvREFCNT_dec (coro->saved_deffh);
     SvREFCNT_dec (coro->rouse_cb);
     SvREFCNT_dec (coro->invoke_cb);
     SvREFCNT_dec (coro->invoke_av);
+    SvREFCNT_dec (coro->on_enter_xs);
+    SvREFCNT_dec (coro->on_leave_xs);
   }
 }
-ECB_INLINE void
+ecb_inline void
 free_coro_mortal (pTHX)
 {
   if (ecb_expect_true (coro_mortal))
     {
       SvREFCNT_dec ((SV *)coro_mortal);
               if (PL_curcop != &PL_compiling)
                 {
                   SV **cb;
-                  if (oldcxix != cxstack_ix && cctx_current->flags & CC_TRACE_SUB)
+                  if (oldcxix != cxstack_ix && cctx_current->flags & CC_TRACE_SUB && cxstack_ix >= 0)
                     {
                       PERL_CONTEXT *cx = &cxstack[cxstack_ix];
                       if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
                         {
   slf_frame.prepare = slf_prepare_set_stacklevel;
   slf_frame.check   = slf_check_set_stacklevel;
 }
 /* the tail of transfer: execute stuff we can only do after a transfer */
-ECB_INLINE void
+ecb_inline void
 transfer_tail (pTHX)
 {
   free_coro_mortal (aTHX);
+}
+/* try to exit the same way perl's main function would do */
+/* we do not bother resetting the environment or other things *7
+/* that are not, uhm, essential */
+/* this obviously also doesn't work when perl is embedded */
+static void ecb_noinline ecb_cold
+perlish_exit (pTHX)
+{
+  int exitstatus = perl_destruct (PL_curinterp);
+  perl_free (PL_curinterp);
+  exit (exitstatus);
 }
 /*
  * this is a _very_ stripped down perl interpreter ;)
  */
      */
     /*
      * If perl-run returns we assume exit() was being called or the coro
      * fell off the end, which seems to be the only valid (non-bug)
-     * reason for perl_run to return. We try to exit by jumping to the
+     * reason for perl_run to return. We try to mimic whatever perl is normally
-     * bootstrap-time "top" top_env, as we cannot restore the "main"
+     * doing in that case. YMMV.
-     * coroutine as Coro has no such concept.
-     * This actually isn't valid with the pthread backend, but OSes requiring
-     * that backend are too broken to do it in a standards-compliant way.
      */
-    PL_top_env = main_top_env;
+    perlish_exit (aTHX);
-    JMPENV_JUMP (2); /* I do not feel well about the hardcoded 2 at all */
   }
 }
 static coro_cctx *
-cctx_new ()
+cctx_new (void)
 {
   coro_cctx *cctx;
   ++cctx_count;
   New (0, cctx, 1, coro_cctx);
   return cctx;
 }
 /* create a new cctx only suitable as source */
 static coro_cctx *
-cctx_new_empty ()
+cctx_new_empty (void)
 {
   coro_cctx *cctx = cctx_new ();
-  cctx->sptr = 0;
+  cctx->stack.sptr = 0;
   coro_create (&cctx->cctx, 0, 0, 0, 0);
   return cctx;
 }
 /* create a new cctx suitable as destination/running a perl interpreter */
 static coro_cctx *
-cctx_new_run ()
+cctx_new_run (void)
 {
   coro_cctx *cctx = cctx_new ();
-  void *stack_start;
-  size_t stack_size;
-#if HAVE_MMAP
+  if (!coro_stack_alloc (&cctx->stack, cctx_stacksize))
-  cctx->ssize = ((cctx_stacksize * sizeof (long) + PAGESIZE - 1) / PAGESIZE + CORO_STACKGUARD) * PAGESIZE;
-  /* mmap supposedly does allocate-on-write for us */
-  cctx->sptr = mmap (0, cctx->ssize, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
-  if (cctx->sptr != (void *)-1)
-    {
-      #if CORO_STACKGUARD
-        mprotect (cctx->sptr, CORO_STACKGUARD * PAGESIZE, PROT_NONE);
-      #endif
-      stack_start = (char *)cctx->sptr + CORO_STACKGUARD * PAGESIZE;
-      stack_size  = cctx->ssize        - CORO_STACKGUARD * PAGESIZE;
-      cctx->flags |= CC_MAPPED;
-    }
+    {
-  else
-#endif
-    {
-      cctx->ssize = cctx_stacksize * (long)sizeof (long);
-      New (0, cctx->sptr, cctx_stacksize, long);
-      if (!cctx->sptr)
-        {
-          perror ("FATAL: unable to allocate stack for coroutine, exiting.");
+      perror ("FATAL: unable to allocate stack for coroutine, exiting.");
-          _exit (EXIT_FAILURE);
+      _exit (EXIT_FAILURE);
-        }
-      stack_start = cctx->sptr;
-      stack_size  = cctx->ssize;
     }
-  #if CORO_USE_VALGRIND
-    cctx->valgrind_id = VALGRIND_STACK_REGISTER ((char *)stack_start, (char *)stack_start + stack_size);
-  #endif
-  coro_create (&cctx->cctx, cctx_run, (void *)cctx, stack_start, stack_size);
+  coro_create (&cctx->cctx, cctx_run, (void *)cctx, cctx->stack.sptr, cctx->stack.ssze);
   return cctx;
 }
 static void
   assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
   --cctx_count;
   coro_destroy (&cctx->cctx);
-  /* coro_transfer creates new, empty cctx's */
+  coro_stack_free (&cctx->stack);
-  if (cctx->sptr)
-    {
-      #if CORO_USE_VALGRIND
-        VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
-      #endif
-#if HAVE_MMAP
-      if (cctx->flags & CC_MAPPED)
-        munmap (cctx->sptr, cctx->ssize);
-      else
-#endif
-        Safefree (cctx->sptr);
-    }
   Safefree (cctx);
 }
 /* wether this cctx should be destructed */
 }
 static void
 cctx_put (coro_cctx *cctx)
 {
-  assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
+  assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->stack.sptr));
   /* free another cctx if overlimit */
   if (ecb_expect_false (cctx_idle >= cctx_max_idle))
     {
       coro_cctx *first = cctx_first;
     return;
   slf_destroy (aTHX_ coro);
   coro->flags |= CF_ZOMBIE;
   if (coro->flags & CF_READY)
     {
       /* reduce nready, as destroying a ready coro effectively unreadies it */
       /* alternative: look through all ready queues and remove the coro */
       --coro_nready;
   TRANSFER (ta, 1);
 }
 /** Coro ********************************************************************/
-ECB_INLINE void
+ecb_inline void
 coro_enq (pTHX_ struct coro *coro)
 {
   struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
   SvREFCNT_inc_NN (coro->hv);
   coro->next_ready = 0;
   *(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
   ready [1] = coro;
 }
-ECB_INLINE struct coro *
+ecb_inline struct coro *
 coro_deq (pTHX)
 {
   int prio;
   for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
 {
   return !!(SvSTATE (coro_sv)->flags & CF_READY);
 }
 /* expects to own a reference to next->hv */
-ECB_INLINE void
+ecb_inline void
 prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)
 {
   SV *prev_sv = SvRV (coro_current);
   ta->prev = SvSTATE_hv (prev_sv);
           /* nothing to schedule: call the idle handler */
           if (SvROK (sv_idle)
               && SvOBJECT (SvRV (sv_idle)))
             {
               if (SvRV (sv_idle) == SvRV (coro_current))
+                {
+                  require_pv ("Carp");
+                  {
+                    dSP;
+                    ENTER;
+                    SAVETMPS;
+                    PUSHMARK (SP);
-                croak ("FATAL: $Coro::IDLE blocked itself - did you try to block inside an event loop callback? Caught");
+                    XPUSHs (sv_2mortal (newSVpv ("FATAL: $Coro::idle blocked itself - did you try to block inside an event loop callback? Caught", 0)));
+                    PUTBACK;
+                    call_pv ("Carp::confess", G_VOID | G_DISCARD);
+                    FREETMPS;
+                    LEAVE;
+                  }
+                }
               ++coro_nready; /* hack so that api_ready doesn't invoke ready hook */
               api_ready (aTHX_ SvRV (sv_idle));
               --coro_nready;
             }
             }
         }
     }
 }
-ECB_INLINE void
+ecb_inline void
 prepare_cede (pTHX_ struct coro_transfer_args *ta)
 {
   api_ready (aTHX_ coro_current);
   prepare_schedule (aTHX_ ta);
 }
-ECB_INLINE void
+ecb_inline void
 prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
 {
   SV *prev = SvRV (coro_current);
   if (coro_nready)
 {
   AV *od = coro->on_destroy;
   if (!od)
     return;
+  coro->on_destroy = 0;
+  sv_2mortal ((SV *)od);
   while (AvFILLp (od) >= 0)
     {
       SV *cb = sv_2mortal (av_pop (od));
 static void
 coro_set_status (pTHX_ struct coro *coro, SV **arg, int items)
 {
   AV *av;
   if (coro->status)
     {
       av = coro->status;
       av_clear (av);
     }
   coro = SvSTATE (arg [0]);
   coro_hv = coro->hv;
   coro_set_status (aTHX_ coro, arg + 1, items - 1);
   if (ecb_expect_false (coro->flags & CF_NOCANCEL))
     {
       /* coro currently busy cancelling something, so just notify it */
       coro->slf_frame.data = (void *)coro;
       slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
     }
   else
     {
       struct coro *self = SvSTATE_current;
+      if (!self)
+        croak ("Coro::cancel called outside of thread content,");
       /* otherwise we cancel directly, purely for speed reasons
        * unfortunately, this requires some magic trickery, as
        * somebody else could cancel us, so we have to fight the cancellation.
        * this is ugly, and hopefully fully worth the extra speed.
 static int
 slf_check_rouse_wait (pTHX_ struct CoroSLF *frame)
 {
   SV *data = (SV *)frame->data;
   if (CORO_THROW)
     return 0;
   if (SvTYPE (SvRV (data)) != SVt_PVAV)
     return 1;
       cb = sv_2mortal (coro->rouse_cb);
       coro->rouse_cb = 0;
     }
   if (!SvROK (cb)
       || SvTYPE (SvRV (cb)) != SVt_PVCV
       || CvXSUB ((CV *)SvRV (cb)) != coro_rouse_callback)
     croak ("Coro::rouse_wait called with illegal callback argument,");
   {
     CV *cv = (CV *)SvRV (cb); /* for S_GENSUB_ARG */
 /* "undo"/cancel a running slf call - used when cancelling a coro, mainly */
 static void
 slf_destroy (pTHX_ struct coro *coro)
 {
-  /* this callback is reserved for slf functions needing to do cleanup */
+  struct CoroSLF frame = coro->slf_frame;
-  if (coro->slf_frame.destroy && coro->slf_frame.prepare && !PL_dirty)
-    coro->slf_frame.destroy (aTHX_ &coro->slf_frame);
   /*
-   * The on_destroy above most likely is from an SLF call.
+   * The on_destroy below most likely is from an SLF call.
    * Since by definition the SLF call will not finish when we destroy
    * the coro, we will have to force-finish it here, otherwise
    * cleanup functions cannot call SLF functions.
    */
   coro->slf_frame.prepare = 0;
+  /* this callback is reserved for slf functions needing to do cleanup */
+  if (frame.destroy && frame.prepare && !PL_dirty)
+    frame.destroy (aTHX_ &frame);
 }
 /*
  * these not obviously related functions are all rolled into one
  * function to increase chances that they all will call transfer with the same
 static void
 coro_pop_on_leave (pTHX_ void *coro)
 {
   SV *cb = coro_avp_pop_and_free (aTHX_ &((struct coro *)coro)->on_leave);
   on_enterleave_call (aTHX_ sv_2mortal (cb));
+}
+static void
+enterleave_hook_xs (pTHX_ struct coro *coro, AV **avp, coro_enterleave_hook hook, void *arg)
+{
+  if (!hook)
+    return;
+  if (!*avp)
+    {
+      *avp = newAV ();
+      AvREAL_off (*avp);
+    }
+  av_push (*avp, (SV *)hook);
+  av_push (*avp, (SV *)arg);
+}
+static void
+enterleave_unhook_xs (pTHX_ struct coro *coro, AV **avp, coro_enterleave_hook hook, int execute)
+{
+  AV *av = *avp;
+  int i;
+  if (!av)
+    return;
+  for (i = AvFILLp (av) - 1; i >= 0; i -= 2)
+    if (AvARRAY (av)[i] == (SV *)hook)
+      {
+        if (execute)
+          hook (aTHX_ (void *)AvARRAY (av)[i + 1]);
+        memmove (AvARRAY (av) + i, AvARRAY (av) + i + 2, AvFILLp (av) - i - 1);
+        av_pop (av);
+        av_pop (av);
+        break;
+      }
+  if (AvFILLp (av) >= 0)
+    {
+      *avp = 0;
+      SvREFCNT_dec_NN (av);
+    }
+}
+static void
+api_enterleave_hook (pTHX_ SV *coro_sv, coro_enterleave_hook enter, void *enter_arg, coro_enterleave_hook leave, void *leave_arg)
+{
+  struct coro *coro = SvSTATE (coro_sv);
+  if (SvSTATE_current == coro)
+    if (enter)
+      enter (aTHX_ enter_arg);
+  enterleave_hook_xs (aTHX_ coro, &coro->on_enter_xs, enter, enter_arg);
+  enterleave_hook_xs (aTHX_ coro, &coro->on_leave_xs, leave, leave_arg);
+}
+static void
+api_enterleave_unhook (pTHX_ SV *coro_sv, coro_enterleave_hook enter, coro_enterleave_hook leave)
+{
+  struct coro *coro = SvSTATE (coro_sv);
+  enterleave_unhook_xs (aTHX_ coro, &coro->on_enter_xs, enter, 0);
+  enterleave_unhook_xs (aTHX_ coro, &coro->on_leave_xs, leave, SvSTATE_current == coro);
+}
+static void
+savedestructor_unhook_enter (pTHX_ coro_enterleave_hook enter)
+{
+  struct coro *coro = SvSTATE_current;
+  enterleave_unhook_xs (aTHX_ coro, &coro->on_enter_xs, enter, 0);
+}
+static void
+savedestructor_unhook_leave (pTHX_ coro_enterleave_hook leave)
+{
+  struct coro *coro = SvSTATE_current;
+  enterleave_unhook_xs (aTHX_ coro, &coro->on_leave_xs, leave, 1);
+}
+static void
+api_enterleave_scope_hook (pTHX_ coro_enterleave_hook enter, void *enter_arg, coro_enterleave_hook leave, void *leave_arg)
+{
+  api_enterleave_hook (aTHX_ coro_current, enter, enter_arg, leave, leave_arg);
+  /* this ought to be much cheaper than malloc + a single destructor call */
+  if (enter) SAVEDESTRUCTOR_X (savedestructor_unhook_enter, enter);
+  if (leave) SAVEDESTRUCTOR_X (savedestructor_unhook_leave, leave);
 }
 /*****************************************************************************/
 /* PerlIO::cede */
           XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
           PUTBACK;
           call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
         }
-      SvREFCNT_dec (cb);
+      SvREFCNT_dec_NN (cb);
     }
 }
 static void
 coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
 {
   AV *av = (AV *)frame->data;
   SV *count_sv = AvARRAY (av)[0];
   SV *coro_hv = SvRV (coro_current);
+  frame->destroy = 0;
   /* if we are about to throw, don't actually acquire the lock, just throw */
-  if (CORO_THROW)
+  if (ecb_expect_false (CORO_THROW))
+    {
+      /* we still might be responsible for the semaphore, so wake up others */
+      coro_semaphore_adjust (aTHX_ av, 0);
-    return 0;
+      return 0;
+    }
   else if (SvIVX (count_sv) > 0)
     {
-      frame->destroy = 0;
       if (acquire)
         SvIVX (count_sv) = SvIVX (count_sv) - 1;
       else
         coro_semaphore_adjust (aTHX_ av, 0);
     {
       int i;
       /* if we were woken up but can't down, we look through the whole */
       /* waiters list and only add us if we aren't in there already */
       /* this avoids some degenerate memory usage cases */
-      for (i = AvFILLp (av); i > 0; --i) // i > 0 is not an off-by-one bug
+      for (i = AvFILLp (av); i > 0; --i) /* i > 0 is not an off-by-one bug */
         if (AvARRAY (av)[i] == coro_hv)
           return 1;
       av_push (av, SvREFCNT_inc (coro_hv));
       return 1;
         {
           api_ready (aTHX_ cb);
           sv_setiv (cb, 0); /* signal waiter */
         }
-      SvREFCNT_dec (cb);
+      SvREFCNT_dec_NN (cb);
       --count;
     }
 }
   }
   av_push (state, data_sv);
   api_ready (aTHX_ coro);
-  SvREFCNT_dec (coro);
+  SvREFCNT_dec_NN (coro);
-  SvREFCNT_dec ((AV *)state);
+  SvREFCNT_dec_NN ((AV *)state);
 }
 static int
 slf_check_aio_req (pTHX_ struct CoroSLF *frame)
 {
   /* it quickly returns */
   if (CORO_THROW)
     return 0;
   /* one element that is an RV? repeat! */
-  if (AvFILLp (state) == 0 && SvROK (AvARRAY (state)[0]))
+  if (AvFILLp (state) == 0 && SvTYPE (AvARRAY (state)[0]) != SVt_PV)
     return 1;
   /* restore status */
   {
     SV *data_sv = av_pop (state);
     errno          = data->errorno;
     PL_laststype   = data->laststype;
     PL_laststatval = data->laststatval;
     PL_statcache   = data->statcache;
-    SvREFCNT_dec (data_sv);
+    SvREFCNT_dec_NN (data_sv);
   }
   /* push result values */
   {
     dSP;
 #endif
 #if CORO_JIT
 static void ecb_noinline ecb_cold
-pushav_3uv (pTHX_ UV a, UV b, UV c)
+pushav_4uv (pTHX_ UV a, UV b, UV c, UV d)
 {
   dSP;
   AV *av = newAV ();
+  av_store (av, 3, newSVuv (d));
   av_store (av, 2, newSVuv (c));
   av_store (av, 1, newSVuv (b));
   av_store (av, 0, newSVuv (a));
   XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
 {
   dSP;
   SV *load, *save;
   char *map_base;
   char *load_ptr, *save_ptr;
-  STRLEN load_len, save_len;
+  STRLEN load_len, save_len, map_len;
   int count;
+  eval_pv ("require 'Coro/jit-" CORO_JIT_TYPE ".pl'", 1);
   PUSHMARK (SP);
-  PUTBACK;
-#define VARx(name,expr,type) pushav_3uv (aTHX_ (UV)&(expr), offsetof (perl_slots, name), sizeof (type));
+  #define VARx(name,expr,type) pushav_4uv (aTHX_ (UV)&(expr), sizeof (expr), offsetof (perl_slots, name), sizeof (type));
-# include "state.h"
+  #include "state.h"
-#undef VARx
   count = call_pv ("Coro::State::_jit", G_ARRAY);
   SPAGAIN;
   save = POPs; save_ptr = SvPVbyte (save, save_len);
   load = POPs; load_ptr = SvPVbyte (load, load_len);
+  map_len = load_len + save_len + 16;
-  map_base = mmap (0, load_len + save_len + 16, PROT_EXEC | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  map_base = mmap (0, map_len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  assert (("Coro: unable mmap jit code page, cannot continue.", map_base != (char *)MAP_FAILED));
+  assert (("Coro: unable to mmap jit code page, cannot continue.", map_base != (char *)MAP_FAILED));
   load_perl_slots = (load_save_perl_slots_type)map_base;
   memcpy (map_base, load_ptr, load_len);
   map_base += (load_len + 15) & ~15;
   save_perl_slots = (load_save_perl_slots_type)map_base;
   memcpy (map_base, save_ptr, save_len);
+  /* we are good citizens and try to make the page read-only, so the evil evil */
+  /* hackers might have it a bit more difficult */
+  mprotect (map_base, map_len, PROT_READ | PROT_EXEC);
+  PUTBACK;
+  eval_pv ("undef &Coro::State::_jit", 1);
 }
 #endif
 MODULE = Coro::State                PACKAGE = Coro::State	PREFIX = api_
 PROTOTYPES: DISABLE
 BOOT:
 {
+#define VARx(name,expr,type) if (sizeof (type) < sizeof (expr)) croak ("FATAL: Coro thread context slot '" # name "' too small for this version of perl.");
+#include "state.h"
 #ifdef USE_ITHREADS
 # if CORO_PTHREAD
         coro_thx = PERL_GET_CONTEXT;
 # endif
 #endif
-        BOOT_PAGESIZE;
         /* perl defines these to check for existance first, but why it doesn't */
         /* just create them one at init time is not clear to me, except for */
         /* programs trying to delete them, but... */
         /* anyway, we declare this as invalid and make sure they are initialised here */
         DEFSV;
         time_init (aTHX);
         assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
 #if CORO_JIT
 	PUTBACK;
-        require_pv ("Coro/jit-" CORO_JIT_TYPE ".pl");
 	jit_init (aTHX);
-        perl_eval_pv ("undef &Coro::State::_jit", 1);
         SPAGAIN;
 #endif
 }
 SV *
 void
 transfer (...)
         PROTOTYPE: $$
 	CODE:
         CORO_EXECUTE_SLF_XS (slf_init_transfer);
-void
-_exit (int code)
-        PROTOTYPE: $
-	CODE:
-	_exit (code);
 SV *
 clone (Coro::State coro)
 	CODE:
 {
 void
 list ()
 	PROTOTYPE:
 	PPCODE:
 {
-  	struct coro *coro;
+	struct coro *coro;
         for (coro = coro_first; coro; coro = coro->next)
           if (coro->hv)
             XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
 }
         RETVAL = boolSV (coro->flags & ix);
 	OUTPUT:
         RETVAL
 void
-throw (Coro::State self, SV *exception = &PL_sv_undef)
+throw (SV *self, SV *exception = &PL_sv_undef)
 	PROTOTYPE: $;$
         CODE:
 {
+	struct coro *coro    = SvSTATE (self);
 	struct coro *current = SvSTATE_current;
-	SV **exceptionp = self == current ? &CORO_THROW : &self->except;
+	SV **exceptionp = coro == current ? &CORO_THROW : &coro->except;
         SvREFCNT_dec (*exceptionp);
         SvGETMAGIC (exception);
         *exceptionp = SvOK (exception) ? newSVsv (exception) : 0;
+	api_ready (aTHX_ self);
 }
 void
 api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
 	PROTOTYPE: $;$
 void
 times (Coro::State self)
 	PPCODE:
 {
-  	struct coro *current = SvSTATE (coro_current);
+	struct coro *current = SvSTATE (coro_current);
         if (ecb_expect_false (current == self))
           {
             coro_times_update ();
             coro_times_add (SvSTATE (coro_current));
 MODULE = Coro::State                PACKAGE = Coro
 BOOT:
 {
+	if (SVt_LAST > 32)
+          croak ("Coro internal error: SVt_LAST > 32, swap_sv might need adjustment");
         sv_pool_rss        = coro_get_sv (aTHX_ "Coro::POOL_RSS"  , TRUE);
         sv_pool_size       = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
         cv_coro_run        =      get_cv (      "Coro::_coro_run" , GV_ADD);
         coro_current       = coro_get_sv (aTHX_ "Coro::current"   , FALSE); SvREADONLY_on (coro_current);
         av_async_pool      = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
         sv_async_pool_idle = newSVpv ("[async pool idle]", 0); SvREADONLY_on (sv_async_pool_idle);
         sv_Coro            = newSVpv ("Coro", 0); SvREADONLY_on (sv_Coro);
         cv_pool_handler    = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler);
         CvNODEBUG_on (get_cv ("Coro::_pool_handler", 0)); /* work around a debugger bug */
 	coro_stash = gv_stashpv ("Coro", TRUE);
         newCONSTSUB (coro_stash, "PRIO_MAX",    newSViv (CORO_PRIO_MAX));
         newCONSTSUB (coro_stash, "PRIO_HIGH",   newSViv (CORO_PRIO_HIGH));
         newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (CORO_PRIO_NORMAL));
           coroapi.ready        = api_ready;
           coroapi.is_ready     = api_is_ready;
           coroapi.nready       = coro_nready;
           coroapi.current      = coro_current;
+          coroapi.enterleave_hook       = api_enterleave_hook;
+          coroapi.enterleave_unhook     = api_enterleave_unhook;
+          coroapi.enterleave_scope_hook = api_enterleave_scope_hook;
           /*GCoroAPI = &coroapi;*/
           sv_setiv (sv, (IV)&coroapi);
           SvREADONLY_on (sv);
         }
 }
 void
 _set_current (SV *current)
         PROTOTYPE: $
 	CODE:
-        SvREFCNT_dec (SvRV (coro_current));
+        SvREFCNT_dec_NN (SvRV (coro_current));
         SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
 void
 _set_readyhook (SV *hook)
 	PROTOTYPE: $
         if ((SV *)hv == &PL_sv_undef)
           {
             SV *sv = coro_new (aTHX_ coro_stash, (SV **)&cv_pool_handler, 1, 1);
             hv = (HV *)SvREFCNT_inc_NN (SvRV (sv));
-            SvREFCNT_dec (sv);
+            SvREFCNT_dec_NN (sv);
           }
         {
           struct coro *coro = SvSTATE_hv (hv);
         api_ready (aTHX_ (SV *)hv);
         if (GIMME_V != G_VOID)
           XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
         else
-          SvREFCNT_dec (hv);
+          SvREFCNT_dec_NN (hv);
 }
 SV *
 rouse_cb ()
         PROTOTYPE:
         on_leave = 1
 	PROTOTYPE: &
 	CODE:
 {
 	struct coro *coro = SvSTATE_current;
-  	AV **avp = ix ? &coro->on_leave : &coro->on_enter;
+	AV **avp = ix ? &coro->on_leave : &coro->on_enter;
         block = s_get_cv_croak (block);
         if (!*avp)
           *avp = newAV ();
 SV *
 new (SV *klass, SV *count = 0)
 	CODE:
 {
-  	int semcnt = 1;
+	int semcnt = 1;
         if (count)
           {
             SvGETMAGIC (count);
           XSRETURN_NO;
 }
 void
 waiters (SV *self)
-    	PPCODE:
+	PPCODE:
 {
         AV *av = (AV *)SvRV (self);
         int wcount = AvFILLp (av) + 1 - 1;
         if (GIMME_V == G_SCALAR)
 }
 MODULE = Coro::State                PACKAGE = Coro::SemaphoreSet
 void
-_may_delete (SV *sem, int count, int extra_refs)
+_may_delete (SV *sem, int count, unsigned int extra_refs)
 	PPCODE:
 {
-  	AV *av = (AV *)SvRV (sem);
+	AV *av = (AV *)SvRV (sem);
         if (SvREFCNT ((SV *)av) == 1 + extra_refs
             && AvFILLp (av) == 0 /* no waiters, just count */
             && SvIV (AvARRAY (av)[0]) == count)
           XSRETURN_YES;
 void
 broadcast (SV *self)
         CODE:
 {
-  	AV *av = (AV *)SvRV (self);
+	AV *av = (AV *)SvRV (self);
         coro_signal_wake (aTHX_ av, AvFILLp (av));
 }
 void
 send (SV *self)
           SvIVX (AvARRAY (av)[0]) = 1; /* remember the signal */
 }
 IV
 awaited (SV *self)
-    	CODE:
+	CODE:
         RETVAL = AvFILLp ((AV *)SvRV (self)) + 1 - 1;
 	OUTPUT:
         RETVAL
 void
 _schedule (...)
 	CODE:
 {
-  	static int incede;
+	static int incede;
         api_cede_notself (aTHX);
         ++incede;
         while (coro_nready >= incede && api_cede (aTHX))
           {
             PL_ppaddr [OP_SSELECT] = coro_old_pp_sselect;
             coro_old_pp_sselect = 0;
           }
+MODULE = Coro::State                PACKAGE = Coro::Util
+void
+_exit (int code)
+	CODE:
+	_exit (code);
+NV
+time ()
+	CODE:
+        RETVAL = nvtime (aTHX);
+	OUTPUT:
+        RETVAL
+NV
+gettimeofday ()
+	PPCODE:
+{
+        UV tv [2];
+        u2time (aTHX_ tv);
+        EXTEND (SP, 2);
+        PUSHs (sv_2mortal (newSVuv (tv [0])));
+        PUSHs (sv_2mortal (newSVuv (tv [1])));
+}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing Coro/Coro/State.xs (file contents): Revision 1.406 by root, Sat Jun 11 13:49:00 2011 UTC vs. Revision 1.454 by root, Tue Jul 7 00:38:03 2015 UTC

Diff Legend

Comparing Coro/Coro/State.xs (file contents):
Revision 1.406 by root, Sat Jun 11 13:49:00 2011 UTC vs.
Revision 1.454 by root, Tue Jul 7 00:38:03 2015 UTC