< prev index next >

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

Print this page
rev 54658 : refactored mask and shuffle creation methods, moved classes to top-level

@@ -85,18 +85,18 @@
     static final int BT_overflow = 2;
     static final int BT_no_overflow = 6;
 
     /* ============================================================================ */
     interface BroadcastOperation<V, E> {
-        V broadcast(long l, Vector.Species<E> s);
+        V broadcast(long l, VectorSpecies<E> s);
     }
 
     @HotSpotIntrinsicCandidate
     static
     <VM, E>
     VM broadcastCoerced(Class<VM> vmClass, Class<?> E, int length,
-                                  long bits, Vector.Species<E> s,
+                                  long bits, VectorSpecies<E> s,
                                   BroadcastOperation<VM, E> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.broadcast(bits, s);
     }
 

@@ -147,11 +147,11 @@
 
     @HotSpotIntrinsicCandidate
     static
     <VM>
     VM unaryOp(int oprId, Class<VM> vmClass, Class<?> elementType, int length,
-               VM vm, /*Vector.Mask<E,S> m,*/
+               VM vm,
                Function<VM, VM> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(vm);
     }
 

@@ -159,11 +159,11 @@
 
     @HotSpotIntrinsicCandidate
     static
     <VM>
     VM binaryOp(int oprId, Class<? extends VM> vmClass, Class<?> elementType, int length,
-                VM vm1, VM vm2, /*Vector.Mask<E,S> m,*/
+                VM vm1, VM vm2,
                 BiFunction<VM, VM, VM> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(vm1, vm2);
     }
 

@@ -175,49 +175,48 @@
 
     @HotSpotIntrinsicCandidate
     static
     <VM>
     VM ternaryOp(int oprId, Class<VM> vmClass, Class<?> elementType, int length,
-                 VM vm1, VM vm2, VM vm3, /*Vector.Mask<E,S> m,*/
+                 VM vm1, VM vm2, VM vm3,
                  TernaryOperation<VM> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(vm1, vm2, vm3);
     }
 
     /* ============================================================================ */
 
     // Memory operations
 
     interface LoadOperation<C, V, E> {
-        V load(C container, int index, Vector.Species<E> s);
+        V load(C container, int index, VectorSpecies<E> s);
     }
 
     @HotSpotIntrinsicCandidate
     static
     <C, VM, E>
     VM load(Class<VM> vmClass, Class<?> E, int length,
            Object base, long offset,    // Unsafe addressing
-           // Vector.Mask<E,S> m,
-           C container, int index, Vector.Species<E> s,     // Arguments for default implementation
+           C container, int index, VectorSpecies<E> s,     // Arguments for default implementation
            LoadOperation<C, VM, E> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.load(container, index, s);
     }
 
     /* ============================================================================ */
 
     interface LoadVectorOperationWithMap<C, V extends Vector<?>, E> {
-        V loadWithMap(C container, int index, int[] indexMap, int indexM, Vector.Species<E> s);
+        V loadWithMap(C container, int index, int[] indexMap, int indexM, VectorSpecies<E> s);
     }
 
     @HotSpotIntrinsicCandidate
     static
     <C, V extends Vector<?>, W extends IntVector, E>
     V loadWithMap(Class<?> vectorClass, Class<?> E, int length, Class<?> vectorIndexClass,
                   Object base, long offset, // Unsafe addressing
                   W index_vector,
-                  C container, int index, int[] indexMap, int indexM, Vector.Species<E> s, // Arguments for default implementation
+                  C container, int index, int[] indexMap, int indexM, VectorSpecies<E> s, // Arguments for default implementation
                   LoadVectorOperationWithMap<C, V, E> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.loadWithMap(container, index, indexMap, indexM, s);
     }
 

@@ -231,11 +230,10 @@
     static
     <C, V extends Vector<?>>
     void store(Class<?> vectorClass, Class<?> elementType, int length,
                Object base, long offset,    // Unsafe addressing
                V v,
-               // Vector.Mask<E,S> m,
                C container, int index,      // Arguments for default implementation
                StoreVectorOperation<C, V> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         defaultImpl.store(container, index, v);
     }

@@ -276,11 +274,11 @@
         M apply(V v1, V v2);
     }
 
     @HotSpotIntrinsicCandidate
     static <V extends Vector<E>,
-            M extends Vector.Mask<E>,
+            M extends VectorMask<E>,
             E>
     M compare(int cond, Class<V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
               V v1, V v2,
               VectorCompareOp<V,M> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;

@@ -288,19 +286,19 @@
     }
 
     /* ============================================================================ */
 
     interface VectorRearrangeOp<V extends Vector<E>,
-            Sh extends Vector.Shuffle<E>,
+            Sh extends VectorShuffle<E>,
             E> {
         V apply(V v1, Sh shuffle);
     }
 
     @HotSpotIntrinsicCandidate
     static
     <V extends Vector<E>,
-            Sh extends Vector.Shuffle<E>,
+            Sh extends VectorShuffle<E>,
             E>
     V rearrangeOp(Class<V> vectorClass, Class<Sh> shuffleClass, Class<?> elementType, int vlen,
             V v1, Sh sh,
             VectorRearrangeOp<V,Sh, E> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;

@@ -308,19 +306,19 @@
     }
 
     /* ============================================================================ */
 
     interface VectorBlendOp<V extends Vector<E>,
-            M extends Vector.Mask<E>,
+            M extends VectorMask<E>,
             E> {
         V apply(V v1, V v2, M mask);
     }
 
     @HotSpotIntrinsicCandidate
     static
     <V extends Vector<E>,
-     M extends Vector.Mask<E>,
+     M extends VectorMask<E>,
      E>
     V blend(Class<V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
             V v1, V v2, M m,
             VectorBlendOp<V,M, E> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
< prev index next >