perl.h add SVVALIDIVX()/SVVAILDRV/SVVAILDNVX/SVVAILDPVX bitfield testers

- Add faster versions of the PL_valid_types_IVX[], PL_valid_types_PVX[],
  etc array tests intended for use in -O2/not -DDEBUGGING builds.

- Currently the PL_valid_types_*VX[] arrays are all 17 bytes long and only
  used for -DDEBUGGING assert()s in sv.h.  The same information can be
  stored in a U32 literal integer instead.  By making these macros use a
  U32 literal integer instead of a const array of bool/8 vars, there is
  no performance or overhead concerns anymore, if someone finds a reason
  to use these macros, in an optimized perl build. The U32 literal integers
  are now part of the CPU's instruction stream like in all other SV*
  flag tests.
- It is not known yet if there is any good reason to these faster macros,
  or the old slower PL_valid_types_*VX[]s arrays, in an optimized blead
  perl or optimized stable perl. All "correct enough" code either in CORE
  or on CPAN already has macros or expressions using existing macros,
  to test whatever flags they need to test inside a SV* head struct.

Author: bulk88

ext/XS-APItest/APItest.pm

@@ -4,7 +4,7 @@ use strict;
 use warnings;
 use Carp;
 
-our $VERSION = '1.43';
+our $VERSION = '1.44';
 
 require XSLoader;
 

ext/XS-APItest/APItest.xs

@@ -1999,6 +1999,82 @@ test_mismatch_xs_handshake_api_ver(...)
 #endif
     }
 
+bool
+PL_valid_types_IRNPVX_arrays()
+    PREINIT:
+        int i;
+        int t;
+        SV fksv;
+        bool * arr;
+        bool* p_arrs [] = {
+            PL_valid_types_IVX,
+            PL_valid_types_NVX,
+            PL_valid_types_PVX,
+            PL_valid_types_RV,
+            PL_valid_types_IV_set,
+            PL_valid_types_NV_set
+        };
+    CODE:
+        for(i=0; i< C_ARRAY_LENGTH(p_arrs); i++){
+            arr = p_arrs[i];
+            switch(i) {
+                case 0:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDIVX(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+                case 1:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDNVX(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+                case 2:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDPVX(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+                case 3:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDRV(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+                case 4:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDIV_set(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+                case 5:
+                    for(t = 0; t <SVt_LAST; t++) {
+                        SvFLAGS(&fksv) = t;
+                        if (cBOOL(SVVAILDNV_set(&fksv))
+                            != cBOOL(arr[SvTYPE(&fksv) & SVt_MASK]))
+                            goto failed;
+                    }
+                    break;
+            }
+        }
+        RETVAL = TRUE;
+        if (0){
+            failed:
+            RETVAL = FALSE;
+        }
+    OUTPUT:
+        RETVAL
 
 MODULE = XS::APItest:Hash               PACKAGE = XS::APItest::Hash
 

ext/XS-APItest/t/xsub_h.t

@@ -150,5 +150,7 @@ is scalar @xs_empty, 0, 'XSRETURN_EMPTY returns empty list in array context';
 my $xs_empty = XS::APItest::XSUB::xsreturn_empty();
 is $xs_empty, undef, 'XSRETURN_EMPTY returns undef in scalar context';
 
+ok( XS::APItest::XSUB::PL_valid_types_IRNPVX_arrays(),
+    "APItest::XSUB::PL_valid_types_IRNPVX_arrays returned true");
 
 done_testing();

perl.h

@@ -6265,6 +6265,51 @@ EXTCONST U8 PL_magic_data[256] =
 EXTCONST U8 PL_magic_data[256];
 #endif
 
+#define SVtVAILDIVX ((0<<0)/*NL*/|(1<<1)/*IV*/|(0<<2)/*NV*/|(0<<3)/*PV*/ \
+    |(0<<4)/*INV*/|(1<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(0<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(0<<13)/*CV*/ \
+    |(0<<14)/*FM*/|(0<<15)/*IO*/|(0<<16)/*OBJ*/)
+#define SVtVAILDNVX ((0<<0)/*NL*/|(0<<1)/*IV*/|(1<<2)/*NV*/|(0<<3)/*PV*/ \
+    |(0<<4)/*INV*/|(0<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(0<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(0<<13)/*CV*/ \
+    |(0<<14)/*FM*/|(0<<15)/*IO*/|(0<<16)/*OBJ*/)
+#define SVtVAILDPVX ((0<<0)/*NL*/|(0<<1)/*IV*/|(0<<2)/*NV*/|(1<<3)/*PV*/ \
+    |(1<<4)/*INV*/|(1<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(1<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(1<<13)/*CV*/ \
+    |(1<<14)/*FM*/|(1<<15)/*IO*/|(0<<16)/*OBJ*/)
+#define SVtVAILDRV ((0<<0)/*NL*/|(1<<1)/*IV*/|(0<<2)/*NV*/|(1<<3)/*PV*/ \
+    |(0<<4)/*INV*/|(1<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(1<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(0<<13)/*CV*/ \
+    |(0<<14)/*FM*/|(1<<15)/*IO*/|(0<<16)/*OBJ*/)
+#define SVtVAILDIV_set ((0<<0)/*NL*/|(1<<1)/*IV*/|(0<<2)/*NV*/|(0<<3)/*PV*/ \
+    |(0<<4)/*INV*/|(1<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(1<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(0<<13)/*CV*/ \
+    |(1<<14)/*FM*/|(1<<15)/*IO*/|(0<<16)/*OBJ*/)
+#define SVtVAILDNV_set ((0<<0)/*NL*/|(0<<1)/*IV*/|(1<<2)/*NV*/|(0<<3)/*PV*/ \
+    |(0<<4)/*INV*/|(0<<5)/*PI*/|(1<<6)/*PN*/|(1<<7)/*MG*/|(1<<8)/*RX*/ \
+    |(1<<9)/*GV*/|(1<<10)/*LV*/|(0<<11)/*AV*/|(0<<12)/*HV*/|(0<<13)/*CV*/ \
+    |(0<<14)/*FM*/|(0<<15)/*IO*/|(0<<16)/*OBJ*/)
+
+/* Experimental. Only for PERL_CORE. Not for CPAN XS or private XS code.
+ *
+ * Faster but identical to the assert tests inside sv.h that look like :
+ *
+ *      assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]);
+ *
+ * These macros don't do an extra memory read from a 17 byte array like
+ * the assert() above.  The intent is these macros could be used in
+ * -O1/-O2 non-DEBUGGING builds, either temporarily in blead, or permanently
+ * in stable releases. Probably the only useful macro is SVVAILDPVX() vs
+ *      if ((type >= SVt_PV && type <= SVt_PVLV) || type == SVt_PVCV) { 0; }
+ */
+
+#define SVVAILDIVX(_sv) ((1<<SvTYPE(_sv))&SVtVAILDIVX)
+#define SVVAILDNVX(_sv) ((1<<SvTYPE(_sv))&SVtVAILDNVX)
+#define SVVAILDPVX(_sv) ((1<<SvTYPE(_sv))&SVtVAILDPVX)
+#define SVVAILDRV(_sv) ((1<<SvTYPE(_sv))&SVtVAILDRV)
+#define SVVAILDIV_set(_sv) ((1<<SvTYPE(_sv))&SVtVAILDIV_set)
+#define SVVAILDNV_set(_sv) ((1<<SvTYPE(_sv))&SVtVAILDNV_set)
+
 #ifdef DOINIT
                         /* NL IV NV PV INV PI PN MG RX GV LV AV HV CV FM IO OBJ */
 EXTCONST bool