8305461: [vectorapi] Add VectorMask::xor

Reviewed-by: psandoz
This commit is contained in:
Quan Anh Mai 2023-04-06 15:33:16 +00:00
parent ddd50d0db3
commit 536ad9df1a
64 changed files with 2451 additions and 321 deletions

@ -137,10 +137,17 @@ abstract class AbstractMask<E> extends VectorMask<E> {
}
@Override
public VectorMask<E> andNot(VectorMask<E> m) {
@ForceInline
public final VectorMask<E> andNot(VectorMask<E> m) {
return and(m.not());
}
@Override
@ForceInline
public final VectorMask<E> eq(VectorMask<E> m) {
return xor(m.not());
}
/*package-private*/
static boolean anyTrueHelper(boolean[] bits) {
// FIXME: Maybe use toLong() != 0 here.

@ -677,14 +677,6 @@ final class Byte128Vector extends ByteVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Byte128Mask eq(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte128Mask m = (Byte128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -733,9 +725,9 @@ final class Byte128Vector extends ByteVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Byte128Mask xor(VectorMask<Byte> mask) {
public Byte128Mask xor(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte128Mask m = (Byte128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte128Mask.class, null, byte.class, VLENGTH,

@ -709,14 +709,6 @@ final class Byte256Vector extends ByteVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Byte256Mask eq(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte256Mask m = (Byte256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -765,9 +757,9 @@ final class Byte256Vector extends ByteVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Byte256Mask xor(VectorMask<Byte> mask) {
public Byte256Mask xor(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte256Mask m = (Byte256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte256Mask.class, null, byte.class, VLENGTH,

@ -773,14 +773,6 @@ final class Byte512Vector extends ByteVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Byte512Mask eq(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte512Mask m = (Byte512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -829,9 +821,9 @@ final class Byte512Vector extends ByteVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Byte512Mask xor(VectorMask<Byte> mask) {
public Byte512Mask xor(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte512Mask m = (Byte512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte512Mask.class, null, byte.class, VLENGTH,

@ -661,14 +661,6 @@ final class Byte64Vector extends ByteVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Byte64Mask eq(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte64Mask m = (Byte64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -717,9 +709,9 @@ final class Byte64Vector extends ByteVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Byte64Mask xor(VectorMask<Byte> mask) {
public Byte64Mask xor(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
Byte64Mask m = (Byte64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte64Mask.class, null, byte.class, VLENGTH,

@ -647,14 +647,6 @@ final class ByteMaxVector extends ByteVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public ByteMaxMask eq(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
ByteMaxMask m = (ByteMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -703,9 +695,9 @@ final class ByteMaxVector extends ByteVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
ByteMaxMask xor(VectorMask<Byte> mask) {
public ByteMaxMask xor(VectorMask<Byte> mask) {
Objects.requireNonNull(mask);
ByteMaxMask m = (ByteMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMaxMask.class, null, byte.class, VLENGTH,

@ -638,14 +638,6 @@ final class Double128Vector extends DoubleVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Double128Mask eq(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double128Mask m = (Double128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -694,9 +686,9 @@ final class Double128Vector extends DoubleVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Double128Mask xor(VectorMask<Double> mask) {
public Double128Mask xor(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double128Mask m = (Double128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double128Mask.class, null, long.class, VLENGTH,

@ -642,14 +642,6 @@ final class Double256Vector extends DoubleVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Double256Mask eq(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double256Mask m = (Double256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -698,9 +690,9 @@ final class Double256Vector extends DoubleVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Double256Mask xor(VectorMask<Double> mask) {
public Double256Mask xor(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double256Mask m = (Double256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double256Mask.class, null, long.class, VLENGTH,

@ -650,14 +650,6 @@ final class Double512Vector extends DoubleVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Double512Mask eq(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double512Mask m = (Double512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -706,9 +698,9 @@ final class Double512Vector extends DoubleVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Double512Mask xor(VectorMask<Double> mask) {
public Double512Mask xor(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double512Mask m = (Double512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double512Mask.class, null, long.class, VLENGTH,

@ -636,14 +636,6 @@ final class Double64Vector extends DoubleVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Double64Mask eq(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double64Mask m = (Double64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -692,9 +684,9 @@ final class Double64Vector extends DoubleVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Double64Mask xor(VectorMask<Double> mask) {
public Double64Mask xor(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
Double64Mask m = (Double64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double64Mask.class, null, long.class, VLENGTH,

@ -635,14 +635,6 @@ final class DoubleMaxVector extends DoubleVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public DoubleMaxMask eq(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
DoubleMaxMask m = (DoubleMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -691,9 +683,9 @@ final class DoubleMaxVector extends DoubleVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
DoubleMaxMask xor(VectorMask<Double> mask) {
public DoubleMaxMask xor(VectorMask<Double> mask) {
Objects.requireNonNull(mask);
DoubleMaxMask m = (DoubleMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMaxMask.class, null, long.class, VLENGTH,

@ -642,14 +642,6 @@ final class Float128Vector extends FloatVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Float128Mask eq(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float128Mask m = (Float128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -698,9 +690,9 @@ final class Float128Vector extends FloatVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Float128Mask xor(VectorMask<Float> mask) {
public Float128Mask xor(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float128Mask m = (Float128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float128Mask.class, null, int.class, VLENGTH,

@ -650,14 +650,6 @@ final class Float256Vector extends FloatVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Float256Mask eq(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float256Mask m = (Float256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -706,9 +698,9 @@ final class Float256Vector extends FloatVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Float256Mask xor(VectorMask<Float> mask) {
public Float256Mask xor(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float256Mask m = (Float256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float256Mask.class, null, int.class, VLENGTH,

@ -666,14 +666,6 @@ final class Float512Vector extends FloatVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Float512Mask eq(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float512Mask m = (Float512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -722,9 +714,9 @@ final class Float512Vector extends FloatVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Float512Mask xor(VectorMask<Float> mask) {
public Float512Mask xor(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float512Mask m = (Float512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float512Mask.class, null, int.class, VLENGTH,

@ -638,14 +638,6 @@ final class Float64Vector extends FloatVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Float64Mask eq(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float64Mask m = (Float64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -694,9 +686,9 @@ final class Float64Vector extends FloatVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Float64Mask xor(VectorMask<Float> mask) {
public Float64Mask xor(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
Float64Mask m = (Float64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float64Mask.class, null, int.class, VLENGTH,

@ -635,14 +635,6 @@ final class FloatMaxVector extends FloatVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public FloatMaxMask eq(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
FloatMaxMask m = (FloatMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -691,9 +683,9 @@ final class FloatMaxVector extends FloatVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
FloatMaxMask xor(VectorMask<Float> mask) {
public FloatMaxMask xor(VectorMask<Float> mask) {
Objects.requireNonNull(mask);
FloatMaxMask m = (FloatMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaxMask.class, null, int.class, VLENGTH,

@ -653,14 +653,6 @@ final class Int128Vector extends IntVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Int128Mask eq(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int128Mask m = (Int128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -709,9 +701,9 @@ final class Int128Vector extends IntVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Int128Mask xor(VectorMask<Integer> mask) {
public Int128Mask xor(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int128Mask m = (Int128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int128Mask.class, null, int.class, VLENGTH,

@ -661,14 +661,6 @@ final class Int256Vector extends IntVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Int256Mask eq(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int256Mask m = (Int256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -717,9 +709,9 @@ final class Int256Vector extends IntVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Int256Mask xor(VectorMask<Integer> mask) {
public Int256Mask xor(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int256Mask m = (Int256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int256Mask.class, null, int.class, VLENGTH,

@ -677,14 +677,6 @@ final class Int512Vector extends IntVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Int512Mask eq(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int512Mask m = (Int512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -733,9 +725,9 @@ final class Int512Vector extends IntVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Int512Mask xor(VectorMask<Integer> mask) {
public Int512Mask xor(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int512Mask m = (Int512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int512Mask.class, null, int.class, VLENGTH,

@ -649,14 +649,6 @@ final class Int64Vector extends IntVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Int64Mask eq(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int64Mask m = (Int64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -705,9 +697,9 @@ final class Int64Vector extends IntVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Int64Mask xor(VectorMask<Integer> mask) {
public Int64Mask xor(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
Int64Mask m = (Int64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int64Mask.class, null, int.class, VLENGTH,

@ -647,14 +647,6 @@ final class IntMaxVector extends IntVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public IntMaxMask eq(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
IntMaxMask m = (IntMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -703,9 +695,9 @@ final class IntMaxVector extends IntVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
IntMaxMask xor(VectorMask<Integer> mask) {
public IntMaxMask xor(VectorMask<Integer> mask) {
Objects.requireNonNull(mask);
IntMaxMask m = (IntMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMaxMask.class, null, int.class, VLENGTH,

@ -639,14 +639,6 @@ final class Long128Vector extends LongVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Long128Mask eq(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long128Mask m = (Long128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -695,9 +687,9 @@ final class Long128Vector extends LongVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Long128Mask xor(VectorMask<Long> mask) {
public Long128Mask xor(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long128Mask m = (Long128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long128Mask.class, null, long.class, VLENGTH,

@ -643,14 +643,6 @@ final class Long256Vector extends LongVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Long256Mask eq(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long256Mask m = (Long256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -699,9 +691,9 @@ final class Long256Vector extends LongVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Long256Mask xor(VectorMask<Long> mask) {
public Long256Mask xor(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long256Mask m = (Long256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long256Mask.class, null, long.class, VLENGTH,

@ -651,14 +651,6 @@ final class Long512Vector extends LongVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Long512Mask eq(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long512Mask m = (Long512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -707,9 +699,9 @@ final class Long512Vector extends LongVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Long512Mask xor(VectorMask<Long> mask) {
public Long512Mask xor(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long512Mask m = (Long512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long512Mask.class, null, long.class, VLENGTH,

@ -637,14 +637,6 @@ final class Long64Vector extends LongVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Long64Mask eq(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long64Mask m = (Long64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -693,9 +685,9 @@ final class Long64Vector extends LongVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Long64Mask xor(VectorMask<Long> mask) {
public Long64Mask xor(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
Long64Mask m = (Long64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long64Mask.class, null, long.class, VLENGTH,

@ -637,14 +637,6 @@ final class LongMaxVector extends LongVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public LongMaxMask eq(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
LongMaxMask m = (LongMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -693,9 +685,9 @@ final class LongMaxVector extends LongVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
LongMaxMask xor(VectorMask<Long> mask) {
public LongMaxMask xor(VectorMask<Long> mask) {
Objects.requireNonNull(mask);
LongMaxMask m = (LongMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMaxMask.class, null, long.class, VLENGTH,

@ -661,14 +661,6 @@ final class Short128Vector extends ShortVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Short128Mask eq(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short128Mask m = (Short128Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -717,9 +709,9 @@ final class Short128Vector extends ShortVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Short128Mask xor(VectorMask<Short> mask) {
public Short128Mask xor(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short128Mask m = (Short128Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short128Mask.class, null, short.class, VLENGTH,

@ -677,14 +677,6 @@ final class Short256Vector extends ShortVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Short256Mask eq(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short256Mask m = (Short256Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -733,9 +725,9 @@ final class Short256Vector extends ShortVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Short256Mask xor(VectorMask<Short> mask) {
public Short256Mask xor(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short256Mask m = (Short256Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short256Mask.class, null, short.class, VLENGTH,

@ -709,14 +709,6 @@ final class Short512Vector extends ShortVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Short512Mask eq(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short512Mask m = (Short512Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -765,9 +757,9 @@ final class Short512Vector extends ShortVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Short512Mask xor(VectorMask<Short> mask) {
public Short512Mask xor(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short512Mask m = (Short512Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short512Mask.class, null, short.class, VLENGTH,

@ -653,14 +653,6 @@ final class Short64Vector extends ShortVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public Short64Mask eq(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short64Mask m = (Short64Mask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -709,9 +701,9 @@ final class Short64Vector extends ShortVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
Short64Mask xor(VectorMask<Short> mask) {
public Short64Mask xor(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
Short64Mask m = (Short64Mask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short64Mask.class, null, short.class, VLENGTH,

@ -647,14 +647,6 @@ final class ShortMaxVector extends ShortVector {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public ShortMaxMask eq(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
ShortMaxMask m = (ShortMaxMask)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -703,9 +695,9 @@ final class ShortMaxVector extends ShortVector {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
ShortMaxMask xor(VectorMask<Short> mask) {
public ShortMaxMask xor(VectorMask<Short> mask) {
Objects.requireNonNull(mask);
ShortMaxMask m = (ShortMaxMask)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMaxMask.class, null, short.class, VLENGTH,

@ -398,20 +398,18 @@ public abstract class VectorMask<E> extends jdk.internal.vm.vector.VectorSupport
public abstract VectorMask<E> or(VectorMask<E> m);
/**
* Determines logical equivalence of this mask
* to a second input mask (as boolean {@code a==b}
* or {@code a^~b}).
* Determines logical symmetric difference
* (as {@code a^b}) of this mask and a second input mask.
* <p>
* This is a lane-wise binary operation tests each
* corresponding pair of mask bits for equality.
* It is also equivalent to a inverse {@code XOR}
* operation ({@code ^~}) on the mask bits.
* This is a lane-wise binary operation which applies
* the logical {@code XOR} operation
* ({@code ^}) to each corresponding pair of mask bits.
*
* @param m the input mask
* @return a mask showing where the two input masks were equal
* @see #equals
* @return the result of logically disjunctively disjoining the two
* input masks
*/
public abstract VectorMask<E> eq(VectorMask<E> m);
public abstract VectorMask<E> xor(VectorMask<E> m);
/**
* Logically subtracts a second input mask
@ -426,6 +424,23 @@ public abstract class VectorMask<E> extends jdk.internal.vm.vector.VectorSupport
*/
public abstract VectorMask<E> andNot(VectorMask<E> m);
/**
* Determines logical equivalence of this mask
* to a second input mask (as boolean {@code a==b}
* or {@code a^~b}).
* <p>
* This is a lane-wise binary operation tests each
* corresponding pair of mask bits for equality.
* It is also equivalent to the logical {@code XNOR}
* operation ({@code ^~}) to each corresponding pair
* of mask bits.
*
* @param m the input mask
* @return a mask showing where the two input masks were equal
* @see #equals
*/
public abstract VectorMask<E> eq(VectorMask<E> m);
/**
* Logically negates this mask.
* <p>

@ -920,14 +920,6 @@ final class $vectortype$ extends $abstractvectortype$ {
(m, s) -> s.maskFactory(m.toArray()).check(s));
}
@Override
@ForceInline
public $masktype$ eq(VectorMask<$Boxtype$> mask) {
Objects.requireNonNull(mask);
$masktype$ m = ($masktype$)mask;
return xor(m.not());
}
@Override
@ForceInline
/*package-private*/
@ -976,9 +968,9 @@ final class $vectortype$ extends $abstractvectortype$ {
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
}
@Override
@ForceInline
/* package-private */
$masktype$ xor(VectorMask<$Boxtype$> mask) {
public $masktype$ xor(VectorMask<$Boxtype$> mask) {
Objects.requireNonNull(mask);
$masktype$ m = ($masktype$)mask;
return VectorSupport.binaryOp(VECTOR_OP_XOR, $masktype$.class, null, $bitstype$.class, VLENGTH,

@ -5849,6 +5849,82 @@ public class Byte128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndByte128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrByte128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorByte128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotByte128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5849,6 +5849,82 @@ public class Byte256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5849,6 +5849,82 @@ public class Byte512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndByte512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrByte512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorByte512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotByte512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5849,6 +5849,82 @@ public class Byte64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndByte64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrByte64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorByte64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotByte64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5854,6 +5854,82 @@ public class ByteMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ByteMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ByteMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ByteMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ByteMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4880,6 +4880,82 @@ public class Double128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndDouble128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrDouble128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorDouble128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotDouble128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4880,6 +4880,82 @@ public class Double256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4880,6 +4880,82 @@ public class Double512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndDouble512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrDouble512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorDouble512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotDouble512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4880,6 +4880,82 @@ public class Double64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndDouble64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrDouble64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorDouble64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotDouble64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Double64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4885,6 +4885,82 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, DoubleMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4859,6 +4859,82 @@ public class Float128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndFloat128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrFloat128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorFloat128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotFloat128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4859,6 +4859,82 @@ public class Float256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndFloat256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrFloat256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorFloat256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotFloat256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4859,6 +4859,82 @@ public class Float512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndFloat512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrFloat512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorFloat512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotFloat512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4859,6 +4859,82 @@ public class Float64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndFloat64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrFloat64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorFloat64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotFloat64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Float64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -4864,6 +4864,82 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndFloatMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, FloatMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrFloatMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, FloatMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorFloatMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, FloatMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotFloatMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, FloatMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5882,6 +5882,82 @@ public class Int128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5882,6 +5882,82 @@ public class Int256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5882,6 +5882,82 @@ public class Int512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndInt512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrInt512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorInt512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotInt512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5882,6 +5882,82 @@ public class Int64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Int64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5887,6 +5887,82 @@ public class IntMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, IntMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, IntMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, IntMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, IntMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5768,6 +5768,82 @@ public class Long128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndLong128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrLong128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorLong128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotLong128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5768,6 +5768,82 @@ public class Long256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5768,6 +5768,82 @@ public class Long512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5768,6 +5768,82 @@ public class Long64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndLong64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrLong64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorLong64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotLong64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Long64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5773,6 +5773,82 @@ public class LongMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndLongMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, LongMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrLongMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, LongMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorLongMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, LongMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotLongMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, LongMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5829,6 +5829,82 @@ public class Short128VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndShort128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short128VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrShort128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short128VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorShort128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short128VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotShort128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short128VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5829,6 +5829,82 @@ public class Short256VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndShort256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short256VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrShort256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short256VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorShort256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short256VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotShort256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short256VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5829,6 +5829,82 @@ public class Short512VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short512VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short512VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short512VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short512VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5829,6 +5829,82 @@ public class Short64VectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndShort64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short64VectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrShort64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short64VectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorShort64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short64VectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotShort64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Short64VectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -5834,6 +5834,82 @@ public class ShortMaxVectorTests extends AbstractVectorTest {
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ShortMaxVectorTests::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOrShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ShortMaxVectorTests::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXorShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ShortMaxVectorTests::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNotShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, ShortMaxVectorTests::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}

@ -378,6 +378,82 @@
}
}
static boolean band(boolean a, boolean b) {
return a & b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAnd$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.and(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, $vectorteststype$::band);
}
static boolean bor(boolean a, boolean b) {
return a | b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskOr$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.or(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, $vectorteststype$::bor);
}
static boolean bxor(boolean a, boolean b) {
return a != b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskXor$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.xor(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, $vectorteststype$::bxor);
}
static boolean bandNot(boolean a, boolean b) {
return a & !b;
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskAndNot$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.andNot(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, $vectorteststype$::bandNot);
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}