< prev index next >

src/java.base/share/classes/jdk/internal/vm/vector/VectorSupport.java

Print this page
*** 67,14 ***
  
      // Mask manipulation operations
      public static final int VECTOR_OP_MASK_TRUECOUNT = 19;
      public static final int VECTOR_OP_MASK_FIRSTTRUE = 20;
      public static final int VECTOR_OP_MASK_LASTTRUE  = 21;
  
      // Rotate operations
!     public static final int VECTOR_OP_LROTATE = 22;
!     public static final int VECTOR_OP_RROTATE = 23;
  
      // Math routines
      public static final int VECTOR_OP_TAN = 101;
      public static final int VECTOR_OP_TANH = 102;
      public static final int VECTOR_OP_SIN = 103;
--- 67,15 ---
  
      // Mask manipulation operations
      public static final int VECTOR_OP_MASK_TRUECOUNT = 19;
      public static final int VECTOR_OP_MASK_FIRSTTRUE = 20;
      public static final int VECTOR_OP_MASK_LASTTRUE  = 21;
+     public static final int VECTOR_OP_MASK_TOLONG    = 22;
  
      // Rotate operations
!     public static final int VECTOR_OP_LROTATE = 23;
!     public static final int VECTOR_OP_RROTATE = 24;
  
      // Math routines
      public static final int VECTOR_OP_TAN = 101;
      public static final int VECTOR_OP_TANH = 102;
      public static final int VECTOR_OP_SIN = 103;

*** 154,312 ***
              super(payload);
          }
      }
  
      /* ============================================================================ */
