changeset 58870:3b869865b8ed vectorIntrinsics

Summary: Removed subAll() and few javadoc changes
author kkharbas
date Tue, 19 Mar 2019 13:23:31 -0700
parents 0a204f4fb3d4
children 01bb6f53b843 39a4aa9406e8
files src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVectorHelper.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Vector.java src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorHelper.java.template src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh test/jdk/jdk/incubator/vector/Byte128VectorTests.java test/jdk/jdk/incubator/vector/Byte256VectorTests.java test/jdk/jdk/incubator/vector/Byte512VectorTests.java test/jdk/jdk/incubator/vector/Byte64VectorTests.java test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java test/jdk/jdk/incubator/vector/Double128VectorTests.java test/jdk/jdk/incubator/vector/Double256VectorTests.java test/jdk/jdk/incubator/vector/Double512VectorTests.java test/jdk/jdk/incubator/vector/Double64VectorTests.java test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java test/jdk/jdk/incubator/vector/Float128VectorTests.java test/jdk/jdk/incubator/vector/Float256VectorTests.java test/jdk/jdk/incubator/vector/Float512VectorTests.java test/jdk/jdk/incubator/vector/Float64VectorTests.java test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java test/jdk/jdk/incubator/vector/Int128VectorTests.java test/jdk/jdk/incubator/vector/Int256VectorTests.java test/jdk/jdk/incubator/vector/Int512VectorTests.java test/jdk/jdk/incubator/vector/Int64VectorTests.java test/jdk/jdk/incubator/vector/IntMaxVectorTests.java test/jdk/jdk/incubator/vector/Long128VectorTests.java test/jdk/jdk/incubator/vector/Long256VectorTests.java test/jdk/jdk/incubator/vector/Long512VectorTests.java test/jdk/jdk/incubator/vector/Long64VectorTests.java test/jdk/jdk/incubator/vector/LongMaxVectorTests.java test/jdk/jdk/incubator/vector/Short128VectorTests.java test/jdk/jdk/incubator/vector/Short256VectorTests.java test/jdk/jdk/incubator/vector/Short512VectorTests.java test/jdk/jdk/incubator/vector/Short64VectorTests.java test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteScalar.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleScalar.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatScalar.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntScalar.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongScalar.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short128Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short256Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short512Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short64Vector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortMaxVector.java test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortScalar.java test/jdk/jdk/incubator/vector/gen-template.sh
diffstat 114 files changed, 1113 insertions(+), 4135 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -761,15 +761,6 @@
 
     @Override
     @ForceInline
