8338023: Support two vector selectFrom API

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java

@@ -536,6 +536,19 @@ static ByteVector compressHelper(Vector<Byte> v, VectorMask<Byte> m) {
         return r;
     }
 
+    static ByteVector selectFromHelper(Vector<Byte> v1, Vector<Byte> v2, Vector<Byte> v3) {
+        int vlen = v1.length();
+        byte[] res = new byte[vlen];
+        byte[] vpayload1 = ((ByteVector)v1).vec();
+        byte[] vpayload2 = ((ByteVector)v2).vec();
+        byte[] vpayload3 = ((ByteVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((ByteVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2582,9 +2595,7 @@ final ByteVector selectFromTemplate(ByteVector v1, ByteVector v2) {
         int twovectorlen = length() * 2;
         ByteVector wrapped_indexes = this.lanewise(VectorOperators.AND, twovectorlen - 1);
         return (ByteVector)VectorSupport.selectFromTwoVectorOp(getClass(), byte.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java

@@ -525,6 +525,19 @@ static DoubleVector compressHelper(Vector<Double> v, VectorMask<Double> m) {
         return r;
     }
 
+    static DoubleVector selectFromHelper(Vector<Double> v1, Vector<Double> v2, Vector<Double> v3) {
+        int vlen = v1.length();
+        double[] res = new double[vlen];
+        double[] vpayload1 = ((DoubleVector)v1).vec();
+        double[] vpayload2 = ((DoubleVector)v2).vec();
+        double[] vpayload3 = ((DoubleVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((DoubleVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2428,9 +2441,7 @@ final DoubleVector selectFromTemplate(DoubleVector v1, DoubleVector v2) {
                                                .convert(VectorOperators.I2D, 0)
                                                .reinterpretAsDoubles();
         return (DoubleVector)VectorSupport.selectFromTwoVectorOp(getClass(), double.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java

@@ -525,6 +525,19 @@ static FloatVector compressHelper(Vector<Float> v, VectorMask<Float> m) {
         return r;
     }
 
+    static FloatVector selectFromHelper(Vector<Float> v1, Vector<Float> v2, Vector<Float> v3) {
+        int vlen = v1.length();
+        float[] res = new float[vlen];
+        float[] vpayload1 = ((FloatVector)v1).vec();
+        float[] vpayload2 = ((FloatVector)v2).vec();
+        float[] vpayload3 = ((FloatVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((FloatVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2440,9 +2453,7 @@ final FloatVector selectFromTemplate(FloatVector v1, FloatVector v2) {
                                                .convert(VectorOperators.I2F, 0)
                                                .reinterpretAsFloats();
         return (FloatVector)VectorSupport.selectFromTwoVectorOp(getClass(), float.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java

@@ -536,6 +536,19 @@ static IntVector compressHelper(Vector<Integer> v, VectorMask<Integer> m) {
         return r;
     }
 
+    static IntVector selectFromHelper(Vector<Integer> v1, Vector<Integer> v2, Vector<Integer> v3) {
+        int vlen = v1.length();
+        int[] res = new int[vlen];
+        int[] vpayload1 = ((IntVector)v1).vec();
+        int[] vpayload2 = ((IntVector)v2).vec();
+        int[] vpayload3 = ((IntVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((IntVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2567,9 +2580,7 @@ final IntVector selectFromTemplate(IntVector v1, IntVector v2) {
         int twovectorlen = length() * 2;
         IntVector wrapped_indexes = this.lanewise(VectorOperators.AND, twovectorlen - 1);
         return (IntVector)VectorSupport.selectFromTwoVectorOp(getClass(), int.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java

@@ -536,6 +536,19 @@ static LongVector compressHelper(Vector<Long> v, VectorMask<Long> m) {
         return r;
     }
 
+    static LongVector selectFromHelper(Vector<Long> v1, Vector<Long> v2, Vector<Long> v3) {
+        int vlen = v1.length();
+        long[] res = new long[vlen];
+        long[] vpayload1 = ((LongVector)v1).vec();
+        long[] vpayload2 = ((LongVector)v2).vec();
+        long[] vpayload3 = ((LongVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((LongVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2433,9 +2446,7 @@ final LongVector selectFromTemplate(LongVector v1, LongVector v2) {
         int twovectorlen = length() * 2;
         LongVector wrapped_indexes = this.lanewise(VectorOperators.AND, twovectorlen - 1);
         return (LongVector)VectorSupport.selectFromTwoVectorOp(getClass(), long.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java

@@ -536,6 +536,19 @@ static ShortVector compressHelper(Vector<Short> v, VectorMask<Short> m) {
         return r;
     }
 
+    static ShortVector selectFromHelper(Vector<Short> v1, Vector<Short> v2, Vector<Short> v3) {
+        int vlen = v1.length();
+        short[] res = new short[vlen];
+        short[] vpayload1 = ((ShortVector)v1).vec();
+        short[] vpayload2 = ((ShortVector)v2).vec();
+        short[] vpayload3 = ((ShortVector)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return ((ShortVector)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2583,9 +2596,7 @@ final ShortVector selectFromTemplate(ShortVector v1, ShortVector v2) {
         int twovectorlen = length() * 2;
         ShortVector wrapped_indexes = this.lanewise(VectorOperators.AND, twovectorlen - 1);
         return (ShortVector)VectorSupport.selectFromTwoVectorOp(getClass(), short.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }
 

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template

@@ -550,6 +550,19 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> {
         return r;
     }
 
+    static $abstractvectortype$ selectFromHelper(Vector<$Boxtype$> v1, Vector<$Boxtype$> v2, Vector<$Boxtype$> v3) {
+        int vlen = v1.length();
+        $type$[] res = new $type$[vlen];
+        $type$[] vpayload1 = (($abstractvectortype$)v1).vec();
+        $type$[] vpayload2 = (($abstractvectortype$)v2).vec();
+        $type$[] vpayload3 = (($abstractvectortype$)v3).vec();
+        for (int i = 0; i < vlen; i++) {
+            int index = ((int)vpayload1[i]);
+            res[i] = index >= vlen ? vpayload3[index & (vlen - 1)] : vpayload2[index];
+        }
+        return (($abstractvectortype$)v1).vectorFactory(res);
+    }
+
     // Static factories (other than memory operations)
 
     // Note: A surprising behavior in javadoc
@@ -2975,9 +2988,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> {
         $abstractvectortype$ wrapped_indexes = this.lanewise(VectorOperators.AND, twovectorlen - 1);
 #end[FP]
         return ($Type$Vector)VectorSupport.selectFromTwoVectorOp(getClass(), $type$.class, length(), wrapped_indexes, v1, v2,
-            (vec1, vec2, vec3) -> {
-                return vec2.rearrange(vec1.toShuffle(), vec3);
-            }
+            (vec1, vec2, vec3) -> selectFromHelper(vec1, vec2, vec3)
         );
     }