--- old/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	2019-04-09 12:05:41.042396800 -0700
+++ new/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	2019-04-09 12:05:40.511257600 -0700
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class Byte64Vector extends ByteVector {
-    static final Byte64Species SPECIES = new Byte64Species();
+    private static final Species<Byte> SPECIES = ByteVector.SPECIES_64;
 
     static final Byte64Vector ZERO = new Byte64Vector();
 
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             Byte64Vector.class,
             byte.class, LENGTH,
-            s.vectorType(),
+            s.boxType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((ByteVector.ByteSpecies) s, a, 0);
+            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((ShortVector.ShortSpecies) s, a, 0);
+            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((IntVector.IntSpecies) s, a, 0);
+            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((LongVector.LongSpecies) s, a, 0);
+            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((FloatVector.FloatSpecies) s, a, 0);
+            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((DoubleVector.DoubleSpecies) s, a, 0);
+            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -292,55 +292,50 @@
     @ForceInline
     public ByteVector reshape(Species<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s instanceof Byte64Vector.Byte64Species)) {
-            Byte64Vector.Byte64Species ts = (Byte64Vector.Byte64Species)s;
+        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
                 Byte64Vector.class,
                 byte.class, Byte64Vector.LENGTH,
-                this, ts,
+                this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s instanceof Byte128Vector.Byte128Species)) {
-            Byte128Vector.Byte128Species ts = (Byte128Vector.Byte128Species)s;
+        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
                 Byte128Vector.class,
                 byte.class, Byte128Vector.LENGTH,
-                this, ts,
+                this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s instanceof Byte256Vector.Byte256Species)) {
-            Byte256Vector.Byte256Species ts = (Byte256Vector.Byte256Species)s;
+        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
                 Byte256Vector.class,
                 byte.class, Byte256Vector.LENGTH,
-                this, ts,
+                this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s instanceof Byte512Vector.Byte512Species)) {
-            Byte512Vector.Byte512Species ts = (Byte512Vector.Byte512Species)s;
+        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
                 Byte512Vector.class,
                 byte.class, Byte512Vector.LENGTH,
-                this, ts,
+                this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s instanceof ByteMaxVector.ByteMaxSpecies)) {
-            ByteMaxVector.ByteMaxSpecies ts = (ByteMaxVector.ByteMaxSpecies)s;
+                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
                 ByteMaxVector.class,
                 byte.class, ByteMaxVector.LENGTH,
-                this, ts,
+                this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else {
@@ -353,128 +348,128 @@
     @Override
     @ForceInline
     public ByteVector add(byte o) {
-        return add(SPECIES.broadcast(o));
+        return add((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector add(byte o, Mask<Byte> m) {
-        return add(SPECIES.broadcast(o), m);
+        return add((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
     public ByteVector sub(byte o) {
-        return sub(SPECIES.broadcast(o));
+        return sub((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector sub(byte o, Mask<Byte> m) {
-        return sub(SPECIES.broadcast(o), m);
+        return sub((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
     public ByteVector mul(byte o) {
-        return mul(SPECIES.broadcast(o));
+        return mul((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector mul(byte o, Mask<Byte> m) {
-        return mul(SPECIES.broadcast(o), m);
+        return mul((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
     public ByteVector min(byte o) {
-        return min(SPECIES.broadcast(o));
+        return min((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector max(byte o) {
-        return max(SPECIES.broadcast(o));
+        return max((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> equal(byte o) {
-        return equal(SPECIES.broadcast(o));
+        return equal((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> notEqual(byte o) {
-        return notEqual(SPECIES.broadcast(o));
+        return notEqual((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> lessThan(byte o) {
-        return lessThan(SPECIES.broadcast(o));
+        return lessThan((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> lessThanEq(byte o) {
-        return lessThanEq(SPECIES.broadcast(o));
+        return lessThanEq((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> greaterThan(byte o) {
-        return greaterThan(SPECIES.broadcast(o));
+        return greaterThan((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public Mask<Byte> greaterThanEq(byte o) {
-        return greaterThanEq(SPECIES.broadcast(o));
+        return greaterThanEq((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector blend(byte o, Mask<Byte> m) {
-        return blend(SPECIES.broadcast(o), m);
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
 
     @Override
     @ForceInline
     public ByteVector and(byte o) {
-        return and(SPECIES.broadcast(o));
+        return and((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector and(byte o, Mask<Byte> m) {
-        return and(SPECIES.broadcast(o), m);
+        return and((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
     public ByteVector or(byte o) {
-        return or(SPECIES.broadcast(o));
+        return or((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector or(byte o, Mask<Byte> m) {
-        return or(SPECIES.broadcast(o), m);
+        return or((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
     public ByteVector xor(byte o) {
-        return xor(SPECIES.broadcast(o));
+        return xor((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
     public ByteVector xor(byte o, Mask<Byte> m) {
-        return xor(SPECIES.broadcast(o), m);
+        return xor((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
     @Override
@@ -729,7 +724,7 @@
     @Override
     @ForceInline
     public byte andAll(Mask<Byte> m) {
-        return SPECIES.broadcast((byte) -1).blend(this, m).andAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
     @Override
@@ -771,7 +766,7 @@
     @Override
     @ForceInline
     public byte orAll(Mask<Byte> m) {
-        return SPECIES.broadcast((byte) 0).blend(this, m).orAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
     @Override
@@ -786,33 +781,33 @@
     @Override
     @ForceInline
     public byte xorAll(Mask<Byte> m) {
-        return SPECIES.broadcast((byte) 0).blend(this, m).xorAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
     public byte addAll(Mask<Byte> m) {
-        return SPECIES.broadcast((byte) 0).blend(this, m).addAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
     public byte mulAll(Mask<Byte> m) {
-        return SPECIES.broadcast((byte) 1).blend(this, m).mulAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
     public byte minAll(Mask<Byte> m) {
-        return SPECIES.broadcast(Byte.MAX_VALUE).blend(this, m).minAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
     public byte maxAll(Mask<Byte> m) {
-        return SPECIES.broadcast(Byte.MIN_VALUE).blend(this, m).maxAll();
+        return blend((Byte64Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
@@ -1196,7 +1191,7 @@
         }
 
         @Override
-        public Byte64Species species() {
+        public Species<Byte> species() {
             return SPECIES;
         }
 
@@ -1212,6 +1207,31 @@
             return new Byte64Vector(res);
         }
 
+        @Override
+        @ForceInline
+        @SuppressWarnings("unchecked")
+        public <E> Mask<E> cast(Species<E> species) {
+            if (length() != species.length())
+                throw new IllegalArgumentException("Mask length and species length differ");
+            Class<?> stype = species.elementType();
+            boolean [] maskArray = toArray();
+            if (stype == byte.class) {
+                return (Mask <E>) new Byte64Vector.Byte64Mask(maskArray);
+            } else if (stype == short.class) {
+                return (Mask <E>) new Short64Vector.Short64Mask(maskArray);
+            } else if (stype == int.class) {
+                return (Mask <E>) new Int64Vector.Int64Mask(maskArray);
+            } else if (stype == long.class) {
+                return (Mask <E>) new Long64Vector.Long64Mask(maskArray);
+            } else if (stype == float.class) {
+                return (Mask <E>) new Float64Vector.Float64Mask(maskArray);
+            } else if (stype == double.class) {
+                return (Mask <E>) new Double64Vector.Double64Mask(maskArray);
+            } else {
+                throw new UnsupportedOperationException("Bad lane type for casting.");
+            }
+        }
+
         // Unary operations
 
         @Override
@@ -1284,7 +1304,7 @@
         }
 
         @Override
-        public Byte64Species species() {
+        public Species<Byte> species() {
             return SPECIES;
         }
 
@@ -1298,6 +1318,31 @@
         }
 
         @Override
+        @ForceInline
+        @SuppressWarnings("unchecked")
+        public <F> Shuffle<F> cast(Species<F> species) {
+            if (length() != species.length())
+                throw new IllegalArgumentException("Shuffle length and species length differ");
+            Class<?> stype = species.elementType();
+            int [] shuffleArray = toArray();
+            if (stype == byte.class) {
+                return (Shuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
+            } else if (stype == short.class) {
+                return (Shuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
+            } else if (stype == int.class) {
+                return (Shuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
+            } else if (stype == long.class) {
+                return (Shuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
+            } else if (stype == float.class) {
+                return (Shuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
+            } else if (stype == double.class) {
+                return (Shuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
+            } else {
+                throw new UnsupportedOperationException("Bad lane type for casting.");
+            }
+        }
+
+        @Override
         public Byte64Shuffle rearrange(Vector.Shuffle<Byte> o) {
             Byte64Shuffle s = (Byte64Shuffle) o;
             byte[] r = new byte[reorder.length];
@@ -1311,148 +1356,7 @@
     // Species
 
     @Override
-    public Byte64Species species() {
+    public Species<Byte> species() {
         return SPECIES;
     }
-
-    static final class Byte64Species extends ByteSpecies {
-        static final int BIT_SIZE = Shape.S_64_BIT.bitSize();
-
-        static final int LENGTH = BIT_SIZE / Byte.SIZE;
-
-        @Override
-        public String toString() {
-           StringBuilder sb = new StringBuilder("Shape[");
-           sb.append(bitSize()).append(" bits, ");
-           sb.append(length()).append(" ").append(byte.class.getSimpleName()).append("s x ");
-           sb.append(elementSize()).append(" bits");
-           sb.append("]");
-           return sb.toString();
-        }
-
-        @Override
-        @ForceInline
-        public int bitSize() {
-            return BIT_SIZE;
-        }
-
-        @Override
-        @ForceInline
-        public int length() {
-            return LENGTH;
-        }
-
-        @Override
-        @ForceInline
-        public Class<Byte> elementType() {
-            return byte.class;
-        }
-
-        @Override
-        @ForceInline
-        public Class<?> boxType() {
-            return Byte64Vector.class;
-        }
-
-        @Override
-        @ForceInline
-        public Class<?> maskType() {
-            return Byte64Mask.class;
-        }
-
-        @Override
-        @ForceInline
-        public int elementSize() {
-            return Byte.SIZE;
-        }
-
-        @Override
-        @ForceInline
-        @SuppressWarnings("unchecked")
-        Class<?> vectorType() {
-            return Byte64Vector.class;
-        }
-
-        @Override
-        @ForceInline
-        public Shape shape() {
-            return Shape.S_64_BIT;
-        }
-
-        @Override
-        Byte64Vector op(FOp f) {
-            byte[] res = new byte[length()];
-            for (int i = 0; i < length(); i++) {
-                res[i] = f.apply(i);
-            }
-            return new Byte64Vector(res);
-        }
-
-        @Override
-        Byte64Vector op(Mask<Byte> o, FOp f) {
-            byte[] res = new byte[length()];
-            boolean[] mbits = ((Byte64Mask)o).getBits();
-            for (int i = 0; i < length(); i++) {
-                if (mbits[i]) {
-                    res[i] = f.apply(i);
-                }
-            }
-            return new Byte64Vector(res);
-        }
-
-        @Override
-        Byte64Mask opm(FOpm f) {
-            boolean[] res = new boolean[length()];
-            for (int i = 0; i < length(); i++) {
-                res[i] = (boolean)f.apply(i);
-            }
-            return new Byte64Mask(res);
-        }
-
-        // Factories
-
-        @Override
-        @ForceInline
-        public Byte64Vector zero() {
-            return VectorIntrinsics.broadcastCoerced(Byte64Vector.class, byte.class, LENGTH,
-                                                     0, SPECIES,
-                                                     ((bits, s) -> ((Byte64Species)s).op(i -> (byte)bits)));
-        }
-
-        @Override
-        @ForceInline
-        public Byte64Vector broadcast(byte e) {
-            return VectorIntrinsics.broadcastCoerced(
-                Byte64Vector.class, byte.class, LENGTH,
-                e, SPECIES,
-                ((bits, s) -> ((Byte64Species)s).op(i -> (byte)bits)));
-        }
-
-        @Override
-        @ForceInline
-        public Byte64Vector scalars(byte... es) {
-            Objects.requireNonNull(es);
-            int ix = VectorIntrinsics.checkIndex(0, es.length, LENGTH);
-            return VectorIntrinsics.load(Byte64Vector.class, byte.class, LENGTH,
-                                         es, Unsafe.ARRAY_BYTE_BASE_OFFSET,
-                                         es, ix, SPECIES,
-                                         (c, idx, s) -> ((Byte64Species)s).op(n -> c[idx + n]));
-        }
-
-        @Override
-        @ForceInline
-        public <E> Byte64Mask cast(Mask<E> m) {
-            if (m.length() != LENGTH)
-                throw new IllegalArgumentException("Mask length this species length differ");
-            return new Byte64Mask(m.toArray());
-        }
-
-        @Override
-        @ForceInline
-        public <E> Byte64Shuffle cast(Shuffle<E> s) {
-            if (s.length() != LENGTH)
-                throw new IllegalArgumentException("Shuffle length this species length differ");
-            return new Byte64Shuffle(s.toArray());
-        }
-    }
 }