!     public interface BroadcastOperation<VM, E, S extends VectorSpecies<E>> {
          VM broadcast(long l, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <VM, E, S extends VectorSpecies<E>>
!     VM broadcastCoerced(Class<? extends VM> vmClass, Class<E> E, int length,
!                                   long bits, S s,
!                                   BroadcastOperation<VM, E, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.broadcast(bits, s);
      }
  
      /* ============================================================================ */
!     public interface ShuffleIotaOperation<E, S extends VectorSpecies<E>> {
!         VectorShuffle<E> apply(int length, int start, int step, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <E, S extends VectorSpecies<E>>
!     VectorShuffle<E> shuffleIota(Class<?> E, Class<?> ShuffleClass, S s, int length,
!                      int start, int step, int wrap, ShuffleIotaOperation<E, S> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(length, start, step, s);
      }
  
!     public interface ShuffleToVectorOperation<VM, Sh, E> {
!        VM apply(Sh s);
      }
  
      @IntrinsicCandidate
      public static
!     <VM ,Sh extends VectorShuffle<E>, E>
!     VM shuffleToVector(Class<?> VM, Class<?>E , Class<?> ShuffleClass, Sh s, int length,
!                        ShuffleToVectorOperation<VM,Sh,E> defaultImpl) {
        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!       return defaultImpl.apply(s);
      }
  
      /* ============================================================================ */
!     public interface IndexOperation<V extends Vector<E>, E, S extends VectorSpecies<E>> {
          V index(V v, int step, S s);
      }
  
      //FIXME @IntrinsicCandidate
      public static
!     <V extends Vector<E>, E, S extends VectorSpecies<E>>
!     V indexVector(Class<? extends V> vClass, Class<E> E, int length,
                    V v, int step, S s,
!                   IndexOperation<V, E, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.index(v, step, s);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<?>>
!     long reductionCoerced(int oprId, Class<?> vectorClass, Class<?> elementType, int length,
!                           V v,
!                           Function<V,Long> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v);
      }
  
      /* ============================================================================ */
  
!     public interface VecExtractOp<V> {
!         long apply(V v1, int idx);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<?>>
!     long extract(Class<?> vectorClass, Class<?> elementType, int vlen,
!                  V vec, int ix,
                   VecExtractOp<V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vec, ix);
      }
  
      /* ============================================================================ */
  
!     public interface VecInsertOp<V> {
!         V apply(V v1, int idx, long val);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<?>>
!     V insert(Class<? extends V> vectorClass, Class<?> elementType, int vlen,
!              V vec, int ix, long val,
               VecInsertOp<V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vec, ix, val);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
      public static
!     <VM>
!     VM unaryOp(int oprId, Class<? extends VM> vmClass, Class<?> elementType, int length,
!                VM vm,
!                Function<VM, VM> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vm);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
      public static
!     <VM>
!     VM binaryOp(int oprId, Class<? extends VM> vmClass, Class<?> elementType, int length,
!                 VM vm1, VM vm2,
!                 BiFunction<VM, VM, VM> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vm1, vm2);
      }
  
      /* ============================================================================ */
  
!     public interface TernaryOperation<V> {
!         V apply(V v1, V v2, V v3);
      }
  
      @IntrinsicCandidate
      public static
!     <VM>
!     VM ternaryOp(int oprId, Class<? extends VM> vmClass, Class<?> elementType, int length,
!                  VM vm1, VM vm2, VM vm3,
!                  TernaryOperation<VM> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vm1, vm2, vm3);
      }
  
      /* ============================================================================ */
  
      // Memory operations
  
!     public interface LoadOperation<C, V, E, S extends VectorSpecies<E>> {
!         V load(C container, int index, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <C, VM, E, S extends VectorSpecies<E>>
!     VM load(Class<? extends VM> vmClass, Class<E> E, int length,
!            Object base, long offset,    // Unsafe addressing
!            C container, int index, S s,     // Arguments for default implementation
!            LoadOperation<C, VM, E, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.load(container, index, s);
      }
  
      /* ============================================================================ */
  
!     public interface LoadVectorOperationWithMap<C, V extends Vector<?>, E, S extends VectorSpecies<E>> {
!         V loadWithMap(C container, int index, int[] indexMap, int indexM, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <C, V extends Vector<?>, W extends Vector<Integer>, E, S extends VectorSpecies<E>>
!     V loadWithMap(Class<?> vectorClass, Class<E> E, int length, Class<?> vectorIndexClass,
!                   Object base, long offset, // Unsafe addressing
                    W index_vector,
!                   C container, int index, int[] indexMap, int indexM, S s, // Arguments for default implementation
!                   LoadVectorOperationWithMap<C, V, E, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.loadWithMap(container, index, indexMap, indexM, s);
      }
  
      /* ============================================================================ */
  
!     public interface StoreVectorOperation<C, V extends Vector<?>> {
          void store(C container, int index, V v);
      }
  
      @IntrinsicCandidate
      public static
!     <C, V extends Vector<?>>
!     void store(Class<?> vectorClass, Class<?> elementType, int length,
!                Object base, long offset,    // Unsafe addressing
!                V v,
!                C container, int index,      // Arguments for default implementation
                 StoreVectorOperation<C, V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          defaultImpl.store(container, index, v);
      }
  
      /* ============================================================================ */
  
!     public interface StoreVectorOperationWithMap<C, V extends Vector<?>> {
!         void storeWithMap(C container, int index, V v, int[] indexMap, int indexM);
      }
  
      @IntrinsicCandidate
      public static
!     <C, V extends Vector<?>, W extends Vector<Integer>>
!     void storeWithMap(Class<?> vectorClass, Class<?> elementType, int length, Class<?> vectorIndexClass,
!                       Object base, long offset,    // Unsafe addressing
!                       W index_vector, V v,
!                       C container, int index, int[] indexMap, int indexM, // Arguments for default implementation
!                       StoreVectorOperationWithMap<C, V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         defaultImpl.storeWithMap(container, index, v, indexMap, indexM);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
      public static
!     <VM>
!     boolean test(int cond, Class<?> vmClass, Class<?> elementType, int length,
!                  VM vm1, VM vm2,
!                  BiFunction<VM, VM, Boolean> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(vm1, vm2);
      }
  
      /* ============================================================================ */
  
!     public interface VectorCompareOp<V,M> {
!         M apply(int cond, V v1, V v2);
      }
  
      @IntrinsicCandidate
!     public static <V extends Vector<E>,
!                    M extends VectorMask<E>,
!                    E>
!     M compare(int cond, Class<? extends V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
!               V v1, V v2,
!               VectorCompareOp<V,M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(cond, v1, v2);
      }
  
      /* ============================================================================ */
! 
!     public interface VectorRearrangeOp<V extends Vector<E>,
!             Sh extends VectorShuffle<E>,
!             E> {
-         V apply(V v1, Sh shuffle);
      }
  
      @IntrinsicCandidate
      public static
      <V extends Vector<E>,
!             Sh extends VectorShuffle<E>,
!             E>
!     V rearrangeOp(Class<? extends V> vectorClass, Class<Sh> shuffleClass, Class<?> elementType, int vlen,
!                   V v1, Sh sh,
!                   VectorRearrangeOp<V,Sh, E> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v1, sh);
      }
  
      /* ============================================================================ */
  
!     public interface VectorBlendOp<V extends Vector<E>,
!             M extends VectorMask<E>,
!             E> {
-         V apply(V v1, V v2, M mask);
      }
  
      @IntrinsicCandidate
      public static
      <V extends Vector<E>,
       M extends VectorMask<E>,
       E>
!     V blend(Class<? extends V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
              V v1, V v2, M m,
!             VectorBlendOp<V,M, E> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.apply(v1, v2, m);
      }
  
      /* ============================================================================ */
  
!     public interface VectorBroadcastIntOp<V extends Vector<?>> {
!         V apply(V v, int n);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<?>>
!     V broadcastInt(int opr, Class<? extends V> vectorClass, Class<?> elementType, int length,
!                    V v, int n,
!                    VectorBroadcastIntOp<V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, n);
      }
  
      /* ============================================================================ */
  
!     public interface VectorConvertOp<VOUT, VIN, S> {
!         VOUT apply(VIN v, S species);
      }
  
      // Users of this intrinsic assume that it respects
      // REGISTER_ENDIAN, which is currently ByteOrder.LITTLE_ENDIAN.
      // See javadoc for REGISTER_ENDIAN.
--- 155,453 ---
              super(payload);
          }
      }
  
      /* ============================================================================ */
!     public interface BroadcastOperation<VM extends VectorPayload,
+                                         S extends VectorSpecies<?>> {
          VM broadcast(long l, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <VM extends VectorPayload,
!      S extends VectorSpecies<E>,
!      E>
!     VM broadcastCoerced(Class<? extends VM> vmClass, Class<E> eClass,
+                         int length,
+                         long bits, S s,
+                         BroadcastOperation<VM, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.broadcast(bits, s);
      }
  
      /* ============================================================================ */
!     public interface ShuffleIotaOperation<S extends VectorSpecies<?>,
!                                           SH extends VectorShuffle<?>> {
+         SH apply(int length, int start, int step, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <E,
!      S extends VectorSpecies<E>,
!      SH extends VectorShuffle<E>>
+     SH shuffleIota(Class<E> eClass, Class<? extends SH> shClass, S s,
+                    int length,
+                    int start, int step, int wrap,
+                    ShuffleIotaOperation<S, SH> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(length, start, step, s);
      }
  
!     public interface ShuffleToVectorOperation<V extends Vector<?>,
!                                               SH extends VectorShuffle<?>> {
+        V apply(SH sh);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      SH extends VectorShuffle<E>,
!      E>
+     V shuffleToVector(Class<? extends Vector<E>> vClass, Class<E> eClass, Class<? extends SH> shClass, SH sh,
+                       int length,
+                       ShuffleToVectorOperation<V, SH> defaultImpl) {
        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!       return defaultImpl.apply(sh);
      }
  
      /* ============================================================================ */
!     public interface IndexOperation<V extends Vector<?>,
+                                     S extends VectorSpecies<?>> {
          V index(V v, int step, S s);
      }
  
      //FIXME @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      E,
+      S extends VectorSpecies<E>>
+     V indexVector(Class<? extends V> vClass, Class<E> eClass,
+                   int length,
                    V v, int step, S s,
!                   IndexOperation<V, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.index(v, step, s);
      }
  
      /* ============================================================================ */
  
+     public interface ReductionOperation<V extends Vector<?>,
+                                         M extends VectorMask<?>> {
+         long apply(V v, M m);
+     }
+ 
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      M extends VectorMask<E>,
!      E>
!     long reductionCoerced(int oprId,
+                           Class<? extends V> vClass, Class<? extends M> mClass, Class<E> eClass,
+                           int length,
+                           V v, M m,
+                           ReductionOperation<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, m);
      }
  
+ 
      /* ============================================================================ */
  
!     public interface VecExtractOp<V extends Vector<?>> {
!         long apply(V v, int i);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      E>
!     long extract(Class<? extends V> vClass, Class<E> eClass,
+                  int length,
+                  V v, int i,
                   VecExtractOp<V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, i);
      }
  
      /* ============================================================================ */
  
!     public interface VecInsertOp<V extends Vector<?>> {
!         V apply(V v, int i, long val);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      E>
!     V insert(Class<? extends V> vClass, Class<E> eClass,
+              int length,
+              V v, int i, long val,
               VecInsertOp<V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, i, val);
      }
  
      /* ============================================================================ */
  
+     public interface UnaryOperation<V extends Vector<?>,
+                                     M extends VectorMask<?>> {
+         V apply(V v, M m);
+     }
+ 
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      M extends VectorMask<E>,
!      E>
!     V unaryOp(int oprId,
+               Class<? extends V> vClass, Class<? extends M> mClass, Class<E> eClass,
+               int length,
+               V v, M m,
+               UnaryOperation<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, m);
      }
  
      /* ============================================================================ */
  
+     public interface BinaryOperation<VM extends VectorPayload,
+                                      M extends VectorMask<?>> {
+         VM apply(VM v1, VM v2, M m);
+     }
+ 
      @IntrinsicCandidate
      public static
!     <VM extends VectorPayload,
!      M extends VectorMask<E>,
!      E>
!     VM binaryOp(int oprId,
+                 Class<? extends VM> vmClass, Class<? extends M> mClass, Class<E> eClass,
+                 int length,
+                 VM v1, VM v2, M m,
+                 BinaryOperation<VM, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v1, v2, m);
      }
  
      /* ============================================================================ */
  
!     public interface TernaryOperation<V extends Vector<?>,
!                                       M extends VectorMask<?>> {
+         V apply(V v1, V v2, V v3, M m);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      M extends VectorMask<E>,
!      E>
!     V ternaryOp(int oprId,
+                 Class<? extends V> vClass, Class<? extends M> mClass, Class<E> eClass,
+                 int length,
+                 V v1, V v2, V v3, M m,
+                 TernaryOperation<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v1, v2, v3, m);
      }
  
      /* ============================================================================ */
  
      // Memory operations
  
!     public interface LoadOperation<C,
!                                    VM extends VectorPayload,
+                                    S extends VectorSpecies<?>> {
+         VM load(C container, int index, S s);
      }
  
      @IntrinsicCandidate
      public static
!     <C,
!      VM extends VectorPayload,
!      E,
!      S extends VectorSpecies<E>>
!     VM load(Class<? extends VM> vmClass, Class<E> eClass,
+             int length,
+             Object base, long offset,
+             C container, int index, S s,
+             LoadOperation<C, VM, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.load(container, index, s);
      }
  
      /* ============================================================================ */
  
!     public interface LoadVectorMaskedOperation<C,
!                                                V extends Vector<?>,
+                                                S extends VectorSpecies<?>,
+                                                M extends VectorMask<?>> {
+         V load(C container, int index, S s, M m);
      }
  
      @IntrinsicCandidate
      public static
!     <C,
!      V extends Vector<?>,
!      E,
+      S extends VectorSpecies<E>,
+      M extends VectorMask<E>>
+     V loadMasked(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
+                  int length,
+                  Object base, long offset,
+                  M m, C container, int index, S s,
+                  LoadVectorMaskedOperation<C, V, S, M> defaultImpl) {
+         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+         return defaultImpl.load(container, index, s, m);
+     }
+ 
+     /* ============================================================================ */
+ 
+     public interface LoadVectorOperationWithMap<C,
+                                                 V extends Vector<?>,
+                                                 S extends VectorSpecies<?>,
+                                                 M extends VectorMask<?>> {
+         V loadWithMap(C container, int index, int[] indexMap, int indexM, S s, M m);
+     }
+ 
+     @IntrinsicCandidate
+     public static
+     <C,
+      V extends Vector<?>,
+      W extends Vector<Integer>,
+      S extends VectorSpecies<E>,
+      M extends VectorMask<E>,
+      E>
+     V loadWithMap(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
+                   int length,
+                   Class<? extends Vector<Integer>> vectorIndexClass,
+                   Object base, long offset,
                    W index_vector,
!                   M m, C container, int index, int[] indexMap, int indexM, S s,
!                   LoadVectorOperationWithMap<C, V, S, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.loadWithMap(container, index, indexMap, indexM, s, m);
      }
  
      /* ============================================================================ */
  
!     public interface StoreVectorOperation<C,
+                                           V extends Vector<?>> {
          void store(C container, int index, V v);
      }
  
      @IntrinsicCandidate
      public static
!     <C,
!      V extends Vector<?>>
!     void store(Class<?> vClass, Class<?> eClass,
!                int length,
!                Object base, long offset,
+                V v, C container, int index,
                 StoreVectorOperation<C, V> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          defaultImpl.store(container, index, v);
      }
  
+     public interface StoreVectorMaskedOperation<C,
+                                                 V extends Vector<?>,
+                                                 M extends VectorMask<?>> {
+         void store(C container, int index, V v, M m);
+     }
+ 
+     @IntrinsicCandidate
+     public static
+     <C,
+      V extends Vector<E>,
+      M extends VectorMask<E>,
+      E>
+     void storeMasked(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
+                      int length,
+                      Object base, long offset,
+                      V v, M m, C container, int index,
+                      StoreVectorMaskedOperation<C, V, M> defaultImpl) {
+         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+         defaultImpl.store(container, index, v, m);
+     }
+ 
      /* ============================================================================ */
  
!     public interface StoreVectorOperationWithMap<C,
!                                                  V extends Vector<?>,
+                                                  M extends VectorMask<?>> {
+         void storeWithMap(C container, int index, V v, int[] indexMap, int indexM, M m);
      }
  
      @IntrinsicCandidate
      public static
!     <C,
!      V extends Vector<E>,
!      W extends Vector<Integer>,
!      M extends VectorMask<E>,
!      E>
!     void storeWithMap(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
+                       int length,
+                       Class<? extends Vector<Integer>> vectorIndexClass,
+                       Object base, long offset,
+                       W index_vector,
+                       V v, M m, C container, int index, int[] indexMap, int indexM,
+                       StoreVectorOperationWithMap<C, V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         defaultImpl.storeWithMap(container, index, v, indexMap, indexM, m);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
      public static
!     <M extends VectorMask<E>,
!      E>
!     boolean test(int cond,
!                  Class<?> mClass, Class<?> eClass,
+                  int length,
+                  M m1, M m2,
+                  BiFunction<M, M, Boolean> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(m1, m2);
      }
  
      /* ============================================================================ */
  
!     public interface VectorCompareOp<V extends Vector<?>,
!                                      M extends VectorMask<?>> {
+         M apply(int cond, V v1, V v2, M m);
      }
  
      @IntrinsicCandidate
!     public static
!     <V extends Vector<E>,
!      M extends VectorMask<E>,
!      E>
!     M compare(int cond,
!               Class<? extends V> vectorClass, Class<M> mClass, Class<E> eClass,
+               int length,
+               V v1, V v2, M m,
+               VectorCompareOp<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(cond, v1, v2, m);
      }
  
      /* ============================================================================ */
!     public interface VectorRearrangeOp<V extends Vector<?>,
!                                        SH extends VectorShuffle<?>,
!                                        M extends VectorMask<?>> {
!         V apply(V v, SH sh, M m);
      }
  
      @IntrinsicCandidate
      public static
      <V extends Vector<E>,
!      SH extends VectorShuffle<E>,
!      M  extends VectorMask<E>,
!      E>
!     V rearrangeOp(Class<? extends V> vClass, Class<SH> shClass, Class<M> mClass, Class<E> eClass,
!                   int length,
+                   V v, SH sh, M m,
+                   VectorRearrangeOp<V, SH, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, sh, m);
      }
  
      /* ============================================================================ */
  
!     public interface VectorBlendOp<V extends Vector<?>,
!                                    M extends VectorMask<?>> {
!         V apply(V v1, V v2, M m);
      }
  
      @IntrinsicCandidate
      public static
      <V extends Vector<E>,
       M extends VectorMask<E>,
       E>
!     V blend(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
+             int length,
              V v1, V v2, M m,
!             VectorBlendOp<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.apply(v1, v2, m);
      }
  
      /* ============================================================================ */
  
!     public interface VectorBroadcastIntOp<V extends Vector<?>,
!                                           M extends VectorMask<?>> {
+         V apply(V v, int n, M m);
      }
  
      @IntrinsicCandidate
      public static
!     <V extends Vector<E>,
!      M extends VectorMask<E>,
!      E>
!     V broadcastInt(int opr,
+                    Class<? extends V> vClass, Class<? extends M> mClass, Class<E> eClass,
+                    int length,
+                    V v, int n, M m,
+                    VectorBroadcastIntOp<V, M> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
!         return defaultImpl.apply(v, n, m);
      }
  
      /* ============================================================================ */
  
!     public interface VectorConvertOp<VOUT extends VectorPayload,
!                                      VIN extends VectorPayload,
+                                      S extends VectorSpecies<?>> {
+         VOUT apply(VIN v, S s);
      }
  
      // Users of this intrinsic assume that it respects
      // REGISTER_ENDIAN, which is currently ByteOrder.LITTLE_ENDIAN.
      // See javadoc for REGISTER_ENDIAN.

*** 467,38 ***
      @IntrinsicCandidate
      public static <VOUT extends VectorPayload,
                      VIN extends VectorPayload,
                        S extends VectorSpecies<?>>
      VOUT convert(int oprId,
!               Class<?> fromVectorClass, Class<?> fromElementType, int fromVLen,
!               Class<?>   toVectorClass, Class<?>   toElementType, int   toVLen,
                VIN v, S s,
                VectorConvertOp<VOUT, VIN, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.apply(v, s);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
!     public static <V> V maybeRebox(V v) {
          // The fence is added here to avoid memory aliasing problems in C2 between scalar & vector accesses.
          // TODO: move the fence generation into C2. Generate only when reboxing is taking place.
          U.loadFence();
          return v;
      }
  
      /* ============================================================================ */
!     public interface VectorMaskOp<M> {
!         int apply(M m);
      }
  
      @IntrinsicCandidate
      public static
!     <E, M>
!     int maskReductionCoerced(int oper, Class<? extends M> maskClass, Class<?> elemClass, int length, M m,
!                VectorMaskOp<M> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(m);
      }
  
      /* ============================================================================ */
--- 609,44 ---
      @IntrinsicCandidate
      public static <VOUT extends VectorPayload,
                      VIN extends VectorPayload,
                        S extends VectorSpecies<?>>
      VOUT convert(int oprId,
!               Class<?> fromVectorClass, Class<?> fromeClass, int fromVLen,
!               Class<?>   toVectorClass, Class<?>   toeClass, int   toVLen,
                VIN v, S s,
                VectorConvertOp<VOUT, VIN, S> defaultImpl) {
          assert isNonCapturingLambda(defaultImpl) : defaultImpl;
          return defaultImpl.apply(v, s);
      }
  
      /* ============================================================================ */
  
      @IntrinsicCandidate
!     public static
+     <VP extends VectorPayload>
+     VP maybeRebox(VP v) {
          // The fence is added here to avoid memory aliasing problems in C2 between scalar & vector accesses.
          // TODO: move the fence generation into C2. Generate only when reboxing is taking place.
          U.loadFence();
          return v;
      }
  
      /* ============================================================================ */
!     public interface VectorMaskOp<M extends VectorMask<?>> {
!         long apply(M m);
      }
  
      @IntrinsicCandidate
      public static
!     <M extends VectorMask<E>,
!      E>
!     long maskReductionCoerced(int oper,
+                               Class<? extends M> mClass, Class<?> eClass,
+                               int length,
+                               M m,
+                               VectorMaskOp<M> defaultImpl) {
         assert isNonCapturingLambda(defaultImpl) : defaultImpl;
         return defaultImpl.apply(m);
      }
  
      /* ============================================================================ */
< prev index next >