%test-vector instruction for vany?, vall?, vnone?

basis/compiler/cfg/comparisons/comparisons.factor

@@ -9,6 +9,9 @@ SYMBOLS:
     cc<  cc<=  cc=  cc>  cc>=  cc<>  cc<>= 
     cc/< cc/<= cc/= cc/> cc/>= cc/<> cc/<>= ;
 
+SYMBOLS:
+    vcc-all vcc-any vcc-none ;
+
 : negate-cc ( cc -- cc' )
     H{
         { cc<    cc/<   }

basis/compiler/cfg/instructions/instructions.factor

@@ -302,6 +302,12 @@ def: dst
 use: src1 src2
 literal: rep cc ;
 
+PURE-INSN: ##test-vector
+def: dst/int-rep
+use: src
+temp: temp/int-rep
+literal: rep vcc ;
+
 PURE-INSN: ##add-vector
 def: dst
 use: src1 src2

basis/compiler/cfg/intrinsics/intrinsics.factor

@@ -172,6 +172,9 @@ IN: compiler.cfg.intrinsics
         { math.vectors.simd.intrinsics:(simd-vbitor) [ [ ^^or-vector ] emit-binary-vector-op ] }
         { math.vectors.simd.intrinsics:(simd-vbitxor) [ [ ^^xor-vector ] emit-binary-vector-op ] }
         { math.vectors.simd.intrinsics:(simd-v=) [ [ cc= ^^compare-vector ] emit-binary-vector-op ] }
+        { math.vectors.simd.intrinsics:(simd-vany?) [ [ vcc-any ^^test-vector ] emit-unary-vector-op ] }
+        { math.vectors.simd.intrinsics:(simd-vall?) [ [ vcc-all ^^test-vector ] emit-unary-vector-op ] }
+        { math.vectors.simd.intrinsics:(simd-vnone?) [ [ vcc-none ^^test-vector ] emit-unary-vector-op ] }
         { math.vectors.simd.intrinsics:(simd-vlshift) [ [ ^^shl-vector ] emit-binary-vector-op ] }
         { math.vectors.simd.intrinsics:(simd-vrshift) [ [ ^^shr-vector ] emit-binary-vector-op ] }
         { math.vectors.simd.intrinsics:(simd-hlshift) [ [ ^^horizontal-shl-vector ] emit-horizontal-shift ] }

basis/compiler/codegen/codegen.factor

@@ -167,6 +167,7 @@ CODEGEN: ##gather-vector-2 %gather-vector-2
 CODEGEN: ##gather-vector-4 %gather-vector-4
 CODEGEN: ##shuffle-vector %shuffle-vector
 CODEGEN: ##compare-vector %compare-vector
+CODEGEN: ##test-vector %test-vector
 CODEGEN: ##box-vector %box-vector
 CODEGEN: ##add-vector %add-vector
 CODEGEN: ##saturated-add-vector %saturated-add-vector

basis/compiler/tree/propagation/simd/simd.factor

@@ -46,6 +46,12 @@ IN: compiler.tree.propagation.simd
 
 \ (simd-v.) [ 2nip scalar-output-class ] "outputs" set-word-prop
 
+{
+    (simd-vany?)
+    (simd-vall?)
+    (simd-vnone?)
+} [ { boolean } "default-output-classes" set-word-prop ] each
+
 \ (simd-select) [ 2nip scalar-output-class ] "outputs" set-word-prop
 
 \ assert-positive [

basis/cpu/architecture/architecture.factor

@@ -224,6 +224,7 @@ HOOK: %gather-vector-2 cpu ( dst src1 src2 rep -- )
 HOOK: %gather-vector-4 cpu ( dst src1 src2 src3 src4 rep -- )
 HOOK: %shuffle-vector cpu ( dst src shuffle rep -- )
 HOOK: %compare-vector cpu ( dst src1 src2 rep cc -- )
+HOOK: %test-vector cpu ( dst src temp rep vcc -- )
 HOOK: %add-vector cpu ( dst src1 src2 rep -- )
 HOOK: %saturated-add-vector cpu ( dst src1 src2 rep -- )
 HOOK: %add-sub-vector cpu ( dst src1 src2 rep -- )
@@ -258,6 +259,7 @@ HOOK: %gather-vector-2-reps cpu ( -- reps )
 HOOK: %gather-vector-4-reps cpu ( -- reps )
 HOOK: %shuffle-vector-reps cpu ( -- reps )
 HOOK: %compare-vector-reps cpu ( -- reps )
+HOOK: %test-vector-reps cpu ( -- reps )
 HOOK: %add-vector-reps cpu ( -- reps )
 HOOK: %saturated-add-vector-reps cpu ( -- reps )
 HOOK: %add-sub-vector-reps cpu ( -- reps )

basis/cpu/ppc/ppc.factor

@@ -268,6 +268,7 @@ M: ppc %gather-vector-2-reps { } ;
 M: ppc %gather-vector-4-reps { } ;
 M: ppc %shuffle-vector-reps { } ;
 M: ppc %compare-vector-reps { } ;
+M: ppc %test-vector-reps { } ;
 M: ppc %add-vector-reps { } ;
 M: ppc %saturated-add-vector-reps { } ;
 M: ppc %add-sub-vector-reps { } ;

basis/cpu/x86/x86.factor

@@ -747,6 +747,27 @@ M: x86 %compare-vector-reps
         { sse4.1? { longlong-2-rep ulonglong-2-rep } }
     } available-reps ;
 
+:: (%test-vector) ( dst temp mask vcc -- )
+    vcc {
+        { vcc-any  [ dst dst TEST dst temp \ CMOVNE %boolean ] }
+        { vcc-none [ dst dst TEST dst temp \ CMOVE  %boolean ] }
+        { vcc-all  [ dst mask CMP dst temp \ CMOVE  %boolean ] }
+    } case ;
+
+M:: x86 %test-vector ( dst src temp rep vcc -- )
+    dst src rep {
+        { double-2-rep [ MOVMSKPD HEX: 3 ] }
+        { float-4-rep  [ MOVMSKPS HEX: f ] }
+        [ drop PMOVMSKB HEX: ffff ]
+    } case :> mask
+    dst temp mask vcc (%test-vector) ;
+
+M: x86 %test-vector-reps
+    {
+        { sse? { float-4-rep } }
+        { sse2? { double-2-rep char-16-rep uchar-16-rep short-8-rep ushort-8-rep int-4-rep uint-4-rep longlong-2-rep ulonglong-2-rep } }
+    } available-reps ;
+
 M: x86 %add-vector ( dst src1 src2 rep -- )
     [ two-operand ] keep
     {

basis/math/vectors/simd/intrinsics/intrinsics.factor

@@ -50,6 +50,9 @@ SIMD-OP: hlshift
 SIMD-OP: hrshift
 SIMD-OP: vshuffle
 SIMD-OP: v=
+SIMD-OP: vany?
+SIMD-OP: vall?
+SIMD-OP: vnone?
 
 : (simd-with) ( x rep -- v ) bad-simd-call ;
 : (simd-gather-2) ( a b rep -- v ) bad-simd-call ;
@@ -130,4 +133,7 @@ M: vector-rep supported-simd-op?
         { \ (simd-v=)       [ %compare-vector-reps        ] }
         { \ (simd-gather-2) [ %gather-vector-2-reps       ] }
         { \ (simd-gather-4) [ %gather-vector-4-reps       ] }
+        { \ (simd-vany?)    [ %test-vector-reps           ] }
+        { \ (simd-vall?)    [ %test-vector-reps           ] }
+        { \ (simd-vnone?)   [ %test-vector-reps           ] }
     } case member? ;

basis/math/vectors/specialization/specialization.factor

@@ -93,6 +93,9 @@ H{
     { vshuffle { +vector+ +literal+ -> +vector+ } }
     { vbroadcast { +vector+ +literal+ -> +vector+ } }
     { v= { +vector+ +vector+ -> +vector+ } }
+    { vany? { +vector+ -> +scalar+ } }
+    { vall? { +vector+ -> +scalar+ } }
+    { vnone? { +vector+ -> +scalar+ } }
 }
 
 PREDICATE: vector-word < word vector-words key? ;