-    public byte subAll() {
-        return (byte) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Byte128Vector.class, byte.class, LENGTH,
-            this,
-            v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public byte orAll() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte128Vector.class, byte.class, LENGTH,
@@ -807,12 +798,6 @@
 
     @Override
     @ForceInline
-    public byte subAll(Mask<Byte> m) {
-        return blend(SPECIES.broadcast((byte) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public byte mulAll(Mask<Byte> m) {
         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -761,15 +761,6 @@
 
     @Override
     @ForceInline
-    public byte subAll() {
-        return (byte) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Byte256Vector.class, byte.class, LENGTH,
-            this,
-            v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public byte orAll() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte256Vector.class, byte.class, LENGTH,
@@ -807,12 +798,6 @@
 
     @Override
     @ForceInline
-    public byte subAll(Mask<Byte> m) {
-        return blend(SPECIES.broadcast((byte) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public byte mulAll(Mask<Byte> m) {
         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -761,15 +761,6 @@
 
     @Override
     @ForceInline
-    public byte subAll() {
-        return (byte) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Byte512Vector.class, byte.class, LENGTH,
-            this,
-            v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public byte orAll() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte512Vector.class, byte.class, LENGTH,
@@ -807,12 +798,6 @@
 
     @Override
     @ForceInline
-    public byte subAll(Mask<Byte> m) {
-        return blend(SPECIES.broadcast((byte) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public byte mulAll(Mask<Byte> m) {
         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -761,15 +761,6 @@
 
     @Override
     @ForceInline
-    public byte subAll() {
-        return (byte) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Byte64Vector.class, byte.class, LENGTH,
-            this,
-            v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public byte orAll() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte64Vector.class, byte.class, LENGTH,
@@ -807,12 +798,6 @@
 
     @Override
     @ForceInline
-    public byte subAll(Mask<Byte> m) {
-        return blend(SPECIES.broadcast((byte) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public byte mulAll(Mask<Byte> m) {
         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -761,15 +761,6 @@
 
     @Override
     @ForceInline
-    public byte subAll() {
-        return (byte) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, ByteMaxVector.class, byte.class, LENGTH,
-            this,
-            v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public byte orAll() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, ByteMaxVector.class, byte.class, LENGTH,
@@ -807,12 +798,6 @@
 
     @Override
     @ForceInline
-    public byte subAll(Mask<Byte> m) {
-        return blend(SPECIES.broadcast((byte) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public byte mulAll(Mask<Byte> m) {
         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -104,7 +104,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -125,6 +126,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -160,6 +162,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -184,6 +187,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -211,6 +215,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -232,6 +237,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -256,10 +262,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -287,6 +295,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -338,8 +347,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -352,6 +363,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Byte> maskFromValues(ByteSpecies species, boolean... bits) {
         if (species.boxType() == ByteMaxVector.class)
@@ -390,6 +414,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Byte> maskFromArray(ByteSpecies species, boolean[] bits, int ix) {
@@ -401,6 +439,12 @@
                                      (c, idx, s) -> (Mask<Byte>) ((ByteSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Byte> maskAllTrue(ByteSpecies species) {
@@ -409,6 +453,12 @@
                                                  ((z, s) -> trueMask((ByteSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Byte> maskAllFalse(ByteSpecies species) {
@@ -417,6 +467,30 @@
                                                  ((z, s) -> falseMask((ByteSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Byte> shuffle(ByteSpecies species, IntUnaryOperator f) {
         if (species.boxType() == ByteMaxVector.class)
@@ -430,6 +504,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Byte> shuffleIota(ByteSpecies species) {
         if (species.boxType() == ByteMaxVector.class)
@@ -443,6 +530,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Byte> shuffleFromValues(ByteSpecies species, int... ixs) {
         if (species.boxType() == ByteMaxVector.class)
@@ -456,6 +559,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Byte> shuffleFromArray(ByteSpecies species, int[] ixs, int i) {
         if (species.boxType() == ByteMaxVector.class)
@@ -927,7 +1045,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -944,7 +1062,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -965,7 +1083,7 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -983,10 +1101,11 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -1001,7 +1120,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 3 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -1019,7 +1138,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 3 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -1044,7 +1163,6 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
@@ -1065,35 +1183,11 @@
      * and the identity value is {@code 0}.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract byte addAll(Mask<Byte> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract byte subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract byte subAll(Mask<Byte> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
      * This is an associative vector reduction operation where the
@@ -1122,7 +1216,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Byte#MAX_VALUE}.
+     * and the identity value is
+     * {@link Byte#MAX_VALUE}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1134,7 +1229,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Byte#MAX_VALUE}.
+     * and the identity value is
+     * {@link Byte#MAX_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1146,7 +1242,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Byte#MIN_VALUE}.
+     * and the identity value is
+     * {@link Byte#MIN_VALUE}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1158,7 +1255,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Byte#MIN_VALUE}.
+     * and the identity value is
+     * {@link Byte#MIN_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1373,9 +1471,7 @@
     public abstract ByteSpecies species();
 
     /**
-     * A specialized factory for creating {@link ByteVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link ByteVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class ByteSpecies extends Vector.Species<Byte> {
         interface FOp {
@@ -1428,7 +1524,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link (byte)ThreadLocalRandom#nextInt() }
+         * {@code (byte)ThreadLocalRandom#nextInt()}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class ByteVectorHelper {
-
-    private ByteVectorHelper() {}
-
-    public interface BinaryOp {
-        byte apply(int i, byte a, byte b);
-    }
-
-    public interface UnaryOp {
-        byte apply(int i, byte a);
-    }
-
-    public static 
-    ByteVector map(ByteVector va, ByteVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    ByteVector map(ByteVector va, ByteVector vb, Vector.Mask<Byte> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    ByteVector map(ByteVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    ByteVector map(ByteVector va, Vector.Mask<Byte> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    ByteVector div(ByteVector va, ByteVector vb) {
-        return va.bOp(vb, (i, a, b) -> (byte) (a / b));
-    }
-
-    public static 
-    ByteVector div(ByteVector va, ByteVector vb, Vector.Mask<Byte> m) {
-        return va.bOp(vb, m, (i, a, b) -> (byte) (a / b));
-    }
-
-    public static 
-    ByteVector mod(ByteVector va, ByteVector vb) {
-        return va.bOp(vb, (i, a, b) -> (byte) (a % b));
-    }
-
-    public static 
-    ByteVector mod(ByteVector va, ByteVector vb, Vector.Mask<Byte> m) {
-        return va.bOp(vb, m, (i, a, b) -> (byte) (a % b));
-    }
-
-
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public double subAll() {
-        long bits = (long) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Double128Vector.class, double.class, LENGTH,
-                                this,
-                                v -> {
-                                    double r = v.rOp((double) 0, (i, a, b) -> (double) (a - b));
-                                    return (long)Double.doubleToLongBits(r);
-                                });
-        return Double.longBitsToDouble(bits);
-    }
-
-    @Override
-    @ForceInline
     public double mulAll() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double128Vector.class, double.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public double subAll(Mask<Double> m) {
-        return blend(SPECIES.broadcast((double) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public double mulAll(Mask<Double> m) {
         return blend(SPECIES.broadcast((double) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public double subAll() {
-        long bits = (long) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Double256Vector.class, double.class, LENGTH,
-                                this,
-                                v -> {
-                                    double r = v.rOp((double) 0, (i, a, b) -> (double) (a - b));
-                                    return (long)Double.doubleToLongBits(r);
-                                });
-        return Double.longBitsToDouble(bits);
-    }
-
-    @Override
-    @ForceInline
     public double mulAll() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double256Vector.class, double.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public double subAll(Mask<Double> m) {
-        return blend(SPECIES.broadcast((double) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public double mulAll(Mask<Double> m) {
         return blend(SPECIES.broadcast((double) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public double subAll() {
-        long bits = (long) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Double512Vector.class, double.class, LENGTH,
-                                this,
-                                v -> {
-                                    double r = v.rOp((double) 0, (i, a, b) -> (double) (a - b));
-                                    return (long)Double.doubleToLongBits(r);
-                                });
-        return Double.longBitsToDouble(bits);
-    }
-
-    @Override
-    @ForceInline
     public double mulAll() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double512Vector.class, double.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public double subAll(Mask<Double> m) {
-        return blend(SPECIES.broadcast((double) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public double mulAll(Mask<Double> m) {
         return blend(SPECIES.broadcast((double) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -854,19 +854,6 @@
 
     @Override
     @ForceInline
-    public double subAll() {
-        long bits = (long) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Double64Vector.class, double.class, LENGTH,
-                                this,
-                                v -> {
-                                    double r = v.rOp((double) 0, (i, a, b) -> (double) (a - b));
-                                    return (long)Double.doubleToLongBits(r);
-                                });
-        return Double.longBitsToDouble(bits);
-    }
-
-    @Override
-    @ForceInline
     public double mulAll() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double64Vector.class, double.class, LENGTH,
@@ -913,12 +900,6 @@
 
     @Override
     @ForceInline
-    public double subAll(Mask<Double> m) {
-        return blend(SPECIES.broadcast((double) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public double mulAll(Mask<Double> m) {
         return blend(SPECIES.broadcast((double) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public double subAll() {
-        long bits = (long) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, DoubleMaxVector.class, double.class, LENGTH,
-                                this,
-                                v -> {
-                                    double r = v.rOp((double) 0, (i, a, b) -> (double) (a - b));
-                                    return (long)Double.doubleToLongBits(r);
-                                });
-        return Double.longBitsToDouble(bits);
-    }
-
-    @Override
-    @ForceInline
     public double mulAll() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, DoubleMaxVector.class, double.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public double subAll(Mask<Double> m) {
-        return blend(SPECIES.broadcast((double) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public double mulAll(Mask<Double> m) {
         return blend(SPECIES.broadcast((double) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -105,7 +105,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -126,6 +127,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -161,6 +163,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -185,6 +188,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -212,6 +216,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -233,6 +238,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -275,10 +281,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -310,6 +318,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -361,8 +370,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -375,6 +386,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Double> maskFromValues(DoubleSpecies species, boolean... bits) {
         if (species.boxType() == DoubleMaxVector.class)
@@ -413,6 +437,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Double> maskFromArray(DoubleSpecies species, boolean[] bits, int ix) {
@@ -424,6 +462,12 @@
                                      (c, idx, s) -> (Mask<Double>) ((DoubleSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Double> maskAllTrue(DoubleSpecies species) {
@@ -432,6 +476,12 @@
                                                  ((z, s) -> trueMask((DoubleSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Double> maskAllFalse(DoubleSpecies species) {
@@ -440,6 +490,30 @@
                                                  ((z, s) -> falseMask((DoubleSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Double> shuffle(DoubleSpecies species, IntUnaryOperator f) {
         if (species.boxType() == DoubleMaxVector.class)
@@ -453,6 +527,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Double> shuffleIota(DoubleSpecies species) {
         if (species.boxType() == DoubleMaxVector.class)
@@ -466,6 +553,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Double> shuffleFromValues(DoubleSpecies species, int... ixs) {
         if (species.boxType() == DoubleMaxVector.class)
@@ -479,6 +582,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Double> shuffleFromArray(DoubleSpecies species, int[] ixs, int i) {
         if (species.boxType() == DoubleMaxVector.class)
@@ -1640,13 +1758,21 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
-     * This is an associative vector reduction operation where the addition
+     * This is a vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
-     * and the identity value is {@code 0}.
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary for the same input values.
      *
      * @return the addition of all the lane elements of this vector
      */
@@ -1656,45 +1782,38 @@
      * Adds all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
-     * This is an associative vector reduction operation where the addition
+     * This is a vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
-     * and the identity value is {@code 0}.
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract double addAll(Mask<Double> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract double subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract double subAll(Mask<Double> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
-     * This is an associative vector reduction operation where the
+     * This is a vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
-     * and the identity value is {@code 1}.
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @return the multiplication of all the lane elements of this vector
      */
@@ -1704,9 +1823,17 @@
      * Multiplies all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
-     * This is an associative vector reduction operation where the
+     * This is a vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
-     * and the identity value is {@code 1}.
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
@@ -1718,7 +1845,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Double#MAX_VALUE}.
+     * and the identity value is
+     * {@link Double#POSITIVE_INFINITY}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1730,7 +1858,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Double#MAX_VALUE}.
+     * and the identity value is
+     * {@link Double#POSITIVE_INFINITY}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1742,7 +1871,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Double#MIN_VALUE}.
+     * and the identity value is
+     * {@link Double#NEGATIVE_INFINITY}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1754,7 +1884,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Double#MIN_VALUE}.
+     * and the identity value is
+     * {@link Double#NEGATIVE_INFINITY}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1894,9 +2025,7 @@
     public abstract DoubleSpecies species();
 
     /**
-     * A specialized factory for creating {@link DoubleVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link DoubleVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class DoubleSpecies extends Vector.Species<Double> {
         interface FOp {
@@ -1950,7 +2079,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link ThreadLocalRandom#nextDouble }
+         * {@code ThreadLocalRandom#nextDouble}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,215 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class DoubleVectorHelper {
-
-    private DoubleVectorHelper() {}
-
-    public interface BinaryOp {
-        double apply(int i, double a, double b);
-    }
-
-    public interface UnaryOp {
-        double apply(int i, double a);
-    }
-
-    public static 
-    DoubleVector map(DoubleVector va, DoubleVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    DoubleVector map(DoubleVector va, DoubleVector vb, Vector.Mask<Double> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    DoubleVector map(DoubleVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    DoubleVector map(DoubleVector va, Vector.Mask<Double> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-
-
-    public static 
-    DoubleVector ceil(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.ceil((double) a));
-    }
-
-    public static 
-    DoubleVector ceil(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.ceil((double) a));
-    }
-
-    public static 
-    DoubleVector copySign(DoubleVector va, DoubleVector vb) {
-        return va.bOp(vb, (i, a, b) -> (double) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector copySign(DoubleVector va, DoubleVector vb, Vector.Mask<Double> m) {
-        return va.bOp(vb, m, (i, a, b) -> (double) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector floor(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.floor((double) a));
-    }
-
-    public static 
-    DoubleVector floor(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.floor((double) a));
-    }
-
-    public static 
-    DoubleVector getExponent(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.getExponent((double) a));
-    }
-
-    public static 
-    DoubleVector getExponent(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.getExponent((double) a));
-    }
-
-    public static 
-    DoubleVector IEEEremainder(DoubleVector va, DoubleVector vb) {
-        return va.bOp(vb, (i, a, b) -> (double) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector IEEEremainder(DoubleVector va, DoubleVector vb, Vector.Mask<Double> m) {
-        return va.bOp(vb, m, (i, a, b) -> (double) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector nextAfter(DoubleVector va, DoubleVector vb) {
-        return va.bOp(vb, (i, a, b) -> (double) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector nextAfter(DoubleVector va, DoubleVector vb, Vector.Mask<Double> m) {
-        return va.bOp(vb, m, (i, a, b) -> (double) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    DoubleVector nextDown(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.nextDown((double) a));
-    }
-
-    public static 
-    DoubleVector nextDown(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.nextDown((double) a));
-    }
-
-    public static 
-    DoubleVector nextUp(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.nextUp((double) a));
-    }
-
-    public static 
-    DoubleVector nextUp(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.nextUp((double) a));
-    }
-
-    public static 
-    DoubleVector rint(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.rint((double) a));
-    }
-
-    public static 
-    DoubleVector rint(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.rint((double) a));
-    }
-
-    public static 
-    DoubleVector round(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.round((double) a));
-    }
-
-    public static 
-    DoubleVector round(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.round((double) a));
-    }
-
-    public static 
-    DoubleVector scalb(Vector<Integer> o) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    DoubleVector scalb(Vector<Integer> o, Vector.Mask<Double> m) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    DoubleVector signum(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.signum((double) a));
-    }
-
-    public static 
-    DoubleVector signum(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.signum((double) a));
-    }
-
-    public static 
-    DoubleVector toDegrees(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.toDegrees((double) a));
-    }
-
-    public static 
-    DoubleVector toDegrees(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.toDegrees((double) a));
-    }
-
-    public static 
-    DoubleVector toRadians(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.toRadians((double) a));
-    }
-
-    public static 
-    DoubleVector toRadians(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.toRadians((double) a));
-    }
-
-    public static 
-    DoubleVector ulp(DoubleVector va) {
-        return va.uOp((i, a) -> (double) Math.ulp((double) a));
-    }
-
-    public static 
-    DoubleVector ulp(DoubleVector va, Vector.Mask<Double> m) {
-        return va.uOp(m, (i, a) -> (double) Math.ulp((double) a));
-    }
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public float subAll() {
-        int bits = (int) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Float128Vector.class, float.class, LENGTH,
-                                this,
-                                v -> {
-                                    float r = v.rOp((float) 0, (i, a, b) -> (float) (a - b));
-                                    return (long)Float.floatToIntBits(r);
-                                });
-        return Float.intBitsToFloat(bits);
-    }
-
-    @Override
-    @ForceInline
     public float mulAll() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float128Vector.class, float.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public float subAll(Mask<Float> m) {
-        return blend(SPECIES.broadcast((float) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public float mulAll(Mask<Float> m) {
         return blend(SPECIES.broadcast((float) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public float subAll() {
-        int bits = (int) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Float256Vector.class, float.class, LENGTH,
-                                this,
-                                v -> {
-                                    float r = v.rOp((float) 0, (i, a, b) -> (float) (a - b));
-                                    return (long)Float.floatToIntBits(r);
-                                });
-        return Float.intBitsToFloat(bits);
-    }
-
-    @Override
-    @ForceInline
     public float mulAll() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float256Vector.class, float.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public float subAll(Mask<Float> m) {
-        return blend(SPECIES.broadcast((float) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public float mulAll(Mask<Float> m) {
         return blend(SPECIES.broadcast((float) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public float subAll() {
-        int bits = (int) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Float512Vector.class, float.class, LENGTH,
-                                this,
-                                v -> {
-                                    float r = v.rOp((float) 0, (i, a, b) -> (float) (a - b));
-                                    return (long)Float.floatToIntBits(r);
-                                });
-        return Float.intBitsToFloat(bits);
-    }
-
-    @Override
-    @ForceInline
     public float mulAll() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float512Vector.class, float.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public float subAll(Mask<Float> m) {
-        return blend(SPECIES.broadcast((float) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public float mulAll(Mask<Float> m) {
         return blend(SPECIES.broadcast((float) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public float subAll() {
-        int bits = (int) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, Float64Vector.class, float.class, LENGTH,
-                                this,
-                                v -> {
-                                    float r = v.rOp((float) 0, (i, a, b) -> (float) (a - b));
-                                    return (long)Float.floatToIntBits(r);
-                                });
-        return Float.intBitsToFloat(bits);
-    }
-
-    @Override
-    @ForceInline
     public float mulAll() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float64Vector.class, float.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public float subAll(Mask<Float> m) {
-        return blend(SPECIES.broadcast((float) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public float mulAll(Mask<Float> m) {
         return blend(SPECIES.broadcast((float) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -856,19 +856,6 @@
 
     @Override
     @ForceInline
-    public float subAll() {
-        int bits = (int) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, FloatMaxVector.class, float.class, LENGTH,
-                                this,
-                                v -> {
-                                    float r = v.rOp((float) 0, (i, a, b) -> (float) (a - b));
-                                    return (long)Float.floatToIntBits(r);
-                                });
-        return Float.intBitsToFloat(bits);
-    }
-
-    @Override
-    @ForceInline
     public float mulAll() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, FloatMaxVector.class, float.class, LENGTH,
@@ -915,12 +902,6 @@
 
     @Override
     @ForceInline
-    public float subAll(Mask<Float> m) {
-        return blend(SPECIES.broadcast((float) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public float mulAll(Mask<Float> m) {
         return blend(SPECIES.broadcast((float) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -105,7 +105,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -126,6 +127,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -161,6 +163,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -185,6 +188,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -212,6 +216,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -233,6 +238,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -272,10 +278,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -307,6 +315,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -358,8 +367,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -372,6 +383,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Float> maskFromValues(FloatSpecies species, boolean... bits) {
         if (species.boxType() == FloatMaxVector.class)
@@ -410,6 +434,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Float> maskFromArray(FloatSpecies species, boolean[] bits, int ix) {
@@ -421,6 +459,12 @@
                                      (c, idx, s) -> (Mask<Float>) ((FloatSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Float> maskAllTrue(FloatSpecies species) {
@@ -429,6 +473,12 @@
                                                  ((z, s) -> trueMask((FloatSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Float> maskAllFalse(FloatSpecies species) {
@@ -437,6 +487,30 @@
                                                  ((z, s) -> falseMask((FloatSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Float> shuffle(FloatSpecies species, IntUnaryOperator f) {
         if (species.boxType() == FloatMaxVector.class)
@@ -450,6 +524,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Float> shuffleIota(FloatSpecies species) {
         if (species.boxType() == FloatMaxVector.class)
@@ -463,6 +550,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Float> shuffleFromValues(FloatSpecies species, int... ixs) {
         if (species.boxType() == FloatMaxVector.class)
@@ -476,6 +579,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Float> shuffleFromArray(FloatSpecies species, int[] ixs, int i) {
         if (species.boxType() == FloatMaxVector.class)
@@ -1637,13 +1755,21 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
-     * This is an associative vector reduction operation where the addition
+     * This is a vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
-     * and the identity value is {@code 0}.
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary for the same input values.
      *
      * @return the addition of all the lane elements of this vector
      */
@@ -1653,45 +1779,38 @@
      * Adds all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
-     * This is an associative vector reduction operation where the addition
+     * This is a vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
-     * and the identity value is {@code 0}.
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract float addAll(Mask<Float> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract float subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract float subAll(Mask<Float> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
-     * This is an associative vector reduction operation where the
+     * This is a vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
-     * and the identity value is {@code 1}.
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @return the multiplication of all the lane elements of this vector
      */
@@ -1701,9 +1820,17 @@
      * Multiplies all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
-     * This is an associative vector reduction operation where the
+     * This is a vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
-     * and the identity value is {@code 1}.
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
      *
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
@@ -1715,7 +1842,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Float#MAX_VALUE}.
+     * and the identity value is
+     * {@link Float#POSITIVE_INFINITY}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1727,7 +1855,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Float#MAX_VALUE}.
+     * and the identity value is
+     * {@link Float#POSITIVE_INFINITY}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1739,7 +1868,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Float#MIN_VALUE}.
+     * and the identity value is
+     * {@link Float#NEGATIVE_INFINITY}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1751,7 +1881,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Float#MIN_VALUE}.
+     * and the identity value is
+     * {@link Float#NEGATIVE_INFINITY}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1891,9 +2022,7 @@
     public abstract FloatSpecies species();
 
     /**
-     * A specialized factory for creating {@link FloatVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link FloatVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class FloatSpecies extends Vector.Species<Float> {
         interface FOp {
@@ -1947,7 +2076,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link ThreadLocalRandom#nextFloat }
+         * {@code ThreadLocalRandom#nextFloat}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,215 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class FloatVectorHelper {
-
-    private FloatVectorHelper() {}
-
-    public interface BinaryOp {
-        float apply(int i, float a, float b);
-    }
-
-    public interface UnaryOp {
-        float apply(int i, float a);
-    }
-
-    public static 
-    FloatVector map(FloatVector va, FloatVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    FloatVector map(FloatVector va, FloatVector vb, Vector.Mask<Float> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    FloatVector map(FloatVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    FloatVector map(FloatVector va, Vector.Mask<Float> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-
-
-    public static 
-    FloatVector ceil(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.ceil((double) a));
-    }
-
-    public static 
-    FloatVector ceil(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.ceil((double) a));
-    }
-
-    public static 
-    FloatVector copySign(FloatVector va, FloatVector vb) {
-        return va.bOp(vb, (i, a, b) -> (float) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector copySign(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
-        return va.bOp(vb, m, (i, a, b) -> (float) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector floor(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.floor((double) a));
-    }
-
-    public static 
-    FloatVector floor(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.floor((double) a));
-    }
-
-    public static 
-    FloatVector getExponent(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.getExponent((double) a));
-    }
-
-    public static 
-    FloatVector getExponent(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.getExponent((double) a));
-    }
-
-    public static 
-    FloatVector IEEEremainder(FloatVector va, FloatVector vb) {
-        return va.bOp(vb, (i, a, b) -> (float) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector IEEEremainder(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
-        return va.bOp(vb, m, (i, a, b) -> (float) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector nextAfter(FloatVector va, FloatVector vb) {
-        return va.bOp(vb, (i, a, b) -> (float) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector nextAfter(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
-        return va.bOp(vb, m, (i, a, b) -> (float) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    FloatVector nextDown(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.nextDown((double) a));
-    }
-
-    public static 
-    FloatVector nextDown(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.nextDown((double) a));
-    }
-
-    public static 
-    FloatVector nextUp(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.nextUp((double) a));
-    }
-
-    public static 
-    FloatVector nextUp(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.nextUp((double) a));
-    }
-
-    public static 
-    FloatVector rint(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.rint((double) a));
-    }
-
-    public static 
-    FloatVector rint(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.rint((double) a));
-    }
-
-    public static 
-    FloatVector round(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.round((double) a));
-    }
-
-    public static 
-    FloatVector round(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.round((double) a));
-    }
-
-    public static 
-    FloatVector scalb(Vector<Integer> o) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    FloatVector scalb(Vector<Integer> o, Vector.Mask<Float> m) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    FloatVector signum(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.signum((double) a));
-    }
-
-    public static 
-    FloatVector signum(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.signum((double) a));
-    }
-
-    public static 
-    FloatVector toDegrees(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.toDegrees((double) a));
-    }
-
-    public static 
-    FloatVector toDegrees(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.toDegrees((double) a));
-    }
-
-    public static 
-    FloatVector toRadians(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.toRadians((double) a));
-    }
-
-    public static 
-    FloatVector toRadians(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.toRadians((double) a));
-    }
-
-    public static 
-    FloatVector ulp(FloatVector va) {
-        return va.uOp((i, a) -> (float) Math.ulp((double) a));
-    }
-
-    public static 
-    FloatVector ulp(FloatVector va, Vector.Mask<Float> m) {
-        return va.uOp(m, (i, a) -> (float) Math.ulp((double) a));
-    }
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public int subAll() {
-        return (int) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Int128Vector.class, int.class, LENGTH,
-            this,
-            v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public int orAll() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int128Vector.class, int.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public int subAll(Mask<Integer> m) {
-        return blend(SPECIES.broadcast((int) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public int mulAll(Mask<Integer> m) {
         return blend(SPECIES.broadcast((int) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public int subAll() {
-        return (int) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Int256Vector.class, int.class, LENGTH,
-            this,
-            v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public int orAll() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int256Vector.class, int.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public int subAll(Mask<Integer> m) {
-        return blend(SPECIES.broadcast((int) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public int mulAll(Mask<Integer> m) {
         return blend(SPECIES.broadcast((int) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public int subAll() {
-        return (int) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Int512Vector.class, int.class, LENGTH,
-            this,
-            v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public int orAll() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int512Vector.class, int.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public int subAll(Mask<Integer> m) {
-        return blend(SPECIES.broadcast((int) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public int mulAll(Mask<Integer> m) {
         return blend(SPECIES.broadcast((int) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public int subAll() {
-        return (int) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Int64Vector.class, int.class, LENGTH,
-            this,
-            v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public int orAll() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int64Vector.class, int.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public int subAll(Mask<Integer> m) {
-        return blend(SPECIES.broadcast((int) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public int mulAll(Mask<Integer> m) {
         return blend(SPECIES.broadcast((int) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public int subAll() {
-        return (int) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, IntMaxVector.class, int.class, LENGTH,
-            this,
-            v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public int orAll() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, IntMaxVector.class, int.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public int subAll(Mask<Integer> m) {
-        return blend(SPECIES.broadcast((int) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public int mulAll(Mask<Integer> m) {
         return blend(SPECIES.broadcast((int) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -105,7 +105,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -126,6 +127,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -161,6 +163,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -185,6 +188,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -212,6 +216,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -233,6 +238,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -272,10 +278,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -307,6 +315,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -358,8 +367,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -372,6 +383,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Integer> maskFromValues(IntSpecies species, boolean... bits) {
         if (species.boxType() == IntMaxVector.class)
@@ -410,6 +434,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Integer> maskFromArray(IntSpecies species, boolean[] bits, int ix) {
@@ -421,6 +459,12 @@
                                      (c, idx, s) -> (Mask<Integer>) ((IntSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Integer> maskAllTrue(IntSpecies species) {
@@ -429,6 +473,12 @@
                                                  ((z, s) -> trueMask((IntSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Integer> maskAllFalse(IntSpecies species) {
@@ -437,6 +487,30 @@
                                                  ((z, s) -> falseMask((IntSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Integer> shuffle(IntSpecies species, IntUnaryOperator f) {
         if (species.boxType() == IntMaxVector.class)
@@ -450,6 +524,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Integer> shuffleIota(IntSpecies species) {
         if (species.boxType() == IntMaxVector.class)
@@ -463,6 +550,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Integer> shuffleFromValues(IntSpecies species, int... ixs) {
         if (species.boxType() == IntMaxVector.class)
@@ -476,6 +579,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Integer> shuffleFromArray(IntSpecies species, int[] ixs, int i) {
         if (species.boxType() == IntMaxVector.class)
@@ -1018,6 +1136,7 @@
      * operation ({@code >>>}) is applied to lane elements.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -1199,7 +1318,6 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
@@ -1220,35 +1338,11 @@
      * and the identity value is {@code 0}.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract int addAll(Mask<Integer> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract int subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract int subAll(Mask<Integer> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
      * This is an associative vector reduction operation where the
@@ -1277,7 +1371,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Integer#MAX_VALUE}.
+     * and the identity value is
+     * {@link Integer#MAX_VALUE}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1289,7 +1384,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Integer#MAX_VALUE}.
+     * and the identity value is
+     * {@link Integer#MAX_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1301,7 +1397,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Integer#MIN_VALUE}.
+     * and the identity value is
+     * {@link Integer#MIN_VALUE}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1313,7 +1410,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Integer#MIN_VALUE}.
+     * and the identity value is
+     * {@link Integer#MIN_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1524,9 +1622,7 @@
     public abstract IntSpecies species();
 
     /**
-     * A specialized factory for creating {@link IntVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link IntVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class IntSpecies extends Vector.Species<Integer> {
         interface FOp {
@@ -1580,7 +1676,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link (int)ThreadLocalRandom#nextInt() }
+         * {@code (int)ThreadLocalRandom#nextInt()}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class IntVectorHelper {
-
-    private IntVectorHelper() {}
-
-    public interface BinaryOp {
-        int apply(int i, int a, int b);
-    }
-
-    public interface UnaryOp {
-        int apply(int i, int a);
-    }
-
-    public static 
-    IntVector map(IntVector va, IntVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    IntVector map(IntVector va, IntVector vb, Vector.Mask<Integer> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    IntVector map(IntVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    IntVector map(IntVector va, Vector.Mask<Integer> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    IntVector div(IntVector va, IntVector vb) {
-        return va.bOp(vb, (i, a, b) -> (int) (a / b));
-    }
-
-    public static 
-    IntVector div(IntVector va, IntVector vb, Vector.Mask<Integer> m) {
-        return va.bOp(vb, m, (i, a, b) -> (int) (a / b));
-    }
-
-    public static 
-    IntVector mod(IntVector va, IntVector vb) {
-        return va.bOp(vb, (i, a, b) -> (int) (a % b));
-    }
-
-    public static 
-    IntVector mod(IntVector va, IntVector vb, Vector.Mask<Integer> m) {
-        return va.bOp(vb, m, (i, a, b) -> (int) (a % b));
-    }
-
-    public static 
-    IntVector addExact(IntVector va, IntVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    IntVector addExact(IntVector va, IntVector vb, Vector.Mask<Integer> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    IntVector decrementExact(IntVector va) {
-        return va.uOp((i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    IntVector decrementExact(IntVector va, Vector.Mask<Integer> m) {
-        return va.uOp(m, (i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    IntVector incrementExact(IntVector va) {
-        return va.uOp((i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    IntVector incrementExact(IntVector va, Vector.Mask<Integer> m) {
-        return va.uOp(m, (i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    IntVector multiplyExact(IntVector va, IntVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    IntVector multiplyExact(IntVector va, IntVector vb, Vector.Mask<Integer> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    IntVector negateExact(IntVector va) {
-        return va.uOp((i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    IntVector negateExact(IntVector va, Vector.Mask<Integer> m) {
-        return va.uOp(m, (i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    IntVector subtractExtract(IntVector va, IntVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.subtractExact(a, b));
-    }
-
-    public static 
-    IntVector subtractExtract(IntVector va, IntVector vb, Vector.Mask<Integer> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.subtractExact(a, b));
-    }
-
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public long subAll() {
-        return (long) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Long128Vector.class, long.class, LENGTH,
-            this,
-            v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public long orAll() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long128Vector.class, long.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public long subAll(Mask<Long> m) {
-        return blend(SPECIES.broadcast((long) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public long mulAll(Mask<Long> m) {
         return blend(SPECIES.broadcast((long) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public long subAll() {
-        return (long) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Long256Vector.class, long.class, LENGTH,
-            this,
-            v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public long orAll() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long256Vector.class, long.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public long subAll(Mask<Long> m) {
-        return blend(SPECIES.broadcast((long) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public long mulAll(Mask<Long> m) {
         return blend(SPECIES.broadcast((long) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public long subAll() {
-        return (long) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Long512Vector.class, long.class, LENGTH,
-            this,
-            v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public long orAll() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long512Vector.class, long.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public long subAll(Mask<Long> m) {
-        return blend(SPECIES.broadcast((long) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public long mulAll(Mask<Long> m) {
         return blend(SPECIES.broadcast((long) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -803,15 +803,6 @@
 
     @Override
     @ForceInline
-    public long subAll() {
-        return (long) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Long64Vector.class, long.class, LENGTH,
-            this,
-            v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public long orAll() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH,
@@ -849,12 +840,6 @@
 
     @Override
     @ForceInline
-    public long subAll(Mask<Long> m) {
-        return blend(SPECIES.broadcast((long) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public long mulAll(Mask<Long> m) {
         return blend(SPECIES.broadcast((long) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -805,15 +805,6 @@
 
     @Override
     @ForceInline
-    public long subAll() {
-        return (long) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, LongMaxVector.class, long.class, LENGTH,
-            this,
-            v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public long orAll() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, LongMaxVector.class, long.class, LENGTH,
@@ -851,12 +842,6 @@
 
     @Override
     @ForceInline
-    public long subAll(Mask<Long> m) {
-        return blend(SPECIES.broadcast((long) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public long mulAll(Mask<Long> m) {
         return blend(SPECIES.broadcast((long) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -105,7 +105,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -126,6 +127,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -161,6 +163,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -185,6 +188,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -212,6 +216,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -233,6 +238,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -275,10 +281,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -310,6 +318,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -361,8 +370,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -375,6 +386,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Long> maskFromValues(LongSpecies species, boolean... bits) {
         if (species.boxType() == LongMaxVector.class)
@@ -413,6 +437,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Long> maskFromArray(LongSpecies species, boolean[] bits, int ix) {
@@ -424,6 +462,12 @@
                                      (c, idx, s) -> (Mask<Long>) ((LongSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Long> maskAllTrue(LongSpecies species) {
@@ -432,6 +476,12 @@
                                                  ((z, s) -> trueMask((LongSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Long> maskAllFalse(LongSpecies species) {
@@ -440,6 +490,30 @@
                                                  ((z, s) -> falseMask((LongSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Long> shuffle(LongSpecies species, IntUnaryOperator f) {
         if (species.boxType() == LongMaxVector.class)
@@ -453,6 +527,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Long> shuffleIota(LongSpecies species) {
         if (species.boxType() == LongMaxVector.class)
@@ -466,6 +553,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Long> shuffleFromValues(LongSpecies species, int... ixs) {
         if (species.boxType() == LongMaxVector.class)
@@ -479,6 +582,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Long> shuffleFromArray(LongSpecies species, int[] ixs, int i) {
         if (species.boxType() == LongMaxVector.class)
@@ -1021,6 +1139,7 @@
      * operation ({@code >>>}) is applied to lane elements.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -1202,7 +1321,6 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
@@ -1223,35 +1341,11 @@
      * and the identity value is {@code 0}.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract long addAll(Mask<Long> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract long subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract long subAll(Mask<Long> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
      * This is an associative vector reduction operation where the
@@ -1280,7 +1374,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Long#MAX_VALUE}.
+     * and the identity value is
+     * {@link Long#MAX_VALUE}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1292,7 +1387,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Long#MAX_VALUE}.
+     * and the identity value is
+     * {@link Long#MAX_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1304,7 +1400,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Long#MIN_VALUE}.
+     * and the identity value is
+     * {@link Long#MIN_VALUE}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1316,7 +1413,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Long#MIN_VALUE}.
+     * and the identity value is
+     * {@link Long#MIN_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1527,9 +1625,7 @@
     public abstract LongSpecies species();
 
     /**
-     * A specialized factory for creating {@link LongVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link LongVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class LongSpecies extends Vector.Species<Long> {
         interface FOp {
@@ -1583,7 +1679,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link (long)ThreadLocalRandom#nextInt() }
+         * {@code (long)ThreadLocalRandom#nextInt()}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class LongVectorHelper {
-
-    private LongVectorHelper() {}
-
-    public interface BinaryOp {
-        long apply(int i, long a, long b);
-    }
-
-    public interface UnaryOp {
-        long apply(int i, long a);
-    }
-
-    public static 
-    LongVector map(LongVector va, LongVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    LongVector map(LongVector va, LongVector vb, Vector.Mask<Long> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    LongVector map(LongVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    LongVector map(LongVector va, Vector.Mask<Long> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    LongVector div(LongVector va, LongVector vb) {
-        return va.bOp(vb, (i, a, b) -> (long) (a / b));
-    }
-
-    public static 
-    LongVector div(LongVector va, LongVector vb, Vector.Mask<Long> m) {
-        return va.bOp(vb, m, (i, a, b) -> (long) (a / b));
-    }
-
-    public static 
-    LongVector mod(LongVector va, LongVector vb) {
-        return va.bOp(vb, (i, a, b) -> (long) (a % b));
-    }
-
-    public static 
-    LongVector mod(LongVector va, LongVector vb, Vector.Mask<Long> m) {
-        return va.bOp(vb, m, (i, a, b) -> (long) (a % b));
-    }
-
-    public static 
-    LongVector addExact(LongVector va, LongVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    LongVector addExact(LongVector va, LongVector vb, Vector.Mask<Long> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    LongVector decrementExact(LongVector va) {
-        return va.uOp((i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    LongVector decrementExact(LongVector va, Vector.Mask<Long> m) {
-        return va.uOp(m, (i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    LongVector incrementExact(LongVector va) {
-        return va.uOp((i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    LongVector incrementExact(LongVector va, Vector.Mask<Long> m) {
-        return va.uOp(m, (i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    LongVector multiplyExact(LongVector va, LongVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    LongVector multiplyExact(LongVector va, LongVector vb, Vector.Mask<Long> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    LongVector negateExact(LongVector va) {
-        return va.uOp((i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    LongVector negateExact(LongVector va, Vector.Mask<Long> m) {
-        return va.uOp(m, (i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    LongVector subtractExtract(LongVector va, LongVector vb) {
-        return va.bOp(vb, (i, a, b) -> Math.subtractExact(a, b));
-    }
-
-    public static 
-    LongVector subtractExtract(LongVector va, LongVector vb, Vector.Mask<Long> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.subtractExact(a, b));
-    }
-
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -762,15 +762,6 @@
 
     @Override
     @ForceInline
-    public short subAll() {
-        return (short) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Short128Vector.class, short.class, LENGTH,
-            this,
-            v -> (long) v.rOp((short) 0, (i, a, b) -> (short) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public short orAll() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short128Vector.class, short.class, LENGTH,
@@ -808,12 +799,6 @@
 
     @Override
     @ForceInline
-    public short subAll(Mask<Short> m) {
-        return blend(SPECIES.broadcast((short) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public short mulAll(Mask<Short> m) {
         return blend(SPECIES.broadcast((short) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -762,15 +762,6 @@
 
     @Override
     @ForceInline
-    public short subAll() {
-        return (short) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Short256Vector.class, short.class, LENGTH,
-            this,
-            v -> (long) v.rOp((short) 0, (i, a, b) -> (short) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public short orAll() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short256Vector.class, short.class, LENGTH,
@@ -808,12 +799,6 @@
 
     @Override
     @ForceInline
-    public short subAll(Mask<Short> m) {
-        return blend(SPECIES.broadcast((short) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public short mulAll(Mask<Short> m) {
         return blend(SPECIES.broadcast((short) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -762,15 +762,6 @@
 
     @Override
     @ForceInline
-    public short subAll() {
-        return (short) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Short512Vector.class, short.class, LENGTH,
-            this,
-            v -> (long) v.rOp((short) 0, (i, a, b) -> (short) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public short orAll() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short512Vector.class, short.class, LENGTH,
@@ -808,12 +799,6 @@
 
     @Override
     @ForceInline
-    public short subAll(Mask<Short> m) {
-        return blend(SPECIES.broadcast((short) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public short mulAll(Mask<Short> m) {
         return blend(SPECIES.broadcast((short) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -762,15 +762,6 @@
 
     @Override
     @ForceInline
-    public short subAll() {
-        return (short) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, Short64Vector.class, short.class, LENGTH,
-            this,
-            v -> (long) v.rOp((short) 0, (i, a, b) -> (short) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public short orAll() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short64Vector.class, short.class, LENGTH,
@@ -808,12 +799,6 @@
 
     @Override
     @ForceInline
-    public short subAll(Mask<Short> m) {
-        return blend(SPECIES.broadcast((short) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public short mulAll(Mask<Short> m) {
         return blend(SPECIES.broadcast((short) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -762,15 +762,6 @@
 
     @Override
     @ForceInline
-    public short subAll() {
-        return (short) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, ShortMaxVector.class, short.class, LENGTH,
-            this,
-            v -> (long) v.rOp((short) 0, (i, a, b) -> (short) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public short orAll() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, ShortMaxVector.class, short.class, LENGTH,
@@ -808,12 +799,6 @@
 
     @Override
     @ForceInline
-    public short subAll(Mask<Short> m) {
-        return blend(SPECIES.broadcast((short) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public short mulAll(Mask<Short> m) {
         return blend(SPECIES.broadcast((short) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -105,7 +105,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -126,6 +127,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -161,6 +163,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -185,6 +188,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -212,6 +216,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -233,6 +238,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -257,10 +263,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -288,6 +296,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -339,8 +348,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -353,6 +364,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<Short> maskFromValues(ShortSpecies species, boolean... bits) {
         if (species.boxType() == ShortMaxVector.class)
@@ -391,6 +415,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Short> maskFromArray(ShortSpecies species, boolean[] bits, int ix) {
@@ -402,6 +440,12 @@
                                      (c, idx, s) -> (Mask<Short>) ((ShortSpecies)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Short> maskAllTrue(ShortSpecies species) {
@@ -410,6 +454,12 @@
                                                  ((z, s) -> trueMask((ShortSpecies)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<Short> maskAllFalse(ShortSpecies species) {
@@ -418,6 +468,30 @@
                                                  ((z, s) -> falseMask((ShortSpecies)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<Short> shuffle(ShortSpecies species, IntUnaryOperator f) {
         if (species.boxType() == ShortMaxVector.class)
@@ -431,6 +505,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<Short> shuffleIota(ShortSpecies species) {
         if (species.boxType() == ShortMaxVector.class)
@@ -444,6 +531,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<Short> shuffleFromValues(ShortSpecies species, int... ixs) {
         if (species.boxType() == ShortMaxVector.class)
@@ -457,6 +560,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<Short> shuffleFromArray(ShortSpecies species, int[] ixs, int i) {
         if (species.boxType() == ShortMaxVector.class)
@@ -928,7 +1046,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -945,7 +1063,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -966,7 +1084,7 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -984,10 +1102,11 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -1002,7 +1121,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -1020,7 +1139,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -1045,7 +1164,6 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
@@ -1066,35 +1184,11 @@
      * and the identity value is {@code 0}.
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract short addAll(Mask<Short> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract short subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract short subAll(Mask<Short> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
      * This is an associative vector reduction operation where the
@@ -1123,7 +1217,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Short#MAX_VALUE}.
+     * and the identity value is
+     * {@link Short#MAX_VALUE}.
      *
      * @return the minimum lane element of this vector
      */
@@ -1135,7 +1230,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link Short#MAX_VALUE}.
+     * and the identity value is
+     * {@link Short#MAX_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -1147,7 +1243,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Short#MIN_VALUE}.
+     * and the identity value is
+     * {@link Short#MIN_VALUE}.
      *
      * @return the maximum lane element of this vector
      */
@@ -1159,7 +1256,8 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link Short#MIN_VALUE}.
+     * and the identity value is
+     * {@link Short#MIN_VALUE}.
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -1374,9 +1472,7 @@
     public abstract ShortSpecies species();
 
     /**
-     * A specialized factory for creating {@link ShortVector} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link ShortVector}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class ShortSpecies extends Vector.Species<Short> {
         interface FOp {
@@ -1429,7 +1525,7 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link (short)ThreadLocalRandom#nextInt() }
+         * {@code (short)ThreadLocalRandom#nextInt()}.
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVectorHelper.java	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class ShortVectorHelper {
-
-    private ShortVectorHelper() {}
-
-    public interface BinaryOp {
-        short apply(int i, short a, short b);
-    }
-
-    public interface UnaryOp {
-        short apply(int i, short a);
-    }
-
-    public static 
-    ShortVector map(ShortVector va, ShortVector vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    ShortVector map(ShortVector va, ShortVector vb, Vector.Mask<Short> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    ShortVector map(ShortVector va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    ShortVector map(ShortVector va, Vector.Mask<Short> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    ShortVector div(ShortVector va, ShortVector vb) {
-        return va.bOp(vb, (i, a, b) -> (short) (a / b));
-    }
-
-    public static 
-    ShortVector div(ShortVector va, ShortVector vb, Vector.Mask<Short> m) {
-        return va.bOp(vb, m, (i, a, b) -> (short) (a / b));
-    }
-
-    public static 
-    ShortVector mod(ShortVector va, ShortVector vb) {
-        return va.bOp(vb, (i, a, b) -> (short) (a % b));
-    }
-
-    public static 
-    ShortVector mod(ShortVector va, ShortVector vb, Vector.Mask<Short> m) {
-        return va.bOp(vb, m, (i, a, b) -> (short) (a % b));
-    }
-
-
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -830,6 +830,7 @@
      *
      * @param a the byte array
      * @param i the offset into the array
+     * @param m the mask controlling lane selection
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > a.length},
      * for any vector lane index {@code N} where the mask at lane {@code N}
@@ -901,14 +902,19 @@
 
     /**
      * A {@code Shape} governs the total size, in bits, of a
-     * {@link Vector}, {@link Mask}, or {@code Shuffle}.  The shape in
+     * {@link Vector}, {@link Mask}, or {@link Shuffle}.  The shape in
      * combination with the element type together govern the number of lanes.
      */
     public enum Shape {
+        /** Shape of length 64 bits */
         S_64_BIT(64),
+        /** Shape of length 128 bits */
         S_128_BIT(128),
+        /** Shape of length 256 bits */
         S_256_BIT(256),
+        /** Shape of length 512 bits */
         S_512_BIT(512),
+        /** Shape of maximum length supported on the platform */
         S_Max_BIT(Unsafe.getUnsafe().getMaxVectorSize(byte.class) * 8);
 
         final int bitSize;
@@ -966,8 +972,7 @@
 
 
     /**
-     * A factory for creating {@link Vector}, {@link Mask} and {@link Shuffle}
-     * values of the same element type and shape.
+     * Class representing vectors of same element type, {@code E} and {@link Vector.Shape Shape}.
      *
      * @param <E> the boxed element type of this species
      */
@@ -1192,6 +1197,7 @@
      * Mask<E> r = a.species().maskFromArray(ar, 0);
      * }</pre>
      *
+     * </ul>
      * @param <E> the boxed element type of this mask
      */
     public static abstract class Mask<E> {
@@ -1219,7 +1225,7 @@
          * {@code N} of the resulting mask is set, otherwise that mask lane is
          * not set.
          *
-         * @param s the species of the desired mask
+         * @param species the species of the desired mask
          * @param <F> the boxed element type of the species
          * @return a mask converted by shape and element type
          * @throws IllegalArgumentException if this mask length and the species
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template	Tue Mar 19 13:23:31 2019 -0700
@@ -107,7 +107,8 @@
      * Returns a vector where all lane elements are set to the default
      * primitive value.
      *
-     * @return a zero vector
+     * @param species species of desired vector
+     * @return a zero vector of given species
      */
     @ForceInline
     @SuppressWarnings("unchecked")
@@ -128,6 +129,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @return a vector loaded from a byte array
@@ -163,6 +165,7 @@
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param a the byte array
      * @param ix the offset into the array
      * @param m the mask
@@ -187,6 +190,7 @@
      * array element at index {@code i + N} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @return the vector loaded from an array
@@ -214,6 +218,7 @@
      * {@code N}, otherwise the default element value is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array
      * @param m the mask
@@ -235,6 +240,7 @@
      * array element at index {@code i + indexMap[j + N]} is placed into the
      * resulting vector at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
@@ -285,10 +291,12 @@
      * index {@code i + indexMap[j + N]} is placed into the resulting vector
      * at lane index {@code N}.
      *
+     * @param species species of desired vector
      * @param a the array
      * @param i the offset into the array, may be negative if relative
      * indexes in the index map compensate to produce a value within the
      * array bounds
+     * @param m the mask
      * @param indexMap the index map
      * @param j the offset into the index map
      * @return the vector loaded from an array
@@ -326,6 +334,7 @@
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
      * @return a vector loaded from a byte buffer
@@ -377,8 +386,10 @@
      * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
      * }</pre>
      *
+     * @param species species of desired vector
      * @param bb the byte buffer
      * @param ix the offset into the byte buffer
+     * @param m the mask
      * @return a vector loaded from a byte buffer
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > b.limit()},
@@ -391,6 +402,19 @@
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
+    /**
+     * Returns a mask where each lane is set or unset according to given
+     * {@code boolean} values
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the given {@code boolean} value at index {@code N} is {@code true}
+     * then the mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the given {@code boolean} values
+     * @return a mask where each lane is set or unset according to the given {@code boolean} value
+     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
+     */
     @ForceInline
     public static Mask<$Boxtype$> maskFromValues($Type$Species species, boolean... bits) {
         if (species.boxType() == $Type$MaxVector.class)
@@ -429,6 +453,20 @@
         }
     }
 
+    /**
+     * Loads a mask from a {@code boolean} array starting at an offset.
+     * <p>
+     * For each mask lane, where {@code N} is the mask lane index,
+     * if the array element at index {@code ix + N} is {@code true} then the
+     * mask lane at index {@code N} is set, otherwise it is unset.
+     *
+     * @param species mask species
+     * @param bits the {@code boolean} array
+     * @param ix the offset into the array
+     * @return the mask loaded from a {@code boolean} array
+     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
+     * {@code ix > bits.length - species.length()}
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<$Boxtype$> maskFromArray($Type$Species species, boolean[] bits, int ix) {
@@ -440,6 +478,12 @@
                                      (c, idx, s) -> (Mask<$Boxtype$>) (($Type$Species)s).opm(n -> c[idx + n]));
     }
 
+    /**
+     * Returns a mask where all lanes are set.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are set
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<$Boxtype$> maskAllTrue($Type$Species species) {
@@ -448,6 +492,12 @@
                                                  ((z, s) -> trueMask(($Type$Species)s)));
     }
 
+    /**
+     * Returns a mask where all lanes are unset.
+     *
+     * @param species mask species
+     * @return a mask where all lanes are unset
+     */
     @ForceInline
     @SuppressWarnings("unchecked")
     public static Mask<$Boxtype$> maskAllFalse($Type$Species species) {
@@ -456,6 +506,30 @@
                                                  ((z, s) -> falseMask(($Type$Species)s)));
     }
 
+    /**
+     * Returns a shuffle of mapped indexes where each lane element is
+     * the result of applying a mapping function to the corresponding lane
+     * index.
+     * <p>
+     * Care should be taken to ensure Shuffle values produced from this
+     * method are consumed as constants to ensure optimal generation of
+     * code.  For example, values held in static final fields or values
+     * held in loop constant local variables.
+     * <p>
+     * This method behaves as if a shuffle is created from an array of
+     * mapped indexes as follows:
+     * <pre>{@code
+     *   int[] a = new int[species.length()];
+     *   for (int i = 0; i < a.length; i++) {
+     *       a[i] = f.applyAsInt(i);
+     *   }
+     *   return this.shuffleFromValues(a);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @param f the lane index mapping function
+     * @return a shuffle of mapped indexes
+     */
     @ForceInline
     public static Shuffle<$Boxtype$> shuffle($Type$Species species, IntUnaryOperator f) {
         if (species.boxType() == $Type$MaxVector.class)
@@ -469,6 +543,19 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is the value of its
+     * corresponding lane index.
+     * <p>
+     * This method behaves as if a shuffle is created from an identity
+     * index mapping function as follows:
+     * <pre>{@code
+     *   return this.shuffle(i -> i);
+     * }</pre>
+     *
+     * @param species shuffle species
+     * @return a shuffle of lane indexes
+     */
     @ForceInline
     public static Shuffle<$Boxtype$> shuffleIota($Type$Species species) {
         if (species.boxType() == $Type$MaxVector.class)
@@ -482,6 +569,22 @@
         }
     }
 
+    /**
+     * Returns a shuffle where each lane element is set to a given
+     * {@code int} value logically AND'ed by the species length minus one.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * the {@code int} value at index {@code N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at
+     * lane index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the given {@code int} values
+     * @return a shuffle where each lane element is set to a given
+     * {@code int} value
+     * @throws IndexOutOfBoundsException if the number of int values is
+     * {@code < species.length()}
+     */
     @ForceInline
     public static Shuffle<$Boxtype$> shuffleFromValues($Type$Species species, int... ixs) {
         if (species.boxType() == $Type$MaxVector.class)
@@ -495,6 +598,21 @@
         }
     }
 
+    /**
+     * Loads a shuffle from an {@code int} array starting at an offset.
+     * <p>
+     * For each shuffle lane, where {@code N} is the shuffle lane index, the
+     * array element at index {@code i + N} logically AND'ed by
+     * {@code species.length() - 1} is placed into the resulting shuffle at lane
+     * index {@code N}.
+     *
+     * @param species shuffle species
+     * @param ixs the {@code int} array
+     * @param i the offset into the array
+     * @return a shuffle loaded from the {@code int} array
+     * @throws IndexOutOfBoundsException if {@code i < 0}, or
+     * {@code i > a.length - species.length()}
+     */
     @ForceInline
     public static Shuffle<$Boxtype$> shuffleFromArray($Type$Species species, int[] ixs, int i) {
         if (species.boxType() == $Type$MaxVector.class)
@@ -1824,7 +1942,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -1840,7 +1958,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -1871,7 +1989,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -1889,7 +2007,7 @@
      * operation ({@code <<}) is applied to lane elements to left shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to left shift
@@ -1955,7 +2073,7 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -1972,7 +2090,7 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -2005,10 +2123,11 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 3
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -2023,10 +2142,11 @@
      * operation ({@code >>>}) is applied to lane elements to logically right shift the
      * element by shift value as specified by the input scalar. Only the 4
      * lowest-order bits of shift value are used. It is as if the shift value
-     * were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -2041,6 +2161,7 @@
      * operation ({@code >>>}) is applied to lane elements.
      *
      * @param s the input scalar; the number of the bits to right shift
+     * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
@@ -2087,7 +2208,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 3 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -2104,7 +2225,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -2137,7 +2258,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 3 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0x7.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -2156,7 +2277,7 @@
      * shift operation ({@code >>}) is applied to lane elements  to arithmetically
      * right shift the element by shift value as specified by the input scalar.
      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
-     * value were subjected to a bitwise logical AND operator & with the mask value 0xF.
+     * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
      * @param s the input scalar; the number of the bits to right shift
@@ -2304,13 +2425,27 @@
 
 
     // Type specific horizontal reductions
-
     /**
      * Adds all lane elements of this vector.
      * <p>
+#if[FP]
+     * This is a vector reduction operation where the addition
+     * operation ({@code +}) is applied to lane elements,
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary for the same input values.
+#else[FP]
      * This is an associative vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
      * and the identity value is {@code 0}.
+#end[FP]
      *
      * @return the addition of all the lane elements of this vector
      */
@@ -2320,45 +2455,50 @@
      * Adds all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
+#if[FP]
+     * This is a vector reduction operation where the addition
+     * operation ({@code +}) is applied to lane elements,
+     * and the identity value is {@code 0.0}.
+     *
+     * <p>The value of a floating-point sum is a function both of the input values as well
+     * as the order of addition operations. The order of addition operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to add all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of adding vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
+#else[FP]
      * This is an associative vector reduction operation where the addition
      * operation ({@code +}) is applied to lane elements,
      * and the identity value is {@code 0}.
+#end[FP]
      *
      * @param m the mask controlling lane selection
-     * @return the addition of all the lane elements of this vector
+     * @return the addition of the selected lane elements of this vector
      */
     public abstract $type$ addAll(Mask<$Boxtype$> m);
 
     /**
-     * Subtracts all lane elements of this vector.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract $type$ subAll();
-
-    /**
-     * Subtracts all lane elements of this vector, selecting lane elements
-     * controlled by a mask.
-     * <p>
-     * This is an associative vector reduction operation where the subtraction
-     * operation ({@code -}) is applied to lane elements,
-     * and the identity value is {@code 0}.
-     *
-     * @param m the mask controlling lane selection
-     * @return the subtraction of all the lane elements of this vector
-     */
-    public abstract $type$ subAll(Mask<$Boxtype$> m);
-
-    /**
      * Multiplies all lane elements of this vector.
      * <p>
+#if[FP]
+     * This is a vector reduction operation where the
+     * multiplication operation ({@code *}) is applied to lane elements,
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
+#else[FP]
      * This is an associative vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
      * and the identity value is {@code 1}.
+#end[FP]
      *
      * @return the multiplication of all the lane elements of this vector
      */
@@ -2368,9 +2508,23 @@
      * Multiplies all lane elements of this vector, selecting lane elements
      * controlled by a mask.
      * <p>
+#if[FP]
+     * This is a vector reduction operation where the
+     * multiplication operation ({@code *}) is applied to lane elements,
+     * and the identity value is {@code 1.0}.
+     *
+     * <p>The order of multiplication operations of this method
+     * is intentionally not defined to allow for JVM to generate optimal machine
+     * code for the underlying platform at runtime. If the platform supports a vector
+     * instruction to multiply all values in the vector, or if there is some other efficient machine
+     * code sequence, then the JVM has the option of generating this machine code. Otherwise,
+     * the default implementation of multiplying vectors sequentially from left to right is used.
+     * For this reason, the output of this method may vary on the same input values.
+#else[FP]
      * This is an associative vector reduction operation where the
      * multiplication operation ({@code *}) is applied to lane elements,
      * and the identity value is {@code 1}.
+#end[FP]
      *
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
@@ -2382,7 +2536,12 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link $Boxtype$#MAX_VALUE}.
+     * and the identity value is
+#if[FP]
+     * {@link $Boxtype$#POSITIVE_INFINITY}.
+#else[FP]
+     * {@link $Boxtype$#MAX_VALUE}.
+#end[FP]
      *
      * @return the minimum lane element of this vector
      */
@@ -2394,7 +2553,12 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.min(a, b)} is applied to lane elements,
-     * and the identity value is {@link $Boxtype$#MAX_VALUE}.
+     * and the identity value is
+#if[FP]
+     * {@link $Boxtype$#POSITIVE_INFINITY}.
+#else[FP]
+     * {@link $Boxtype$#MAX_VALUE}.
+#end[FP]
      *
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
@@ -2406,7 +2570,12 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link $Boxtype$#MIN_VALUE}.
+     * and the identity value is
+#if[FP]
+     * {@link $Boxtype$#NEGATIVE_INFINITY}.
+#else[FP]
+     * {@link $Boxtype$#MIN_VALUE}.
+#end[FP]
      *
      * @return the maximum lane element of this vector
      */
@@ -2418,7 +2587,12 @@
      * <p>
      * This is an associative vector reduction operation where the operation
      * {@code (a, b) -> Math.max(a, b)} is applied to lane elements,
-     * and the identity value is {@link $Boxtype$#MIN_VALUE}.
+     * and the identity value is
+#if[FP]
+     * {@link $Boxtype$#NEGATIVE_INFINITY}.
+#else[FP]
+     * {@link $Boxtype$#MIN_VALUE}.
+#end[FP]
      *
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
@@ -2643,9 +2817,7 @@
     public abstract $Type$Species species();
 
     /**
-     * A specialized factory for creating {@link $abstractvectortype$} value of the same
-     * shape, and a {@link Mask} and {@link Shuffle} values of the same shape
-     * and {@code int} element type.
+     * Class representing {@link $abstractvectortype$}'s of the same {@link Vector.Shape Shape}.
      */
     public static abstract class $Type$Species extends Vector.Species<$Boxtype$> {
         interface FOp {
@@ -2701,7 +2873,11 @@
          * generated primitive value.
          *
          * The semantics are equivalent to calling
-         * {@link {#if[FP]?ThreadLocalRandom#next$Type$:($type$)ThreadLocalRandom#nextInt()} }
+#if[FP]
+         * {@code ThreadLocalRandom#next$Type$}.
+#else[FP]
+         * {@code ($type$)ThreadLocalRandom#nextInt()}.
+#end[FP]
          *
          * @return a vector where each lane elements is set to a randomly
          * generated primitive value
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template	Tue Mar 19 13:23:31 2019 -0700
@@ -1194,15 +1194,6 @@
 
     @Override
     @ForceInline
-    public $type$ subAll() {
-        return ($type$) VectorIntrinsics.reductionCoerced(
-            VECTOR_OP_SUB, $vectortype$.class, $type$.class, LENGTH,
-            this,
-            v -> (long) v.rOp(($type$) 0, (i, a, b) -> ($type$) (a - b)));
-    }
-
-    @Override
-    @ForceInline
     public $type$ orAll() {
         return ($type$) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, $vectortype$.class, $type$.class, LENGTH,
@@ -1248,19 +1239,6 @@
 
     @Override
     @ForceInline
-    public $type$ subAll() {
-        $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced(
-                                VECTOR_OP_SUB, $vectortype$.class, $type$.class, LENGTH,
-                                this,
-                                v -> {
-                                    $type$ r = v.rOp(($type$) 0, (i, a, b) -> ($type$) (a - b));
-                                    return (long)$Type$.$type$To$Bitstype$Bits(r);
-                                });
-        return $Type$.$bitstype$BitsTo$Fptype$(bits);
-    }
-
-    @Override
-    @ForceInline
     public $type$ mulAll() {
         $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, $vectortype$.class, $type$.class, LENGTH,
@@ -1308,12 +1286,6 @@
 
     @Override
     @ForceInline
-    public $type$ subAll(Mask<$Boxtype$> m) {
-        return blend(SPECIES.broadcast(($type$) 0), m).subAll();
-    }
-
-    @Override
-    @ForceInline
     public $type$ mulAll(Mask<$Boxtype$> m) {
         return blend(SPECIES.broadcast(($type$) 1), m).mulAll();
     }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorHelper.java.template	Thu Mar 07 09:53:35 2019 +0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,299 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have
- * questions.
- */
-package jdk.incubator.vector;
-
-/**
- * Operations on vectors that are not intrinsic candidates
- */
-@SuppressWarnings("cast")
-public final class $abstractvectortype$Helper {
-
-    private $abstractvectortype$Helper() {}
-
-    public interface BinaryOp {
-        $type$ apply(int i, $type$ a, $type$ b);
-    }
-
-    public interface UnaryOp {
-        $type$ apply(int i, $type$ a);
-    }
-
-    public static 
-    $abstractvectortype$ map($abstractvectortype$ va, $abstractvectortype$ vb, BinaryOp op) {
-        return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    $abstractvectortype$ map($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m, BinaryOp op) {
-        return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
-    }
-
-    public static 
-    $abstractvectortype$ map($abstractvectortype$ va, UnaryOp op) {
-        return va.uOp((i, a) -> op.apply(i, a));
-    }
-
-    public static 
-    $abstractvectortype$ map($abstractvectortype$ va, Vector.Mask<$Boxtype$> m, UnaryOp op) {
-        return va.uOp(m, (i, a) -> op.apply(i, a));
-    }
-
-#if[BITWISE]
-    public static 
-    $abstractvectortype$ div($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> ($type$) (a / b));
-    }
-
-    public static 
-    $abstractvectortype$ div($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> ($type$) (a / b));
-    }
-
-    public static 
-    $abstractvectortype$ mod($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> ($type$) (a % b));
-    }
-
-    public static 
-    $abstractvectortype$ mod($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> ($type$) (a % b));
-    }
-#end[BITWISE]
-
-#if[intOrLong]
-    public static 
-    $abstractvectortype$ addExact($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    $abstractvectortype$ addExact($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.addExact(a, b));
-    }
-
-    public static 
-    $abstractvectortype$ decrementExact($abstractvectortype$ va) {
-        return va.uOp((i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ decrementExact($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> Math.decrementExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ incrementExact($abstractvectortype$ va) {
-        return va.uOp((i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ incrementExact($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> Math.incrementExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ multiplyExact($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    $abstractvectortype$ multiplyExact($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.multiplyExact(a, b));
-    }
-
-    public static 
-    $abstractvectortype$ negateExact($abstractvectortype$ va) {
-        return va.uOp((i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ negateExact($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> Math.negateExact(a));
-    }
-
-    public static 
-    $abstractvectortype$ subtractExtract($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> Math.subtractExact(a, b));
-    }
-
-    public static 
-    $abstractvectortype$ subtractExtract($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> Math.subtractExact(a, b));
-    }
-#end[intOrLong]
-
-#if[FP]
-    public static 
-    $abstractvectortype$ ceil($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.ceil((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ ceil($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.ceil((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ copySign($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> ($type$) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ copySign($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> ($type$) Math.copySign((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ floor($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.floor((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ floor($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.floor((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ getExponent($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.getExponent((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ getExponent($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.getExponent((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ IEEEremainder($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> ($type$) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ IEEEremainder($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> ($type$) Math.IEEEremainder((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ nextAfter($abstractvectortype$ va, $abstractvectortype$ vb) {
-        return va.bOp(vb, (i, a, b) -> ($type$) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ nextAfter($abstractvectortype$ va, $abstractvectortype$ vb, Vector.Mask<$Boxtype$> m) {
-        return va.bOp(vb, m, (i, a, b) -> ($type$) Math.nextAfter((double) a, (double) b));
-    }
-
-    public static 
-    $abstractvectortype$ nextDown($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.nextDown((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ nextDown($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.nextDown((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ nextUp($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.nextUp((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ nextUp($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.nextUp((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ rint($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.rint((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ rint($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.rint((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ round($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.round((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ round($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.round((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ scalb(Vector<Integer> o) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    $abstractvectortype$ scalb(Vector<Integer> o, Vector.Mask<$Boxtype$> m) {
-        throw  new UnsupportedOperationException("Scalb not implemented yet.");
-    }
-
-    public static 
-    $abstractvectortype$ signum($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.signum((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ signum($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.signum((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ toDegrees($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.toDegrees((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ toDegrees($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.toDegrees((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ toRadians($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.toRadians((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ toRadians($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.toRadians((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ ulp($abstractvectortype$ va) {
-        return va.uOp((i, a) -> ($type$) Math.ulp((double) a));
-    }
-
-    public static 
-    $abstractvectortype$ ulp($abstractvectortype$ va, Vector.Mask<$Boxtype$> m) {
-        return va.uOp(m, (i, a) -> ($type$) Math.ulp((double) a));
-    }
-#end[FP]
-
-}
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh	Thu Mar 07 09:53:35 2019 +0800
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh	Tue Mar 19 13:23:31 2019 -0700
@@ -89,16 +89,6 @@
     mv temp $abstractvectortype.java
   fi
 
-  rm -f ${abstractvectortype}Helper.java
-  java $SPP -nel $args \
-     -iX-VectorHelper.java.template \
-     -o${abstractvectortype}Helper.java
-
-  if [[ "x${VAR_OS_ENV}" == "xwindows.cygwin" ]]; then
-    tr -d '\r' < ${abstractvectortype}Helper.java > temp
-    mv temp ${abstractvectortype}Helper.java
-  fi
-
   old_args="$args"
   for bits in 64 128 256 512 Max
   do
--- a/test/jdk/jdk/incubator/vector/Byte128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Byte128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Byte128VectorTests::addAll, Byte128VectorTests::addAll);
     }
-    static byte subAll(byte[] a, int idx) {
-        byte res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static byte subAll(byte[] a) {
-        byte res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            byte tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "byteUnaryOpProvider")
-    static void subAllByte128VectorTests(IntFunction<byte[]> fa) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Byte128VectorTests::subAll, Byte128VectorTests::subAll);
-    }
     static byte mulAll(byte[] a, int idx) {
         byte res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Byte256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Byte256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Byte256VectorTests::addAll, Byte256VectorTests::addAll);
     }
-    static byte subAll(byte[] a, int idx) {
-        byte res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static byte subAll(byte[] a) {
-        byte res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            byte tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "byteUnaryOpProvider")
-    static void subAllByte256VectorTests(IntFunction<byte[]> fa) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Byte256VectorTests::subAll, Byte256VectorTests::subAll);
-    }
     static byte mulAll(byte[] a, int idx) {
         byte res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Byte512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Byte512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Byte512VectorTests::addAll, Byte512VectorTests::addAll);
     }
-    static byte subAll(byte[] a, int idx) {
-        byte res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static byte subAll(byte[] a) {
-        byte res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            byte tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "byteUnaryOpProvider")
-    static void subAllByte512VectorTests(IntFunction<byte[]> fa) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Byte512VectorTests::subAll, Byte512VectorTests::subAll);
-    }
     static byte mulAll(byte[] a, int idx) {
         byte res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Byte64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Byte64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Byte64VectorTests::addAll, Byte64VectorTests::addAll);
     }
-    static byte subAll(byte[] a, int idx) {
-        byte res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static byte subAll(byte[] a) {
-        byte res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            byte tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "byteUnaryOpProvider")
-    static void subAllByte64VectorTests(IntFunction<byte[]> fa) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Byte64VectorTests::subAll, Byte64VectorTests::subAll);
-    }
     static byte mulAll(byte[] a, int idx) {
         byte res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1032,50 +1032,6 @@
 
         assertReductionArraysEquals(a, r, ra, ByteMaxVectorTests::addAll, ByteMaxVectorTests::addAll);
     }
-    static byte subAll(byte[] a, int idx) {
-        byte res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static byte subAll(byte[] a) {
-        byte res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            byte tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "byteUnaryOpProvider")
-    static void subAllByteMaxVectorTests(IntFunction<byte[]> fa) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, ByteMaxVectorTests::subAll, ByteMaxVectorTests::subAll);
-    }
     static byte mulAll(byte[] a, int idx) {
         byte res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Double128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Double128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Double128VectorTests::addAll, Double128VectorTests::addAll);
     }
-    static double subAll(double[] a, int idx) {
-        double res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static double subAll(double[] a) {
-        double res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            double tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "doubleUnaryOpProvider")
-    static void subAllDouble128VectorTests(IntFunction<double[]> fa) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Double128VectorTests::subAll, Double128VectorTests::subAll);
-    }
     static double mulAll(double[] a, int idx) {
         double res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Double256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Double256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Double256VectorTests::addAll, Double256VectorTests::addAll);
     }
-    static double subAll(double[] a, int idx) {
-        double res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static double subAll(double[] a) {
-        double res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            double tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "doubleUnaryOpProvider")
-    static void subAllDouble256VectorTests(IntFunction<double[]> fa) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Double256VectorTests::subAll, Double256VectorTests::subAll);
-    }
     static double mulAll(double[] a, int idx) {
         double res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Double512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Double512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Double512VectorTests::addAll, Double512VectorTests::addAll);
     }
-    static double subAll(double[] a, int idx) {
-        double res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static double subAll(double[] a) {
-        double res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            double tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "doubleUnaryOpProvider")
-    static void subAllDouble512VectorTests(IntFunction<double[]> fa) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Double512VectorTests::subAll, Double512VectorTests::subAll);
-    }
     static double mulAll(double[] a, int idx) {
         double res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Double64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Double64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Double64VectorTests::addAll, Double64VectorTests::addAll);
     }
-    static double subAll(double[] a, int idx) {
-        double res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static double subAll(double[] a) {
-        double res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            double tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "doubleUnaryOpProvider")
-    static void subAllDouble64VectorTests(IntFunction<double[]> fa) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Double64VectorTests::subAll, Double64VectorTests::subAll);
-    }
     static double mulAll(double[] a, int idx) {
         double res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -823,50 +823,6 @@
 
         assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::addAll, DoubleMaxVectorTests::addAll);
     }
-    static double subAll(double[] a, int idx) {
-        double res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static double subAll(double[] a) {
-        double res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            double tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "doubleUnaryOpProvider")
-    static void subAllDoubleMaxVectorTests(IntFunction<double[]> fa) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::subAll, DoubleMaxVectorTests::subAll);
-    }
     static double mulAll(double[] a, int idx) {
         double res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Float128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Float128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Float128VectorTests::addAll, Float128VectorTests::addAll);
     }
-    static float subAll(float[] a, int idx) {
-        float res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static float subAll(float[] a) {
-        float res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            float tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "floatUnaryOpProvider")
-    static void subAllFloat128VectorTests(IntFunction<float[]> fa) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Float128VectorTests::subAll, Float128VectorTests::subAll);
-    }
     static float mulAll(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Float256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Float256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Float256VectorTests::addAll, Float256VectorTests::addAll);
     }
-    static float subAll(float[] a, int idx) {
-        float res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static float subAll(float[] a) {
-        float res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            float tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "floatUnaryOpProvider")
-    static void subAllFloat256VectorTests(IntFunction<float[]> fa) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Float256VectorTests::subAll, Float256VectorTests::subAll);
-    }
     static float mulAll(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Float512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Float512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Float512VectorTests::addAll, Float512VectorTests::addAll);
     }
-    static float subAll(float[] a, int idx) {
-        float res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static float subAll(float[] a) {
-        float res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            float tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "floatUnaryOpProvider")
-    static void subAllFloat512VectorTests(IntFunction<float[]> fa) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Float512VectorTests::subAll, Float512VectorTests::subAll);
-    }
     static float mulAll(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Float64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Float64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -817,50 +817,6 @@
 
         assertReductionArraysEquals(a, r, ra, Float64VectorTests::addAll, Float64VectorTests::addAll);
     }
-    static float subAll(float[] a, int idx) {
-        float res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static float subAll(float[] a) {
-        float res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            float tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "floatUnaryOpProvider")
-    static void subAllFloat64VectorTests(IntFunction<float[]> fa) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Float64VectorTests::subAll, Float64VectorTests::subAll);
-    }
     static float mulAll(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -823,50 +823,6 @@
 
         assertReductionArraysEquals(a, r, ra, FloatMaxVectorTests::addAll, FloatMaxVectorTests::addAll);
     }
-    static float subAll(float[] a, int idx) {
-        float res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static float subAll(float[] a) {
-        float res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            float tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "floatUnaryOpProvider")
-    static void subAllFloatMaxVectorTests(IntFunction<float[]> fa) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, FloatMaxVectorTests::subAll, FloatMaxVectorTests::subAll);
-    }
     static float mulAll(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Int128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Int128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Int128VectorTests::addAll, Int128VectorTests::addAll);
     }
-    static int subAll(int[] a, int idx) {
-        int res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static int subAll(int[] a) {
-        int res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            int tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "intUnaryOpProvider")
-    static void subAllInt128VectorTests(IntFunction<int[]> fa) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Int128VectorTests::subAll, Int128VectorTests::subAll);
-    }
     static int mulAll(int[] a, int idx) {
         int res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Int256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Int256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Int256VectorTests::addAll, Int256VectorTests::addAll);
     }
-    static int subAll(int[] a, int idx) {
-        int res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static int subAll(int[] a) {
-        int res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            int tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "intUnaryOpProvider")
-    static void subAllInt256VectorTests(IntFunction<int[]> fa) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Int256VectorTests::subAll, Int256VectorTests::subAll);
-    }
     static int mulAll(int[] a, int idx) {
         int res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Int512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Int512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Int512VectorTests::addAll, Int512VectorTests::addAll);
     }
-    static int subAll(int[] a, int idx) {
-        int res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static int subAll(int[] a) {
-        int res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            int tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "intUnaryOpProvider")
-    static void subAllInt512VectorTests(IntFunction<int[]> fa) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Int512VectorTests::subAll, Int512VectorTests::subAll);
-    }
     static int mulAll(int[] a, int idx) {
         int res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Int64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Int64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Int64VectorTests::addAll, Int64VectorTests::addAll);
     }
-    static int subAll(int[] a, int idx) {
-        int res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static int subAll(int[] a) {
-        int res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            int tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "intUnaryOpProvider")
-    static void subAllInt64VectorTests(IntFunction<int[]> fa) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Int64VectorTests::subAll, Int64VectorTests::subAll);
-    }
     static int mulAll(int[] a, int idx) {
         int res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/IntMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/IntMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1182,50 +1182,6 @@
 
         assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::addAll, IntMaxVectorTests::addAll);
     }
-    static int subAll(int[] a, int idx) {
-        int res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static int subAll(int[] a) {
-        int res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            int tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "intUnaryOpProvider")
-    static void subAllIntMaxVectorTests(IntFunction<int[]> fa) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::subAll, IntMaxVectorTests::subAll);
-    }
     static int mulAll(int[] a, int idx) {
         int res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Long128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Long128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Long128VectorTests::addAll, Long128VectorTests::addAll);
     }
-    static long subAll(long[] a, int idx) {
-        long res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static long subAll(long[] a) {
-        long res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            long tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "longUnaryOpProvider")
-    static void subAllLong128VectorTests(IntFunction<long[]> fa) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Long128VectorTests::subAll, Long128VectorTests::subAll);
-    }
     static long mulAll(long[] a, int idx) {
         long res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Long256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Long256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Long256VectorTests::addAll, Long256VectorTests::addAll);
     }
-    static long subAll(long[] a, int idx) {
-        long res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static long subAll(long[] a) {
-        long res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            long tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "longUnaryOpProvider")
-    static void subAllLong256VectorTests(IntFunction<long[]> fa) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Long256VectorTests::subAll, Long256VectorTests::subAll);
-    }
     static long mulAll(long[] a, int idx) {
         long res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Long512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Long512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Long512VectorTests::addAll, Long512VectorTests::addAll);
     }
-    static long subAll(long[] a, int idx) {
-        long res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static long subAll(long[] a) {
-        long res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            long tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "longUnaryOpProvider")
-    static void subAllLong512VectorTests(IntFunction<long[]> fa) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Long512VectorTests::subAll, Long512VectorTests::subAll);
-    }
     static long mulAll(long[] a, int idx) {
         long res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Long64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Long64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1176,50 +1176,6 @@
 
         assertReductionArraysEquals(a, r, ra, Long64VectorTests::addAll, Long64VectorTests::addAll);
     }
-    static long subAll(long[] a, int idx) {
-        long res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static long subAll(long[] a) {
-        long res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            long tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "longUnaryOpProvider")
-    static void subAllLong64VectorTests(IntFunction<long[]> fa) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Long64VectorTests::subAll, Long64VectorTests::subAll);
-    }
     static long mulAll(long[] a, int idx) {
         long res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/LongMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/LongMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1182,50 +1182,6 @@
 
         assertReductionArraysEquals(a, r, ra, LongMaxVectorTests::addAll, LongMaxVectorTests::addAll);
     }
-    static long subAll(long[] a, int idx) {
-        long res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static long subAll(long[] a) {
-        long res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            long tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "longUnaryOpProvider")
-    static void subAllLongMaxVectorTests(IntFunction<long[]> fa) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, LongMaxVectorTests::subAll, LongMaxVectorTests::subAll);
-    }
     static long mulAll(long[] a, int idx) {
         long res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Short128VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Short128VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Short128VectorTests::addAll, Short128VectorTests::addAll);
     }
-    static short subAll(short[] a, int idx) {
-        short res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static short subAll(short[] a) {
-        short res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            short tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "shortUnaryOpProvider")
-    static void subAllShort128VectorTests(IntFunction<short[]> fa) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Short128VectorTests::subAll, Short128VectorTests::subAll);
-    }
     static short mulAll(short[] a, int idx) {
         short res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Short256VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Short256VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Short256VectorTests::addAll, Short256VectorTests::addAll);
     }
-    static short subAll(short[] a, int idx) {
-        short res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static short subAll(short[] a) {
-        short res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            short tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "shortUnaryOpProvider")
-    static void subAllShort256VectorTests(IntFunction<short[]> fa) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Short256VectorTests::subAll, Short256VectorTests::subAll);
-    }
     static short mulAll(short[] a, int idx) {
         short res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Short512VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Short512VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Short512VectorTests::addAll, Short512VectorTests::addAll);
     }
-    static short subAll(short[] a, int idx) {
-        short res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static short subAll(short[] a) {
-        short res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            short tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "shortUnaryOpProvider")
-    static void subAllShort512VectorTests(IntFunction<short[]> fa) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Short512VectorTests::subAll, Short512VectorTests::subAll);
-    }
     static short mulAll(short[] a, int idx) {
         short res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/Short64VectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/Short64VectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1026,50 +1026,6 @@
 
         assertReductionArraysEquals(a, r, ra, Short64VectorTests::addAll, Short64VectorTests::addAll);
     }
-    static short subAll(short[] a, int idx) {
-        short res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static short subAll(short[] a) {
-        short res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            short tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "shortUnaryOpProvider")
-    static void subAllShort64VectorTests(IntFunction<short[]> fa) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, Short64VectorTests::subAll, Short64VectorTests::subAll);
-    }
     static short mulAll(short[] a, int idx) {
         short res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java	Tue Mar 19 13:23:31 2019 -0700
@@ -1032,50 +1032,6 @@
 
         assertReductionArraysEquals(a, r, ra, ShortMaxVectorTests::addAll, ShortMaxVectorTests::addAll);
     }
-    static short subAll(short[] a, int idx) {
-        short res = 0;
-        for (int i = idx; i < (idx + SPECIES.length()); i++) {
-            res -= a[i];
-        }
-
-        return res;
-    }
-
-    static short subAll(short[] a) {
-        short res = 0;
-        for (int i = 0; i < a.length; i += SPECIES.length()) {
-            short tmp = 0;
-            for (int j = 0; j < SPECIES.length(); j++) {
-                tmp -= a[i + j];
-            }
-            res -= tmp;
-        }
-
-        return res;
-    }
-    @Test(dataProvider = "shortUnaryOpProvider")
-    static void subAllShortMaxVectorTests(IntFunction<short[]> fa) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        assertReductionArraysEquals(a, r, ra, ShortMaxVectorTests::subAll, ShortMaxVectorTests::subAll);
-    }
     static short mulAll(short[] a, int idx) {
         short res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         byte[] a = fa.apply(SPECIES.length());
         byte[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         byte[] a = fa.apply(SPECIES.length());
         byte[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         byte[] a = fa.apply(SPECIES.length());
         byte[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         byte[] a = fa.apply(SPECIES.length());
         byte[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        byte[] a = fa.apply(SPECIES.length());
-        byte[] r = fr.apply(SPECIES.length());
-        byte ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ByteVector av = ByteVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         byte[] a = fa.apply(SPECIES.length());
         byte[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ByteScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -492,16 +492,6 @@
     }
 
     @Benchmark
-    public byte subAll() {
-        byte[] as = fa.apply(size);
-        byte r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public byte mulAll() {
         byte[] as = fa.apply(size);
         byte r = 1;
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         double[] a = fa.apply(SPECIES.length());
         double[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         double[] a = fa.apply(SPECIES.length());
         double[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         double[] a = fa.apply(SPECIES.length());
         double[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Double64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         double[] a = fa.apply(SPECIES.length());
         double[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        double[] a = fa.apply(SPECIES.length());
-        double[] r = fr.apply(SPECIES.length());
-        double ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         double[] a = fa.apply(SPECIES.length());
         double[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/DoubleScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -285,16 +285,6 @@
     }
 
     @Benchmark
-    public double subAll() {
-        double[] as = fa.apply(size);
-        double r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public double mulAll() {
         double[] as = fa.apply(size);
         double r = 1;
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Float64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -325,31 +325,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        float[] a = fa.apply(SPECIES.length());
-        float[] r = fr.apply(SPECIES.length());
-        float ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -285,16 +285,6 @@
     }
 
     @Benchmark
-    public float subAll() {
-        float[] as = fa.apply(size);
-        float r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public float mulAll() {
         float[] as = fa.apply(size);
         float r = 1;
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         int[] a = fa.apply(SPECIES.length());
         int[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         int[] a = fa.apply(SPECIES.length());
         int[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         int[] a = fa.apply(SPECIES.length());
         int[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         int[] a = fa.apply(SPECIES.length());
         int[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        int[] a = fa.apply(SPECIES.length());
-        int[] r = fr.apply(SPECIES.length());
-        int ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                IntVector av = IntVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         int[] a = fa.apply(SPECIES.length());
         int[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -600,16 +600,6 @@
     }
 
     @Benchmark
-    public int subAll() {
-        int[] as = fa.apply(size);
-        int r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public int mulAll() {
         int[] as = fa.apply(size);
         int r = 1;
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         long[] a = fa.apply(SPECIES.length());
         long[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         long[] a = fa.apply(SPECIES.length());
         long[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         long[] a = fa.apply(SPECIES.length());
         long[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Long64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         long[] a = fa.apply(SPECIES.length());
         long[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -701,31 +701,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        long[] a = fa.apply(SPECIES.length());
-        long[] r = fr.apply(SPECIES.length());
-        long ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                LongVector av = LongVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         long[] a = fa.apply(SPECIES.length());
         long[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/LongScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -600,16 +600,6 @@
     }
 
     @Benchmark
-    public long subAll() {
-        long[] as = fa.apply(size);
-        long r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public long mulAll() {
         long[] as = fa.apply(size);
         long r = 1;
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short128Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short128Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         short[] a = fa.apply(SPECIES.length());
         short[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short256Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short256Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         short[] a = fa.apply(SPECIES.length());
         short[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short512Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short512Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         short[] a = fa.apply(SPECIES.length());
         short[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short64Vector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Short64Vector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         short[] a = fa.apply(SPECIES.length());
         short[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortMaxVector.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortMaxVector.java	Tue Mar 19 13:23:31 2019 -0700
@@ -587,31 +587,6 @@
     }
 
     @Benchmark
-    public void subAll(Blackhole bh) {
-        short[] a = fa.apply(SPECIES.length());
-        short[] r = fr.apply(SPECIES.length());
-        short ra = 0;
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                r[i] = av.subAll();
-            }
-        }
-
-        for (int ic = 0; ic < INVOC_COUNT; ic++) {
-            ra = 0;
-            for (int i = 0; i < a.length; i += SPECIES.length()) {
-                ShortVector av = ShortVector.fromArray(SPECIES, a, i);
-                ra -= av.subAll();
-            }
-        }
-
-        bh.consume(ra);
-        bh.consume(r);
-    }
-
-    @Benchmark
     public void mulAll(Blackhole bh) {
         short[] a = fa.apply(SPECIES.length());
         short[] r = fr.apply(SPECIES.length());
--- a/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortScalar.java	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/ShortScalar.java	Tue Mar 19 13:23:31 2019 -0700
@@ -492,16 +492,6 @@
     }
 
     @Benchmark
-    public short subAll() {
-        short[] as = fa.apply(size);
-        short r = 0;
-        for (int i = 0; i < as.length; i++) {
-            r -= as[i];
-        }
-        return r;
-    }
-
-    @Benchmark
     public short mulAll() {
         short[] as = fa.apply(size);
         short r = 1;
--- a/test/jdk/jdk/incubator/vector/gen-template.sh	Thu Mar 07 09:53:35 2019 +0800
+++ b/test/jdk/jdk/incubator/vector/gen-template.sh	Tue Mar 19 13:23:31 2019 -0700
@@ -279,7 +279,6 @@
 gen_reduction_op "orAll" "|" $unit_output $perf_output $perf_scalar_output "BITWISE" "0"
 gen_reduction_op "xorAll" "^" $unit_output $perf_output $perf_scalar_output "BITWISE" "0"
 gen_reduction_op "addAll" "+" $unit_output $perf_output $perf_scalar_output "" "0"
-gen_reduction_op "subAll" "-" $unit_output $perf_output $perf_scalar_output "" "0"
 gen_reduction_op "mulAll" "*" $unit_output $perf_output $perf_scalar_output "" "1"
 gen_reduction_op_min "minAll" "" $unit_output $perf_output $perf_scalar_output "" "\$Wideboxtype\$.MAX_VALUE"
 gen_reduction_op_max "maxAll" "" $unit_output $perf_output $perf_scalar_output "" "\$Wideboxtype\$.MIN_VALUE"