changeset 58930:6a27ea0ccb81 foreign+vector

Automatic merge with vectorIntrinsics
author mcimadamore
date Sat, 27 Apr 2019 00:59:32 +0200
parents 1a5f4e91dd21 54c20dc2769a
children 71c80ee9f770
files
diffstat 122 files changed, 9644 insertions(+), 5282 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java	Sat Apr 27 00:59:32 2019 +0200
@@ -125,7 +125,7 @@
         Class<?> eType = species.elementType();
 
         if (eType == byte.class) {
-            if (species.boxType() == ByteMaxVector.class)
+            if (species.vectorType() == ByteMaxVector.class)
                 return (VectorMask<E>) ByteMaxVector.ByteMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Byte64Vector.Byte64Mask.TRUE_MASK;
@@ -135,7 +135,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == short.class) {
-            if (species.boxType() == ShortMaxVector.class)
+            if (species.vectorType() == ShortMaxVector.class)
                 return (VectorMask<E>) ShortMaxVector.ShortMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Short64Vector.Short64Mask.TRUE_MASK;
@@ -145,7 +145,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == int.class) {
-            if (species.boxType() == IntMaxVector.class)
+            if (species.vectorType() == IntMaxVector.class)
                 return (VectorMask<E>) IntMaxVector.IntMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Int64Vector.Int64Mask.TRUE_MASK;
@@ -155,7 +155,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == long.class) {
-            if (species.boxType() == LongMaxVector.class)
+            if (species.vectorType() == LongMaxVector.class)
                 return (VectorMask<E>) LongMaxVector.LongMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Long64Vector.Long64Mask.TRUE_MASK;
@@ -165,7 +165,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == float.class) {
-            if (species.boxType() == FloatMaxVector.class)
+            if (species.vectorType() == FloatMaxVector.class)
                 return (VectorMask<E>) FloatMaxVector.FloatMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Float64Vector.Float64Mask.TRUE_MASK;
@@ -175,7 +175,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == double.class) {
-            if (species.boxType() == DoubleMaxVector.class)
+            if (species.vectorType() == DoubleMaxVector.class)
                 return (VectorMask<E>) DoubleMaxVector.DoubleMaxMask.TRUE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Double64Vector.Double64Mask.TRUE_MASK;
@@ -195,7 +195,7 @@
         Class<?> eType = species.elementType();
 
         if (eType == byte.class) {
-            if (species.boxType() == ByteMaxVector.class)
+            if (species.vectorType() == ByteMaxVector.class)
                 return (VectorMask<E>) ByteMaxVector.ByteMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Byte64Vector.Byte64Mask.FALSE_MASK;
@@ -205,7 +205,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == short.class) {
-            if (species.boxType() == ShortMaxVector.class)
+            if (species.vectorType() == ShortMaxVector.class)
                 return (VectorMask<E>) ShortMaxVector.ShortMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Short64Vector.Short64Mask.FALSE_MASK;
@@ -215,7 +215,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == int.class) {
-            if (species.boxType() == IntMaxVector.class)
+            if (species.vectorType() == IntMaxVector.class)
                 return (VectorMask<E>) IntMaxVector.IntMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Int64Vector.Int64Mask.FALSE_MASK;
@@ -225,7 +225,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == long.class) {
-            if (species.boxType() == LongMaxVector.class)
+            if (species.vectorType() == LongMaxVector.class)
                 return (VectorMask<E>) LongMaxVector.LongMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Long64Vector.Long64Mask.FALSE_MASK;
@@ -235,7 +235,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == float.class) {
-            if (species.boxType() == FloatMaxVector.class)
+            if (species.vectorType() == FloatMaxVector.class)
                 return (VectorMask<E>) FloatMaxVector.FloatMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Float64Vector.Float64Mask.FALSE_MASK;
@@ -245,7 +245,7 @@
                 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
             }
         } else if (eType == double.class) {
-            if (species.boxType() == DoubleMaxVector.class)
+            if (species.vectorType() == DoubleMaxVector.class)
                 return (VectorMask<E>) DoubleMaxVector.DoubleMaxMask.FALSE_MASK;
             switch (species.bitSize()) {
                 case 64: return (VectorMask<E>) Double64Vector.Double64Mask.FALSE_MASK;
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractSpecies.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractSpecies.java	Sat Apr 27 00:59:32 2019 +0200
@@ -46,14 +46,14 @@
     @Stable
     protected final int elementSize;
     @Stable
-    protected final Class<?> boxType;
+    protected final Class<?> vectorType;
     @Stable
     protected final Class<?> maskType;
     @Stable
     protected final VectorShape indexShape;
 
     AbstractSpecies(VectorShape shape, Class<E> elementType, int elementSize,
-                    Class<?> boxType, Class<?> maskType, Function<boolean[], VectorMask<E>> maskFactory,
+                    Class<?> vectorType, Class<?> maskType, Function<boolean[], VectorMask<E>> maskFactory,
                     Function<IntUnaryOperator, VectorShuffle<E>> shuffleFromOpFactory,
                     fShuffleFromArray<E> shuffleFromArrayFactory) {
 
@@ -64,13 +64,12 @@
         this.shape = shape;
         this.elementType = elementType;
         this.elementSize = elementSize;
-        this.boxType = boxType;
+        this.vectorType = vectorType;
         this.maskType = maskType;
 
-        if (boxType == Long64Vector.class || boxType == Double64Vector.class) {
+        if (vectorType == Long64Vector.class || vectorType == Double64Vector.class) {
             indexShape = VectorShape.S_64_BIT;
-        }
-        else {
+        } else {
             int bitSize = Vector.bitSizeForVectorLength(int.class, shape.bitSize() / elementSize);
             indexShape = VectorShape.forBitSize(bitSize);
         }
@@ -96,8 +95,8 @@
 
     @Override
     @ForceInline
-    public Class<?> boxType() {
-        return boxType;
+    public Class<?> vectorType() {
+        return vectorType;
     }
 
     @Override
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             Byte128Vector.class,
             byte.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -292,7 +292,7 @@
     @ForceInline
     public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte128Vector.class,
                 byte.class, LENGTH,
@@ -301,7 +301,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte128Vector.class,
                 byte.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte128Vector.class,
                 byte.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte128Vector.class,
                 byte.class, LENGTH,
@@ -329,7 +329,7 @@
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte128Vector.class,
                 byte.class, LENGTH,
@@ -656,48 +656,76 @@
 
     @Override
     @ForceInline
-    public Byte128Vector shiftL(int s) {
+    public Byte128Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Byte128Vector.class, byte.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
+            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte128Vector shiftL(int s, VectorMask<Byte> m) {
-        return blend(shiftL(s), m);
+    public Byte128Vector shiftLeft(int s, VectorMask<Byte> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte128Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Byte128Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
+    public Byte128Vector shiftLeft(Vector<Byte> s) {
+        Byte128Vector shiftv = (Byte128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a << (b & 0x7)));
     }
 
     @Override
     @ForceInline
-    public Byte128Vector shiftR(int s, VectorMask<Byte> m) {
-        return blend(shiftR(s), m);
+    public Byte128Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Byte128Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte128Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Byte128Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
+    public Byte128Vector shiftRight(int s, VectorMask<Byte> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte128Vector aShiftR(int s, VectorMask<Byte> m) {
-        return blend(aShiftR(s), m);
+    public Byte128Vector shiftRight(Vector<Byte> s) {
+        Byte128Vector shiftv = (Byte128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >>> (b & 0x7)));
     }
+
+    @Override
+    @ForceInline
+    public Byte128Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Byte128Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 0x7))));
+    }
+
+    @Override
+    @ForceInline
+    public Byte128Vector shiftArithmeticRight(int s, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Byte128Vector shiftArithmeticRight(Vector<Byte> s) {
+        Byte128Vector shiftv = (Byte128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >> (b & 0x7)));
+    }
+
     // Ternary operations
 
 
@@ -705,7 +733,7 @@
 
     @Override
     @ForceInline
-    public byte addAll() {
+    public byte addLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -714,7 +742,7 @@
 
     @Override
     @ForceInline
-    public byte andAll() {
+    public byte andLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -723,13 +751,13 @@
 
     @Override
     @ForceInline
-    public byte andAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andAll();
+    public byte andLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll() {
+    public byte minLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -738,7 +766,7 @@
 
     @Override
     @ForceInline
-    public byte maxAll() {
+    public byte maxLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -747,7 +775,7 @@
 
     @Override
     @ForceInline
-    public byte mulAll() {
+    public byte mulLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -756,7 +784,7 @@
 
     @Override
     @ForceInline
-    public byte orAll() {
+    public byte orLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -765,13 +793,13 @@
 
     @Override
     @ForceInline
-    public byte orAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orAll();
+    public byte orLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public byte xorAll() {
+    public byte xorLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Byte128Vector.class, byte.class, LENGTH,
             this,
@@ -780,34 +808,34 @@
 
     @Override
     @ForceInline
-    public byte xorAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorAll();
+    public byte xorLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addAll();
+    public byte addLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulAll();
+    public byte mulLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minAll();
+    public byte minLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxAll();
+    public byte maxLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1028,7 +1056,7 @@
 
 
     @Override
-    public Byte128Vector rotateEL(int j) {
+    public Byte128Vector rotateLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1038,7 +1066,7 @@
     }
 
     @Override
-    public Byte128Vector rotateER(int j) {
+    public Byte128Vector rotateLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1053,7 +1081,7 @@
     }
 
     @Override
-    public Byte128Vector shiftEL(int j) {
+    public Byte128Vector shiftLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1063,7 +1091,7 @@
     }
 
     @Override
-    public Byte128Vector shiftER(int j) {
+    public Byte128Vector shiftLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             Byte256Vector.class,
             byte.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -292,7 +292,7 @@
     @ForceInline
     public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte256Vector.class,
                 byte.class, LENGTH,
@@ -301,7 +301,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte256Vector.class,
                 byte.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte256Vector.class,
                 byte.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte256Vector.class,
                 byte.class, LENGTH,
@@ -329,7 +329,7 @@
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte256Vector.class,
                 byte.class, LENGTH,
@@ -656,48 +656,76 @@
 
     @Override
     @ForceInline
-    public Byte256Vector shiftL(int s) {
+    public Byte256Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Byte256Vector.class, byte.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
+            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte256Vector shiftL(int s, VectorMask<Byte> m) {
-        return blend(shiftL(s), m);
+    public Byte256Vector shiftLeft(int s, VectorMask<Byte> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte256Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Byte256Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
+    public Byte256Vector shiftLeft(Vector<Byte> s) {
+        Byte256Vector shiftv = (Byte256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a << (b & 0x7)));
     }
 
     @Override
     @ForceInline
-    public Byte256Vector shiftR(int s, VectorMask<Byte> m) {
-        return blend(shiftR(s), m);
+    public Byte256Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Byte256Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte256Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Byte256Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
+    public Byte256Vector shiftRight(int s, VectorMask<Byte> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte256Vector aShiftR(int s, VectorMask<Byte> m) {
-        return blend(aShiftR(s), m);
+    public Byte256Vector shiftRight(Vector<Byte> s) {
+        Byte256Vector shiftv = (Byte256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >>> (b & 0x7)));
     }
+
+    @Override
+    @ForceInline
+    public Byte256Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Byte256Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 0x7))));
+    }
+
+    @Override
+    @ForceInline
+    public Byte256Vector shiftArithmeticRight(int s, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Byte256Vector shiftArithmeticRight(Vector<Byte> s) {
+        Byte256Vector shiftv = (Byte256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >> (b & 0x7)));
+    }
+
     // Ternary operations
 
 
@@ -705,7 +733,7 @@
 
     @Override
     @ForceInline
-    public byte addAll() {
+    public byte addLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -714,7 +742,7 @@
 
     @Override
     @ForceInline
-    public byte andAll() {
+    public byte andLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -723,13 +751,13 @@
 
     @Override
     @ForceInline
-    public byte andAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andAll();
+    public byte andLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll() {
+    public byte minLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -738,7 +766,7 @@
 
     @Override
     @ForceInline
-    public byte maxAll() {
+    public byte maxLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -747,7 +775,7 @@
 
     @Override
     @ForceInline
-    public byte mulAll() {
+    public byte mulLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -756,7 +784,7 @@
 
     @Override
     @ForceInline
-    public byte orAll() {
+    public byte orLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -765,13 +793,13 @@
 
     @Override
     @ForceInline
-    public byte orAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orAll();
+    public byte orLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public byte xorAll() {
+    public byte xorLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Byte256Vector.class, byte.class, LENGTH,
             this,
@@ -780,34 +808,34 @@
 
     @Override
     @ForceInline
-    public byte xorAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorAll();
+    public byte xorLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addAll();
+    public byte addLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulAll();
+    public byte mulLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minAll();
+    public byte minLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxAll();
+    public byte maxLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1028,7 +1056,7 @@
 
 
     @Override
-    public Byte256Vector rotateEL(int j) {
+    public Byte256Vector rotateLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1038,7 +1066,7 @@
     }
 
     @Override
-    public Byte256Vector rotateER(int j) {
+    public Byte256Vector rotateLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1053,7 +1081,7 @@
     }
 
     @Override
-    public Byte256Vector shiftEL(int j) {
+    public Byte256Vector shiftLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1063,7 +1091,7 @@
     }
 
     @Override
-    public Byte256Vector shiftER(int j) {
+    public Byte256Vector shiftLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             Byte512Vector.class,
             byte.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -292,7 +292,7 @@
     @ForceInline
     public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte512Vector.class,
                 byte.class, LENGTH,
@@ -301,7 +301,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte512Vector.class,
                 byte.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte512Vector.class,
                 byte.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte512Vector.class,
                 byte.class, LENGTH,
@@ -329,7 +329,7 @@
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte512Vector.class,
                 byte.class, LENGTH,
@@ -656,48 +656,76 @@
 
     @Override
     @ForceInline
-    public Byte512Vector shiftL(int s) {
+    public Byte512Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Byte512Vector.class, byte.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
+            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte512Vector shiftL(int s, VectorMask<Byte> m) {
-        return blend(shiftL(s), m);
+    public Byte512Vector shiftLeft(int s, VectorMask<Byte> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte512Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Byte512Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
+    public Byte512Vector shiftLeft(Vector<Byte> s) {
+        Byte512Vector shiftv = (Byte512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a << (b & 0x7)));
     }
 
     @Override
     @ForceInline
-    public Byte512Vector shiftR(int s, VectorMask<Byte> m) {
-        return blend(shiftR(s), m);
+    public Byte512Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Byte512Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte512Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Byte512Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
+    public Byte512Vector shiftRight(int s, VectorMask<Byte> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte512Vector aShiftR(int s, VectorMask<Byte> m) {
-        return blend(aShiftR(s), m);
+    public Byte512Vector shiftRight(Vector<Byte> s) {
+        Byte512Vector shiftv = (Byte512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >>> (b & 0x7)));
     }
+
+    @Override
+    @ForceInline
+    public Byte512Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Byte512Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 0x7))));
+    }
+
+    @Override
+    @ForceInline
+    public Byte512Vector shiftArithmeticRight(int s, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Byte512Vector shiftArithmeticRight(Vector<Byte> s) {
+        Byte512Vector shiftv = (Byte512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >> (b & 0x7)));
+    }
+
     // Ternary operations
 
 
@@ -705,7 +733,7 @@
 
     @Override
     @ForceInline
-    public byte addAll() {
+    public byte addLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -714,7 +742,7 @@
 
     @Override
     @ForceInline
-    public byte andAll() {
+    public byte andLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -723,13 +751,13 @@
 
     @Override
     @ForceInline
-    public byte andAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andAll();
+    public byte andLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll() {
+    public byte minLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -738,7 +766,7 @@
 
     @Override
     @ForceInline
-    public byte maxAll() {
+    public byte maxLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -747,7 +775,7 @@
 
     @Override
     @ForceInline
-    public byte mulAll() {
+    public byte mulLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -756,7 +784,7 @@
 
     @Override
     @ForceInline
-    public byte orAll() {
+    public byte orLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -765,13 +793,13 @@
 
     @Override
     @ForceInline
-    public byte orAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orAll();
+    public byte orLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public byte xorAll() {
+    public byte xorLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Byte512Vector.class, byte.class, LENGTH,
             this,
@@ -780,34 +808,34 @@
 
     @Override
     @ForceInline
-    public byte xorAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorAll();
+    public byte xorLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addAll();
+    public byte addLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulAll();
+    public byte mulLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minAll();
+    public byte minLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxAll();
+    public byte maxLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1028,7 +1056,7 @@
 
 
     @Override
-    public Byte512Vector rotateEL(int j) {
+    public Byte512Vector rotateLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1038,7 +1066,7 @@
     }
 
     @Override
-    public Byte512Vector rotateER(int j) {
+    public Byte512Vector rotateLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1053,7 +1081,7 @@
     }
 
     @Override
-    public Byte512Vector shiftEL(int j) {
+    public Byte512Vector shiftLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1063,7 +1091,7 @@
     }
 
     @Override
-    public Byte512Vector shiftER(int j) {
+    public Byte512Vector shiftLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             Byte64Vector.class,
             byte.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -292,7 +292,7 @@
     @ForceInline
     public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
@@ -301,7 +301,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
@@ -329,7 +329,7 @@
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Byte64Vector.class,
                 byte.class, LENGTH,
@@ -656,48 +656,76 @@
 
     @Override
     @ForceInline
-    public Byte64Vector shiftL(int s) {
+    public Byte64Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Byte64Vector.class, byte.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
+            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte64Vector shiftL(int s, VectorMask<Byte> m) {
-        return blend(shiftL(s), m);
+    public Byte64Vector shiftLeft(int s, VectorMask<Byte> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte64Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Byte64Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
+    public Byte64Vector shiftLeft(Vector<Byte> s) {
+        Byte64Vector shiftv = (Byte64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a << (b & 0x7)));
     }
 
     @Override
     @ForceInline
-    public Byte64Vector shiftR(int s, VectorMask<Byte> m) {
-        return blend(shiftR(s), m);
+    public Byte64Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Byte64Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public Byte64Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Byte64Vector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
+    public Byte64Vector shiftRight(int s, VectorMask<Byte> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte64Vector aShiftR(int s, VectorMask<Byte> m) {
-        return blend(aShiftR(s), m);
+    public Byte64Vector shiftRight(Vector<Byte> s) {
+        Byte64Vector shiftv = (Byte64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >>> (b & 0x7)));
     }
+
+    @Override
+    @ForceInline
+    public Byte64Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Byte64Vector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 0x7))));
+    }
+
+    @Override
+    @ForceInline
+    public Byte64Vector shiftArithmeticRight(int s, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Byte64Vector shiftArithmeticRight(Vector<Byte> s) {
+        Byte64Vector shiftv = (Byte64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >> (b & 0x7)));
+    }
+
     // Ternary operations
 
 
@@ -705,7 +733,7 @@
 
     @Override
     @ForceInline
-    public byte addAll() {
+    public byte addLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -714,7 +742,7 @@
 
     @Override
     @ForceInline
-    public byte andAll() {
+    public byte andLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -723,13 +751,13 @@
 
     @Override
     @ForceInline
-    public byte andAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andAll();
+    public byte andLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll() {
+    public byte minLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -738,7 +766,7 @@
 
     @Override
     @ForceInline
-    public byte maxAll() {
+    public byte maxLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -747,7 +775,7 @@
 
     @Override
     @ForceInline
-    public byte mulAll() {
+    public byte mulLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -756,7 +784,7 @@
 
     @Override
     @ForceInline
-    public byte orAll() {
+    public byte orLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -765,13 +793,13 @@
 
     @Override
     @ForceInline
-    public byte orAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orAll();
+    public byte orLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public byte xorAll() {
+    public byte xorLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Byte64Vector.class, byte.class, LENGTH,
             this,
@@ -780,34 +808,34 @@
 
     @Override
     @ForceInline
-    public byte xorAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorAll();
+    public byte xorLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addAll();
+    public byte addLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulAll();
+    public byte mulLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minAll();
+    public byte minLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxAll();
+    public byte maxLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1028,7 +1056,7 @@
 
 
     @Override
-    public Byte64Vector rotateEL(int j) {
+    public Byte64Vector rotateLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1038,7 +1066,7 @@
     }
 
     @Override
-    public Byte64Vector rotateER(int j) {
+    public Byte64Vector rotateLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1053,7 +1081,7 @@
     }
 
     @Override
-    public Byte64Vector shiftEL(int j) {
+    public Byte64Vector shiftLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1063,7 +1091,7 @@
     }
 
     @Override
-    public Byte64Vector shiftER(int j) {
+    public Byte64Vector shiftLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -154,7 +154,7 @@
         return VectorIntrinsics.cast(
             ByteMaxVector.class,
             byte.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -292,7 +292,7 @@
     @ForceInline
     public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ByteMaxVector.class,
                 byte.class, LENGTH,
@@ -301,7 +301,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Byte128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Byte128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ByteMaxVector.class,
                 byte.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Byte256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Byte256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ByteMaxVector.class,
                 byte.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Byte512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Byte512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ByteMaxVector.class,
                 byte.class, LENGTH,
@@ -329,7 +329,7 @@
                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ByteMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ByteMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 ByteMaxVector.class,
                 byte.class, LENGTH,
@@ -656,48 +656,76 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftL(int s) {
+    public ByteMaxVector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, ByteMaxVector.class, byte.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
+            (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftL(int s, VectorMask<Byte> m) {
-        return blend(shiftL(s), m);
+    public ByteMaxVector shiftLeft(int s, VectorMask<Byte> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, ByteMaxVector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
+    public ByteMaxVector shiftLeft(Vector<Byte> s) {
+        ByteMaxVector shiftv = (ByteMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a << (b & 0x7)));
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftR(int s, VectorMask<Byte> m) {
-        return blend(shiftR(s), m);
+    public ByteMaxVector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, ByteMaxVector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 0x7))));
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, ByteMaxVector.class, byte.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
+    public ByteMaxVector shiftRight(int s, VectorMask<Byte> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector aShiftR(int s, VectorMask<Byte> m) {
-        return blend(aShiftR(s), m);
+    public ByteMaxVector shiftRight(Vector<Byte> s) {
+        ByteMaxVector shiftv = (ByteMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >>> (b & 0x7)));
     }
+
+    @Override
+    @ForceInline
+    public ByteMaxVector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, ByteMaxVector.class, byte.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 0x7))));
+    }
+
+    @Override
+    @ForceInline
+    public ByteMaxVector shiftArithmeticRight(int s, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public ByteMaxVector shiftArithmeticRight(Vector<Byte> s) {
+        ByteMaxVector shiftv = (ByteMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ByteVector.broadcast(SPECIES, (byte) 0x7));
+        return this.bOp(shiftv, (i, a, b) -> (byte) (a >> (b & 0x7)));
+    }
+
     // Ternary operations
 
 
@@ -705,7 +733,7 @@
 
     @Override
     @ForceInline
-    public byte addAll() {
+    public byte addLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -714,7 +742,7 @@
 
     @Override
     @ForceInline
-    public byte andAll() {
+    public byte andLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -723,13 +751,13 @@
 
     @Override
     @ForceInline
-    public byte andAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andAll();
+    public byte andLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll() {
+    public byte minLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -738,7 +766,7 @@
 
     @Override
     @ForceInline
-    public byte maxAll() {
+    public byte maxLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -747,7 +775,7 @@
 
     @Override
     @ForceInline
-    public byte mulAll() {
+    public byte mulLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -756,7 +784,7 @@
 
     @Override
     @ForceInline
-    public byte orAll() {
+    public byte orLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -765,13 +793,13 @@
 
     @Override
     @ForceInline
-    public byte orAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orAll();
+    public byte orLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public byte xorAll() {
+    public byte xorLanes() {
         return (byte) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, ByteMaxVector.class, byte.class, LENGTH,
             this,
@@ -780,34 +808,34 @@
 
     @Override
     @ForceInline
-    public byte xorAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorAll();
+    public byte xorLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addAll();
+    public byte addLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulAll();
+    public byte mulLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, (byte) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public byte minAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minAll();
+    public byte minLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(VectorMask<Byte> m) {
-        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxAll();
+    public byte maxLanes(VectorMask<Byte> m) {
+        return ByteVector.broadcast(SPECIES, Byte.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1028,7 +1056,7 @@
 
 
     @Override
-    public ByteMaxVector rotateEL(int j) {
+    public ByteMaxVector rotateLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1038,7 +1066,7 @@
     }
 
     @Override
-    public ByteMaxVector rotateER(int j) {
+    public ByteMaxVector rotateLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length(); i++){
@@ -1053,7 +1081,7 @@
     }
 
     @Override
-    public ByteMaxVector shiftEL(int j) {
+    public ByteMaxVector shiftLanesLeft(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1063,7 +1091,7 @@
     }
 
     @Override
-    public ByteMaxVector shiftER(int j) {
+    public ByteMaxVector shiftLanesRight(int j) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -111,7 +111,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static ByteVector zero(VectorSpecies<Byte> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<ByteVector>) species.boxType(), byte.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<ByteVector>) species.vectorType(), byte.class, species.length(),
                                                  0, species,
                                                  ((bits, s) -> ((ByteSpecies)s).op(i -> (byte)bits)));
     }
@@ -141,7 +141,7 @@
     public static ByteVector fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
+        return VectorIntrinsics.load((Class<ByteVector>) species.vectorType(), byte.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -199,7 +199,7 @@
     public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
+        return VectorIntrinsics.load((Class<ByteVector>) species.vectorType(), byte.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((ByteSpecies)s).op(n -> c[idx + n]));
@@ -312,7 +312,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
+        return VectorIntrinsics.load((Class<ByteVector>) species.vectorType(), byte.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -368,7 +368,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -376,7 +376,7 @@
     @SuppressWarnings("unchecked")
     public static ByteVector broadcast(VectorSpecies<Byte> species, byte e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<ByteVector>) species.boxType(), byte.class, species.length(),
+            (Class<ByteVector>) species.vectorType(), byte.class, species.length(),
             e, species,
             ((bits, sp) -> ((ByteSpecies)sp).op(i -> (byte)bits)));
     }
@@ -400,7 +400,7 @@
     public static ByteVector scalars(VectorSpecies<Byte> species, byte... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
+        return VectorIntrinsics.load((Class<ByteVector>) species.vectorType(), byte.class, species.length(),
                                      es, Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((ByteSpecies)sp).op(n -> c[idx + n]));
@@ -778,25 +778,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract ByteVector rotateEL(int i);
+    public abstract ByteVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ByteVector rotateER(int i);
+    public abstract ByteVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ByteVector shiftEL(int i);
+    public abstract ByteVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ByteVector shiftER(int i);
+    public abstract ByteVector shiftLanesRight(int i);
 
 
 
@@ -976,16 +976,16 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
      * operation ({@code <<}) to each lane 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
+     * 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 ({@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
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftL(int s);
+    public abstract ByteVector shiftLeft(int s);
 
     /**
      * Logically left shifts this vector by the broadcast of an input scalar,
@@ -993,18 +993,53 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
      * operation ({@code <<}) to each lane 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
+     * 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 ({@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
      * @param m the mask controlling lane selection
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftL(int s, VectorMask<Byte> m);
+    public abstract ByteVector shiftLeft(int s, VectorMask<Byte> m);
 
+    /**
+     * Logically left shifts this vector by an input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical left shift
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of logically left shifting this vector by the input
+     * vector
+     */
+    public abstract ByteVector shiftLeft(Vector<Byte> v);
+
+    /**
+     * Logically left shifts this vector by an input vector, selecting lane
+     * elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical left shift
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of logically left shifting this vector by the input
+     * vector
+     */
+    public ByteVector shiftLeft(Vector<Byte> v, VectorMask<Byte> m) {
+        return blend(shiftLeft(v), m);
+    }
 
     // logical, or unsigned, shift right
 
@@ -1014,8 +1049,8 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
      * operation ({@code >>>}) to each lane 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
+     * 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 ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
@@ -1023,7 +1058,7 @@
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftR(int s);
+    public abstract ByteVector shiftRight(int s);
 
      /**
      * Logically right shifts (or unsigned right shifts) this vector by the
@@ -1032,8 +1067,8 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
      * operation ({@code >>}) to each lane 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
+     * 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 ({@code &}) with the mask value 0x7.
      * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
      *
@@ -1042,8 +1077,44 @@
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftR(int s, VectorMask<Byte> m);
+    public abstract ByteVector shiftRight(int s, VectorMask<Byte> m);
 
+    /**
+     * Logically right shifts (or unsigned right shifts) this vector by an
+     * input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical right shift
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of logically right shifting this vector by the
+     * input vector
+     */
+    public abstract ByteVector shiftRight(Vector<Byte> v);
+
+    /**
+     * Logically right shifts (or unsigned right shifts) this vector by an
+     * input vector, selecting lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical right shift
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of logically right shifting this vector by the
+     * input vector
+     */
+    public ByteVector shiftRight(Vector<Byte> v, VectorMask<Byte> m) {
+        return blend(shiftRight(v), m);
+    }
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1060,7 +1131,7 @@
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector aShiftR(int s);
+    public abstract ByteVector shiftArithmeticRight(int s);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1079,8 +1150,120 @@
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector aShiftR(int s, VectorMask<Byte> m);
+    public abstract ByteVector shiftArithmeticRight(int s, VectorMask<Byte> m);
 
+    /**
+     * Arithmetically right shifts (or signed right shifts) this vector by an
+     * input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive arithmetic right
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of arithmetically right shifting this vector by the
+     * input vector
+     */
+    public abstract ByteVector shiftArithmeticRight(Vector<Byte> v);
+
+    /**
+     * Arithmetically right shifts (or signed right shifts) this vector by an
+     * input vector, selecting lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive arithmetic right
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0x7.
+     * The shift distance actually used is therefore always in the range 0 to 7, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of arithmetically right shifting this vector by the
+     * input vector
+     */
+    public ByteVector shiftArithmeticRight(Vector<Byte> v, VectorMask<Byte> m) {
+        return blend(shiftArithmeticRight(v), m);
+    }
+
+    /**
+     * Rotates left this vector by the broadcast of an input scalar.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating left the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0x7.
+     *
+     * @param s the input scalar; the number of the bits to rotate left
+     * @return the result of rotating left this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ByteVector rotateLeft(int s) {
+        return shiftLeft(s).or(shiftRight(-s));
+    }
+
+    /**
+     * Rotates left this vector by the broadcast of an input scalar, selecting
+     * lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating left the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0x7.
+     *
+     * @param s the input scalar; the number of the bits to rotate left
+     * @param m the mask controlling lane selection
+     * @return the result of rotating left this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ByteVector rotateLeft(int s, VectorMask<Byte> m) {
+        return shiftLeft(s, m).or(shiftRight(-s, m), m);
+    }
+
+    /**
+     * Rotates right this vector by the broadcast of an input scalar.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating right the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0x7.
+     *
+     * @param s the input scalar; the number of the bits to rotate right
+     * @return the result of rotating right this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ByteVector rotateRight(int s) {
+        return shiftRight(s).or(shiftLeft(-s));
+    }
+
+    /**
+     * Rotates right this vector by the broadcast of an input scalar, selecting
+     * lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating right the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0x7.
+     *
+     * @param s the input scalar; the number of the bits to rotate right
+     * @param m the mask controlling lane selection
+     * @return the result of rotating right this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ByteVector rotateRight(int s, VectorMask<Byte> m) {
+        return shiftRight(s, m).or(shiftLeft(-s, m), m);
+    }
 
     /**
      * {@inheritDoc}
@@ -1117,7 +1300,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract byte addAll();
+    public abstract byte addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1130,7 +1313,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract byte addAll(VectorMask<Byte> m);
+    public abstract byte addLanes(VectorMask<Byte> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1141,7 +1324,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract byte mulAll();
+    public abstract byte mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1154,7 +1337,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract byte mulAll(VectorMask<Byte> m);
+    public abstract byte mulLanes(VectorMask<Byte> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1166,7 +1349,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract byte minAll();
+    public abstract byte minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1180,7 +1363,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract byte minAll(VectorMask<Byte> m);
+    public abstract byte minLanes(VectorMask<Byte> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1192,7 +1375,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract byte maxAll();
+    public abstract byte maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1206,7 +1389,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract byte maxAll(VectorMask<Byte> m);
+    public abstract byte maxLanes(VectorMask<Byte> m);
 
     /**
      * Logically ORs all lane elements of this vector.
@@ -1217,7 +1400,7 @@
      *
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract byte orAll();
+    public abstract byte orLanes();
 
     /**
      * Logically ORs all lane elements of this vector, selecting lane elements
@@ -1230,7 +1413,7 @@
      * @param m the mask controlling lane selection
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract byte orAll(VectorMask<Byte> m);
+    public abstract byte orLanes(VectorMask<Byte> m);
 
     /**
      * Logically ANDs all lane elements of this vector.
@@ -1241,7 +1424,7 @@
      *
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract byte andAll();
+    public abstract byte andLanes();
 
     /**
      * Logically ANDs all lane elements of this vector, selecting lane elements
@@ -1254,7 +1437,7 @@
      * @param m the mask controlling lane selection
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract byte andAll(VectorMask<Byte> m);
+    public abstract byte andLanes(VectorMask<Byte> m);
 
     /**
      * Logically XORs all lane elements of this vector.
@@ -1265,7 +1448,7 @@
      *
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract byte xorAll();
+    public abstract byte xorLanes();
 
     /**
      * Logically XORs all lane elements of this vector, selecting lane elements
@@ -1278,7 +1461,7 @@
      * @param m the mask controlling lane selection
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract byte xorAll(VectorMask<Byte> m);
+    public abstract byte xorLanes(VectorMask<Byte> m);
 
     // Type specific accessors
 
@@ -1425,13 +1608,13 @@
         final Function<byte[], ByteVector> vectorFactory;
 
         private ByteSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<byte[], ByteVector> vectorFactory,
                           Function<boolean[], VectorMask<Byte>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Byte>> shuffleFromArrayFactory,
                           fShuffleFromArray<Byte> shuffleFromOpFactory) {
-            super(shape, byte.class, Byte.SIZE, boxType, maskType, maskFactory,
+            super(shape, byte.class, Byte.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Double128Vector.class,
             double.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double128Vector.class,
                 double.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Double128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double128Vector.class,
                 double.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Double256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double128Vector.class,
                 double.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Double512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Double512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double128Vector.class,
                 double.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == DoubleMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == DoubleMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double128Vector.class,
                 double.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public double addAll() {
+    public double addLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Double128Vector.class, double.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public double mulAll() {
+    public double mulLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double128Vector.class, double.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public double minAll() {
+    public double minLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Double128Vector.class, double.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public double maxAll() {
+    public double maxLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Double128Vector.class, double.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public double addAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addAll();
+    public double addLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulAll();
+    public double mulLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public double minAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minAll();
+    public double minLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public double maxAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxAll();
+    public double maxLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Double128Vector rotateEL(int j) {
+    public Double128Vector rotateLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Double128Vector rotateER(int j) {
+    public Double128Vector rotateLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Double128Vector shiftEL(int j) {
+    public Double128Vector shiftLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Double128Vector shiftER(int j) {
+    public Double128Vector shiftLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Double256Vector.class,
             double.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double256Vector.class,
                 double.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Double128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double256Vector.class,
                 double.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Double256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double256Vector.class,
                 double.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Double512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Double512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double256Vector.class,
                 double.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == DoubleMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == DoubleMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double256Vector.class,
                 double.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public double addAll() {
+    public double addLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Double256Vector.class, double.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public double mulAll() {
+    public double mulLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double256Vector.class, double.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public double minAll() {
+    public double minLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Double256Vector.class, double.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public double maxAll() {
+    public double maxLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Double256Vector.class, double.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public double addAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addAll();
+    public double addLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulAll();
+    public double mulLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public double minAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minAll();
+    public double minLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public double maxAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxAll();
+    public double maxLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Double256Vector rotateEL(int j) {
+    public Double256Vector rotateLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Double256Vector rotateER(int j) {
+    public Double256Vector rotateLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Double256Vector shiftEL(int j) {
+    public Double256Vector shiftLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Double256Vector shiftER(int j) {
+    public Double256Vector shiftLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Double512Vector.class,
             double.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double512Vector.class,
                 double.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Double128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double512Vector.class,
                 double.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Double256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double512Vector.class,
                 double.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Double512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Double512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double512Vector.class,
                 double.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == DoubleMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == DoubleMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double512Vector.class,
                 double.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public double addAll() {
+    public double addLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Double512Vector.class, double.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public double mulAll() {
+    public double mulLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double512Vector.class, double.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public double minAll() {
+    public double minLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Double512Vector.class, double.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public double maxAll() {
+    public double maxLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Double512Vector.class, double.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public double addAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addAll();
+    public double addLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulAll();
+    public double mulLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public double minAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minAll();
+    public double minLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public double maxAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxAll();
+    public double maxLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Double512Vector rotateEL(int j) {
+    public Double512Vector rotateLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Double512Vector rotateER(int j) {
+    public Double512Vector rotateLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Double512Vector shiftEL(int j) {
+    public Double512Vector shiftLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Double512Vector shiftER(int j) {
+    public Double512Vector shiftLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -162,7 +162,7 @@
         return VectorIntrinsics.cast(
             Double64Vector.class,
             double.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -300,7 +300,7 @@
     @ForceInline
     public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double64Vector.class,
                 double.class, LENGTH,
@@ -309,7 +309,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Double128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double64Vector.class,
                 double.class, LENGTH,
@@ -318,7 +318,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Double256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double64Vector.class,
                 double.class, LENGTH,
@@ -327,7 +327,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Double512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Double512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double64Vector.class,
                 double.class, LENGTH,
@@ -337,7 +337,7 @@
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == DoubleMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == DoubleMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Double64Vector.class,
                 double.class, LENGTH,
@@ -838,7 +838,7 @@
 
     @Override
     @ForceInline
-    public double addAll() {
+    public double addLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Double64Vector.class, double.class, LENGTH,
                                 this,
@@ -851,7 +851,7 @@
 
     @Override
     @ForceInline
-    public double mulAll() {
+    public double mulLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Double64Vector.class, double.class, LENGTH,
                                 this,
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public double minAll() {
+    public double minLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Double64Vector.class, double.class, LENGTH,
                                 this,
@@ -877,7 +877,7 @@
 
     @Override
     @ForceInline
-    public double maxAll() {
+    public double maxLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Double64Vector.class, double.class, LENGTH,
                                 this,
@@ -891,27 +891,27 @@
 
     @Override
     @ForceInline
-    public double addAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addAll();
+    public double addLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulAll();
+    public double mulLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public double minAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minAll();
+    public double minLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public double maxAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxAll();
+    public double maxLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1154,7 +1154,7 @@
 
 
     @Override
-    public Double64Vector rotateEL(int j) {
+    public Double64Vector rotateLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1164,7 +1164,7 @@
     }
 
     @Override
-    public Double64Vector rotateER(int j) {
+    public Double64Vector rotateLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1179,7 +1179,7 @@
     }
 
     @Override
-    public Double64Vector shiftEL(int j) {
+    public Double64Vector shiftLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1189,7 +1189,7 @@
     }
 
     @Override
-    public Double64Vector shiftER(int j) {
+    public Double64Vector shiftLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             DoubleMaxVector.class,
             double.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 DoubleMaxVector.class,
                 double.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Double128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 DoubleMaxVector.class,
                 double.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Double256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 DoubleMaxVector.class,
                 double.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Double512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Double512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 DoubleMaxVector.class,
                 double.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == DoubleMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == DoubleMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 DoubleMaxVector.class,
                 double.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public double addAll() {
+    public double addLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, DoubleMaxVector.class, double.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public double mulAll() {
+    public double mulLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, DoubleMaxVector.class, double.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public double minAll() {
+    public double minLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, DoubleMaxVector.class, double.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public double maxAll() {
+    public double maxLanes() {
         long bits = (long) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, DoubleMaxVector.class, double.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public double addAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addAll();
+    public double addLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulAll();
+    public double mulLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, (double) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public double minAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minAll();
+    public double minLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public double maxAll(VectorMask<Double> m) {
-        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxAll();
+    public double maxLanes(VectorMask<Double> m) {
+        return DoubleVector.broadcast(SPECIES, Double.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public DoubleMaxVector rotateEL(int j) {
+    public DoubleMaxVector rotateLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public DoubleMaxVector rotateER(int j) {
+    public DoubleMaxVector rotateLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public DoubleMaxVector shiftEL(int j) {
+    public DoubleMaxVector shiftLanesLeft(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public DoubleMaxVector shiftER(int j) {
+    public DoubleMaxVector shiftLanesRight(int j) {
         double[] vec = getElements();
         double[] res = new double[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -112,7 +112,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static DoubleVector zero(VectorSpecies<Double> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<DoubleVector>) species.boxType(), double.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
                                                  Double.doubleToLongBits(0.0f), species,
                                                  ((bits, s) -> ((DoubleSpecies)s).op(i -> Double.longBitsToDouble((long)bits))));
     }
@@ -142,7 +142,7 @@
     public static DoubleVector fromByteArray(VectorSpecies<Double> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
+        return VectorIntrinsics.load((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -200,7 +200,7 @@
     public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
+        return VectorIntrinsics.load((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((DoubleSpecies)s).op(n -> c[idx + n]));
@@ -266,8 +266,8 @@
 
         vix = VectorIntrinsics.checkIndex(vix, a.length);
 
-        return VectorIntrinsics.loadWithMap((Class<DoubleVector>) species.boxType(), double.class, species.length(),
-                                            IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
+        return VectorIntrinsics.loadWithMap((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
+                                            IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
                                             a, a_offset, indexMap, i_offset, species,
                                             (double[] c, int idx, int[] iMap, int idy, VectorSpecies<Double> s) ->
                                                 ((DoubleSpecies)s).op(n -> c[idx + iMap[idy+n]]));
@@ -336,7 +336,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
+        return VectorIntrinsics.load((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -392,7 +392,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -400,7 +400,7 @@
     @SuppressWarnings("unchecked")
     public static DoubleVector broadcast(VectorSpecies<Double> species, double e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<DoubleVector>) species.boxType(), double.class, species.length(),
+            (Class<DoubleVector>) species.vectorType(), double.class, species.length(),
             Double.doubleToLongBits(e), species,
             ((bits, sp) -> ((DoubleSpecies)sp).op(i -> Double.longBitsToDouble((long)bits))));
     }
@@ -424,7 +424,7 @@
     public static DoubleVector scalars(VectorSpecies<Double> species, double... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
+        return VectorIntrinsics.load((Class<DoubleVector>) species.vectorType(), double.class, species.length(),
                                      es, Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((DoubleSpecies)sp).op(n -> c[idx + n]));
@@ -802,25 +802,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract DoubleVector rotateEL(int i);
+    public abstract DoubleVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract DoubleVector rotateER(int i);
+    public abstract DoubleVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract DoubleVector shiftEL(int i);
+    public abstract DoubleVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract DoubleVector shiftER(int i);
+    public abstract DoubleVector shiftLanesRight(int i);
 
     /**
      * Divides this vector by an input vector.
@@ -1722,7 +1722,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract double addAll();
+    public abstract double addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1744,7 +1744,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract double addAll(VectorMask<Double> m);
+    public abstract double addLanes(VectorMask<Double> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1763,7 +1763,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract double mulAll();
+    public abstract double mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1784,7 +1784,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract double mulAll(VectorMask<Double> m);
+    public abstract double mulLanes(VectorMask<Double> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1796,7 +1796,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract double minAll();
+    public abstract double minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1810,7 +1810,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract double minAll(VectorMask<Double> m);
+    public abstract double minLanes(VectorMask<Double> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1822,7 +1822,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract double maxAll();
+    public abstract double maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1836,7 +1836,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract double maxAll(VectorMask<Double> m);
+    public abstract double maxLanes(VectorMask<Double> m);
 
 
     // Type specific accessors
@@ -1980,13 +1980,13 @@
         final Function<double[], DoubleVector> vectorFactory;
 
         private DoubleSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<double[], DoubleVector> vectorFactory,
                           Function<boolean[], VectorMask<Double>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Double>> shuffleFromArrayFactory,
                           fShuffleFromArray<Double> shuffleFromOpFactory) {
-            super(shape, double.class, Double.SIZE, boxType, maskType, maskFactory,
+            super(shape, double.class, Double.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Float128Vector.class,
             float.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float128Vector.class,
                 float.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Float128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Float128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float128Vector.class,
                 float.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Float256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Float256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float128Vector.class,
                 float.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Float512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Float512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float128Vector.class,
                 float.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == FloatMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == FloatMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float128Vector.class,
                 float.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public float addAll() {
+    public float addLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Float128Vector.class, float.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public float mulAll() {
+    public float mulLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float128Vector.class, float.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public float minAll() {
+    public float minLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Float128Vector.class, float.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public float maxAll() {
+    public float maxLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Float128Vector.class, float.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public float addAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addAll();
+    public float addLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulAll();
+    public float mulLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public float minAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minAll();
+    public float minLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public float maxAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxAll();
+    public float maxLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Float128Vector rotateEL(int j) {
+    public Float128Vector rotateLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Float128Vector rotateER(int j) {
+    public Float128Vector rotateLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Float128Vector shiftEL(int j) {
+    public Float128Vector shiftLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Float128Vector shiftER(int j) {
+    public Float128Vector shiftLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Float256Vector.class,
             float.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float256Vector.class,
                 float.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Float128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Float128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float256Vector.class,
                 float.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Float256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Float256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float256Vector.class,
                 float.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Float512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Float512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float256Vector.class,
                 float.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == FloatMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == FloatMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float256Vector.class,
                 float.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public float addAll() {
+    public float addLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Float256Vector.class, float.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public float mulAll() {
+    public float mulLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float256Vector.class, float.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public float minAll() {
+    public float minLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Float256Vector.class, float.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public float maxAll() {
+    public float maxLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Float256Vector.class, float.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public float addAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addAll();
+    public float addLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulAll();
+    public float mulLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public float minAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minAll();
+    public float minLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public float maxAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxAll();
+    public float maxLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Float256Vector rotateEL(int j) {
+    public Float256Vector rotateLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Float256Vector rotateER(int j) {
+    public Float256Vector rotateLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Float256Vector shiftEL(int j) {
+    public Float256Vector shiftLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Float256Vector shiftER(int j) {
+    public Float256Vector shiftLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Float512Vector.class,
             float.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float512Vector.class,
                 float.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Float128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Float128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float512Vector.class,
                 float.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Float256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Float256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float512Vector.class,
                 float.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Float512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Float512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float512Vector.class,
                 float.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == FloatMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == FloatMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float512Vector.class,
                 float.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public float addAll() {
+    public float addLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Float512Vector.class, float.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public float mulAll() {
+    public float mulLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float512Vector.class, float.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public float minAll() {
+    public float minLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Float512Vector.class, float.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public float maxAll() {
+    public float maxLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Float512Vector.class, float.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public float addAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addAll();
+    public float addLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulAll();
+    public float mulLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public float minAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minAll();
+    public float minLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public float maxAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxAll();
+    public float maxLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Float512Vector rotateEL(int j) {
+    public Float512Vector rotateLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Float512Vector rotateER(int j) {
+    public Float512Vector rotateLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Float512Vector shiftEL(int j) {
+    public Float512Vector shiftLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Float512Vector shiftER(int j) {
+    public Float512Vector shiftLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Float64Vector.class,
             float.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float64Vector.class,
                 float.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Float128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Float128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float64Vector.class,
                 float.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Float256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Float256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float64Vector.class,
                 float.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Float512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Float512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float64Vector.class,
                 float.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == FloatMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == FloatMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Float64Vector.class,
                 float.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public float addAll() {
+    public float addLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, Float64Vector.class, float.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public float mulAll() {
+    public float mulLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, Float64Vector.class, float.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public float minAll() {
+    public float minLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, Float64Vector.class, float.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public float maxAll() {
+    public float maxLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, Float64Vector.class, float.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public float addAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addAll();
+    public float addLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulAll();
+    public float mulLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public float minAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minAll();
+    public float minLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public float maxAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxAll();
+    public float maxLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public Float64Vector rotateEL(int j) {
+    public Float64Vector rotateLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public Float64Vector rotateER(int j) {
+    public Float64Vector rotateLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public Float64Vector shiftEL(int j) {
+    public Float64Vector shiftLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public Float64Vector shiftER(int j) {
+    public Float64Vector shiftLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             FloatMaxVector.class,
             float.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 FloatMaxVector.class,
                 float.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Float128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Float128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 FloatMaxVector.class,
                 float.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Float256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Float256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 FloatMaxVector.class,
                 float.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Float512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Float512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 FloatMaxVector.class,
                 float.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (FloatVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == FloatMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == FloatMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 FloatMaxVector.class,
                 float.class, LENGTH,
@@ -839,7 +839,7 @@
 
     @Override
     @ForceInline
-    public float addAll() {
+    public float addLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_ADD, FloatMaxVector.class, float.class, LENGTH,
                                 this,
@@ -852,7 +852,7 @@
 
     @Override
     @ForceInline
-    public float mulAll() {
+    public float mulLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MUL, FloatMaxVector.class, float.class, LENGTH,
                                 this,
@@ -865,7 +865,7 @@
 
     @Override
     @ForceInline
-    public float minAll() {
+    public float minLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MIN, FloatMaxVector.class, float.class, LENGTH,
                                 this,
@@ -878,7 +878,7 @@
 
     @Override
     @ForceInline
-    public float maxAll() {
+    public float maxLanes() {
         int bits = (int) VectorIntrinsics.reductionCoerced(
                                 VECTOR_OP_MAX, FloatMaxVector.class, float.class, LENGTH,
                                 this,
@@ -892,27 +892,27 @@
 
     @Override
     @ForceInline
-    public float addAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addAll();
+    public float addLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulAll();
+    public float mulLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, (float) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public float minAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minAll();
+    public float minLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public float maxAll(VectorMask<Float> m) {
-        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxAll();
+    public float maxLanes(VectorMask<Float> m) {
+        return FloatVector.broadcast(SPECIES, Float.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1167,7 +1167,7 @@
 
 
     @Override
-    public FloatMaxVector rotateEL(int j) {
+    public FloatMaxVector rotateLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1177,7 +1177,7 @@
     }
 
     @Override
-    public FloatMaxVector rotateER(int j) {
+    public FloatMaxVector rotateLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length(); i++){
@@ -1192,7 +1192,7 @@
     }
 
     @Override
-    public FloatMaxVector shiftEL(int j) {
+    public FloatMaxVector shiftLanesLeft(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1202,7 +1202,7 @@
     }
 
     @Override
-    public FloatMaxVector shiftER(int j) {
+    public FloatMaxVector shiftLanesRight(int j) {
         float[] vec = getElements();
         float[] res = new float[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -112,7 +112,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static FloatVector zero(VectorSpecies<Float> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<FloatVector>) species.boxType(), float.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<FloatVector>) species.vectorType(), float.class, species.length(),
                                                  Float.floatToIntBits(0.0f), species,
                                                  ((bits, s) -> ((FloatSpecies)s).op(i -> Float.intBitsToFloat((int)bits))));
     }
@@ -142,7 +142,7 @@
     public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(),
+        return VectorIntrinsics.load((Class<FloatVector>) species.vectorType(), float.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -200,7 +200,7 @@
     public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(),
+        return VectorIntrinsics.load((Class<FloatVector>) species.vectorType(), float.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_FLOAT_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((FloatSpecies)s).op(n -> c[idx + n]));
@@ -263,8 +263,8 @@
 
         vix = VectorIntrinsics.checkIndex(vix, a.length);
 
-        return VectorIntrinsics.loadWithMap((Class<FloatVector>) species.boxType(), float.class, species.length(),
-                                            IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_FLOAT_BASE_OFFSET, vix,
+        return VectorIntrinsics.loadWithMap((Class<FloatVector>) species.vectorType(), float.class, species.length(),
+                                            IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_FLOAT_BASE_OFFSET, vix,
                                             a, a_offset, indexMap, i_offset, species,
                                             (float[] c, int idx, int[] iMap, int idy, VectorSpecies<Float> s) ->
                                                 ((FloatSpecies)s).op(n -> c[idx + iMap[idy+n]]));
@@ -333,7 +333,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(),
+        return VectorIntrinsics.load((Class<FloatVector>) species.vectorType(), float.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -389,7 +389,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -397,7 +397,7 @@
     @SuppressWarnings("unchecked")
     public static FloatVector broadcast(VectorSpecies<Float> species, float e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<FloatVector>) species.boxType(), float.class, species.length(),
+            (Class<FloatVector>) species.vectorType(), float.class, species.length(),
             Float.floatToIntBits(e), species,
             ((bits, sp) -> ((FloatSpecies)sp).op(i -> Float.intBitsToFloat((int)bits))));
     }
@@ -421,7 +421,7 @@
     public static FloatVector scalars(VectorSpecies<Float> species, float... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(),
+        return VectorIntrinsics.load((Class<FloatVector>) species.vectorType(), float.class, species.length(),
                                      es, Unsafe.ARRAY_FLOAT_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((FloatSpecies)sp).op(n -> c[idx + n]));
@@ -799,25 +799,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract FloatVector rotateEL(int i);
+    public abstract FloatVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract FloatVector rotateER(int i);
+    public abstract FloatVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract FloatVector shiftEL(int i);
+    public abstract FloatVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract FloatVector shiftER(int i);
+    public abstract FloatVector shiftLanesRight(int i);
 
     /**
      * Divides this vector by an input vector.
@@ -1719,7 +1719,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract float addAll();
+    public abstract float addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1741,7 +1741,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract float addAll(VectorMask<Float> m);
+    public abstract float addLanes(VectorMask<Float> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1760,7 +1760,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract float mulAll();
+    public abstract float mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1781,7 +1781,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract float mulAll(VectorMask<Float> m);
+    public abstract float mulLanes(VectorMask<Float> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1793,7 +1793,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract float minAll();
+    public abstract float minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1807,7 +1807,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract float minAll(VectorMask<Float> m);
+    public abstract float minLanes(VectorMask<Float> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1819,7 +1819,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract float maxAll();
+    public abstract float maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1833,7 +1833,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract float maxAll(VectorMask<Float> m);
+    public abstract float maxLanes(VectorMask<Float> m);
 
 
     // Type specific accessors
@@ -1977,13 +1977,13 @@
         final Function<float[], FloatVector> vectorFactory;
 
         private FloatSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<float[], FloatVector> vectorFactory,
                           Function<boolean[], VectorMask<Float>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Float>> shuffleFromArrayFactory,
                           fShuffleFromArray<Float> shuffleFromOpFactory) {
-            super(shape, float.class, Float.SIZE, boxType, maskType, maskFactory,
+            super(shape, float.class, Float.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Int128Vector.class,
             int.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public IntVector reshape(VectorSpecies<Integer> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Int64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Int64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int128Vector.class,
                 int.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Int128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Int128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int128Vector.class,
                 int.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Int256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Int256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int128Vector.class,
                 int.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Int512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Int512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int128Vector.class,
                 int.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == IntMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == IntMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int128Vector.class,
                 int.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Int128Vector shiftL(int s) {
+    public Int128Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Int128Vector.class, int.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Int128Vector shiftL(int s, VectorMask<Integer> m) {
-        return blend(shiftL(s), m);
+    public Int128Vector shiftLeft(int s, VectorMask<Integer> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Int128Vector shiftR(int s) {
+    public Int128Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Int128Vector.class, int.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Int128Vector shiftR(int s, VectorMask<Integer> m) {
-        return blend(shiftR(s), m);
+    public Int128Vector shiftRight(int s, VectorMask<Integer> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int128Vector aShiftR(int s) {
+    public Int128Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Int128Vector.class, int.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Int128Vector aShiftR(int s, VectorMask<Integer> m) {
-        return blend(aShiftR(s), m);
+    public Int128Vector shiftArithmeticRight(int s, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int128Vector shiftL(Vector<Integer> s) {
+    public Int128Vector shiftLeft(Vector<Integer> s) {
         Int128Vector shiftv = (Int128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Int128Vector shiftR(Vector<Integer> s) {
+    public Int128Vector shiftRight(Vector<Integer> s) {
         Int128Vector shiftv = (Int128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Int128Vector aShiftR(Vector<Integer> s) {
+    public Int128Vector shiftArithmeticRight(Vector<Integer> s) {
         Int128Vector shiftv = (Int128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public int addAll() {
+    public int addLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Int128Vector.class, int.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public int andAll() {
+    public int andLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Int128Vector.class, int.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public int andAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andAll();
+    public int andLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll() {
+    public int minLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Int128Vector.class, int.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public int maxAll() {
+    public int maxLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Int128Vector.class, int.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public int mulAll() {
+    public int mulLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Int128Vector.class, int.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public int orAll() {
+    public int orLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int128Vector.class, int.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public int orAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orAll();
+    public int orLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public int xorAll() {
+    public int xorLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Int128Vector.class, int.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public int xorAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorAll();
+    public int xorLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public int addAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addAll();
+    public int addLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public int mulAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulAll();
+    public int mulLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minAll();
+    public int minLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public int maxAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxAll();
+    public int maxLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Int128Vector rotateEL(int j) {
+    public Int128Vector rotateLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Int128Vector rotateER(int j) {
+    public Int128Vector rotateLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Int128Vector shiftEL(int j) {
+    public Int128Vector shiftLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Int128Vector shiftER(int j) {
+    public Int128Vector shiftLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Int256Vector.class,
             int.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public IntVector reshape(VectorSpecies<Integer> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Int64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Int64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int256Vector.class,
                 int.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Int128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Int128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int256Vector.class,
                 int.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Int256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Int256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int256Vector.class,
                 int.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Int512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Int512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int256Vector.class,
                 int.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == IntMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == IntMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int256Vector.class,
                 int.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Int256Vector shiftL(int s) {
+    public Int256Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Int256Vector.class, int.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Int256Vector shiftL(int s, VectorMask<Integer> m) {
-        return blend(shiftL(s), m);
+    public Int256Vector shiftLeft(int s, VectorMask<Integer> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Int256Vector shiftR(int s) {
+    public Int256Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Int256Vector.class, int.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Int256Vector shiftR(int s, VectorMask<Integer> m) {
-        return blend(shiftR(s), m);
+    public Int256Vector shiftRight(int s, VectorMask<Integer> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int256Vector aShiftR(int s) {
+    public Int256Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Int256Vector.class, int.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Int256Vector aShiftR(int s, VectorMask<Integer> m) {
-        return blend(aShiftR(s), m);
+    public Int256Vector shiftArithmeticRight(int s, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int256Vector shiftL(Vector<Integer> s) {
+    public Int256Vector shiftLeft(Vector<Integer> s) {
         Int256Vector shiftv = (Int256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Int256Vector shiftR(Vector<Integer> s) {
+    public Int256Vector shiftRight(Vector<Integer> s) {
         Int256Vector shiftv = (Int256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Int256Vector aShiftR(Vector<Integer> s) {
+    public Int256Vector shiftArithmeticRight(Vector<Integer> s) {
         Int256Vector shiftv = (Int256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public int addAll() {
+    public int addLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Int256Vector.class, int.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public int andAll() {
+    public int andLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Int256Vector.class, int.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public int andAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andAll();
+    public int andLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll() {
+    public int minLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Int256Vector.class, int.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public int maxAll() {
+    public int maxLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Int256Vector.class, int.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public int mulAll() {
+    public int mulLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Int256Vector.class, int.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public int orAll() {
+    public int orLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int256Vector.class, int.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public int orAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orAll();
+    public int orLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public int xorAll() {
+    public int xorLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Int256Vector.class, int.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public int xorAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorAll();
+    public int xorLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public int addAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addAll();
+    public int addLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public int mulAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulAll();
+    public int mulLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minAll();
+    public int minLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public int maxAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxAll();
+    public int maxLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Int256Vector rotateEL(int j) {
+    public Int256Vector rotateLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Int256Vector rotateER(int j) {
+    public Int256Vector rotateLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Int256Vector shiftEL(int j) {
+    public Int256Vector shiftLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Int256Vector shiftER(int j) {
+    public Int256Vector shiftLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Int512Vector.class,
             int.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public IntVector reshape(VectorSpecies<Integer> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Int64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Int64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int512Vector.class,
                 int.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Int128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Int128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int512Vector.class,
                 int.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Int256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Int256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int512Vector.class,
                 int.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Int512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Int512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int512Vector.class,
                 int.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == IntMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == IntMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int512Vector.class,
                 int.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Int512Vector shiftL(int s) {
+    public Int512Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Int512Vector.class, int.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Int512Vector shiftL(int s, VectorMask<Integer> m) {
-        return blend(shiftL(s), m);
+    public Int512Vector shiftLeft(int s, VectorMask<Integer> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Int512Vector shiftR(int s) {
+    public Int512Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Int512Vector.class, int.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Int512Vector shiftR(int s, VectorMask<Integer> m) {
-        return blend(shiftR(s), m);
+    public Int512Vector shiftRight(int s, VectorMask<Integer> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int512Vector aShiftR(int s) {
+    public Int512Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Int512Vector.class, int.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Int512Vector aShiftR(int s, VectorMask<Integer> m) {
-        return blend(aShiftR(s), m);
+    public Int512Vector shiftArithmeticRight(int s, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int512Vector shiftL(Vector<Integer> s) {
+    public Int512Vector shiftLeft(Vector<Integer> s) {
         Int512Vector shiftv = (Int512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Int512Vector shiftR(Vector<Integer> s) {
+    public Int512Vector shiftRight(Vector<Integer> s) {
         Int512Vector shiftv = (Int512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Int512Vector aShiftR(Vector<Integer> s) {
+    public Int512Vector shiftArithmeticRight(Vector<Integer> s) {
         Int512Vector shiftv = (Int512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public int addAll() {
+    public int addLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Int512Vector.class, int.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public int andAll() {
+    public int andLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Int512Vector.class, int.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public int andAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andAll();
+    public int andLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll() {
+    public int minLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Int512Vector.class, int.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public int maxAll() {
+    public int maxLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Int512Vector.class, int.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public int mulAll() {
+    public int mulLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Int512Vector.class, int.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public int orAll() {
+    public int orLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int512Vector.class, int.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public int orAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orAll();
+    public int orLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public int xorAll() {
+    public int xorLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Int512Vector.class, int.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public int xorAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorAll();
+    public int xorLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public int addAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addAll();
+    public int addLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public int mulAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulAll();
+    public int mulLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minAll();
+    public int minLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public int maxAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxAll();
+    public int maxLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Int512Vector rotateEL(int j) {
+    public Int512Vector rotateLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Int512Vector rotateER(int j) {
+    public Int512Vector rotateLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Int512Vector shiftEL(int j) {
+    public Int512Vector shiftLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Int512Vector shiftER(int j) {
+    public Int512Vector shiftLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Int64Vector.class,
             int.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public IntVector reshape(VectorSpecies<Integer> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Int64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Int64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int64Vector.class,
                 int.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Int128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Int128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int64Vector.class,
                 int.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Int256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Int256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int64Vector.class,
                 int.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Int512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Int512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int64Vector.class,
                 int.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == IntMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == IntMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Int64Vector.class,
                 int.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Int64Vector shiftL(int s) {
+    public Int64Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Int64Vector.class, int.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Int64Vector shiftL(int s, VectorMask<Integer> m) {
-        return blend(shiftL(s), m);
+    public Int64Vector shiftLeft(int s, VectorMask<Integer> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Int64Vector shiftR(int s) {
+    public Int64Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Int64Vector.class, int.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Int64Vector shiftR(int s, VectorMask<Integer> m) {
-        return blend(shiftR(s), m);
+    public Int64Vector shiftRight(int s, VectorMask<Integer> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int64Vector aShiftR(int s) {
+    public Int64Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Int64Vector.class, int.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Int64Vector aShiftR(int s, VectorMask<Integer> m) {
-        return blend(aShiftR(s), m);
+    public Int64Vector shiftArithmeticRight(int s, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Int64Vector shiftL(Vector<Integer> s) {
+    public Int64Vector shiftLeft(Vector<Integer> s) {
         Int64Vector shiftv = (Int64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Int64Vector shiftR(Vector<Integer> s) {
+    public Int64Vector shiftRight(Vector<Integer> s) {
         Int64Vector shiftv = (Int64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Int64Vector aShiftR(Vector<Integer> s) {
+    public Int64Vector shiftArithmeticRight(Vector<Integer> s) {
         Int64Vector shiftv = (Int64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public int addAll() {
+    public int addLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Int64Vector.class, int.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public int andAll() {
+    public int andLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Int64Vector.class, int.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public int andAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andAll();
+    public int andLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll() {
+    public int minLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Int64Vector.class, int.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public int maxAll() {
+    public int maxLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Int64Vector.class, int.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public int mulAll() {
+    public int mulLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Int64Vector.class, int.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public int orAll() {
+    public int orLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Int64Vector.class, int.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public int orAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orAll();
+    public int orLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public int xorAll() {
+    public int xorLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Int64Vector.class, int.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public int xorAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorAll();
+    public int xorLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public int addAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addAll();
+    public int addLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public int mulAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulAll();
+    public int mulLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minAll();
+    public int minLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public int maxAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxAll();
+    public int maxLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Int64Vector rotateEL(int j) {
+    public Int64Vector rotateLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Int64Vector rotateER(int j) {
+    public Int64Vector rotateLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Int64Vector shiftEL(int j) {
+    public Int64Vector shiftLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Int64Vector shiftER(int j) {
+    public Int64Vector shiftLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             IntMaxVector.class,
             int.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public IntVector reshape(VectorSpecies<Integer> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Int64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Int64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 IntMaxVector.class,
                 int.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Int128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Int128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 IntMaxVector.class,
                 int.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Int256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Int256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 IntMaxVector.class,
                 int.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Int512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Int512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 IntMaxVector.class,
                 int.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == IntMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == IntMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 IntMaxVector.class,
                 int.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public IntMaxVector shiftL(int s) {
+    public IntMaxVector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, IntMaxVector.class, int.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public IntMaxVector shiftL(int s, VectorMask<Integer> m) {
-        return blend(shiftL(s), m);
+    public IntMaxVector shiftLeft(int s, VectorMask<Integer> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public IntMaxVector shiftR(int s) {
+    public IntMaxVector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, IntMaxVector.class, int.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public IntMaxVector shiftR(int s, VectorMask<Integer> m) {
-        return blend(shiftR(s), m);
+    public IntMaxVector shiftRight(int s, VectorMask<Integer> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public IntMaxVector aShiftR(int s) {
+    public IntMaxVector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, IntMaxVector.class, int.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public IntMaxVector aShiftR(int s, VectorMask<Integer> m) {
-        return blend(aShiftR(s), m);
+    public IntMaxVector shiftArithmeticRight(int s, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public IntMaxVector shiftL(Vector<Integer> s) {
+    public IntMaxVector shiftLeft(Vector<Integer> s) {
         IntMaxVector shiftv = (IntMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public IntMaxVector shiftR(Vector<Integer> s) {
+    public IntMaxVector shiftRight(Vector<Integer> s) {
         IntMaxVector shiftv = (IntMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public IntMaxVector aShiftR(Vector<Integer> s) {
+    public IntMaxVector shiftArithmeticRight(Vector<Integer> s) {
         IntMaxVector shiftv = (IntMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(IntVector.broadcast(SPECIES, 0x1f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public int addAll() {
+    public int addLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public int andAll() {
+    public int andLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public int andAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andAll();
+    public int andLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll() {
+    public int minLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public int maxAll() {
+    public int maxLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public int mulAll() {
+    public int mulLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public int orAll() {
+    public int orLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public int orAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orAll();
+    public int orLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public int xorAll() {
+    public int xorLanes() {
         return (int) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, IntMaxVector.class, int.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public int xorAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorAll();
+    public int xorLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public int addAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addAll();
+    public int addLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public int mulAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulAll();
+    public int mulLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, (int) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public int minAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minAll();
+    public int minLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public int maxAll(VectorMask<Integer> m) {
-        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxAll();
+    public int maxLanes(VectorMask<Integer> m) {
+        return IntVector.broadcast(SPECIES, Integer.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public IntMaxVector rotateEL(int j) {
+    public IntMaxVector rotateLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public IntMaxVector rotateER(int j) {
+    public IntMaxVector rotateLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public IntMaxVector shiftEL(int j) {
+    public IntMaxVector shiftLanesLeft(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public IntMaxVector shiftER(int j) {
+    public IntMaxVector shiftLanesRight(int j) {
         int[] vec = getElements();
         int[] res = new int[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -112,7 +112,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static IntVector zero(VectorSpecies<Integer> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<IntVector>) species.boxType(), int.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<IntVector>) species.vectorType(), int.class, species.length(),
                                                  0, species,
                                                  ((bits, s) -> ((IntSpecies)s).op(i -> (int)bits)));
     }
@@ -142,7 +142,7 @@
     public static IntVector fromByteArray(VectorSpecies<Integer> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<IntVector>) species.boxType(), int.class, species.length(),
+        return VectorIntrinsics.load((Class<IntVector>) species.vectorType(), int.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -200,7 +200,7 @@
     public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<IntVector>) species.boxType(), int.class, species.length(),
+        return VectorIntrinsics.load((Class<IntVector>) species.vectorType(), int.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_INT_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((IntSpecies)s).op(n -> c[idx + n]));
@@ -263,8 +263,8 @@
 
         vix = VectorIntrinsics.checkIndex(vix, a.length);
 
-        return VectorIntrinsics.loadWithMap((Class<IntVector>) species.boxType(), int.class, species.length(),
-                                            IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_INT_BASE_OFFSET, vix,
+        return VectorIntrinsics.loadWithMap((Class<IntVector>) species.vectorType(), int.class, species.length(),
+                                            IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_INT_BASE_OFFSET, vix,
                                             a, a_offset, indexMap, i_offset, species,
                                             (int[] c, int idx, int[] iMap, int idy, VectorSpecies<Integer> s) ->
                                                 ((IntSpecies)s).op(n -> c[idx + iMap[idy+n]]));
@@ -333,7 +333,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<IntVector>) species.boxType(), int.class, species.length(),
+        return VectorIntrinsics.load((Class<IntVector>) species.vectorType(), int.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -389,7 +389,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -397,7 +397,7 @@
     @SuppressWarnings("unchecked")
     public static IntVector broadcast(VectorSpecies<Integer> species, int e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<IntVector>) species.boxType(), int.class, species.length(),
+            (Class<IntVector>) species.vectorType(), int.class, species.length(),
             e, species,
             ((bits, sp) -> ((IntSpecies)sp).op(i -> (int)bits)));
     }
@@ -421,7 +421,7 @@
     public static IntVector scalars(VectorSpecies<Integer> species, int... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<IntVector>) species.boxType(), int.class, species.length(),
+        return VectorIntrinsics.load((Class<IntVector>) species.vectorType(), int.class, species.length(),
                                      es, Unsafe.ARRAY_INT_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((IntSpecies)sp).op(n -> c[idx + n]));
@@ -799,25 +799,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract IntVector rotateEL(int i);
+    public abstract IntVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract IntVector rotateER(int i);
+    public abstract IntVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract IntVector shiftEL(int i);
+    public abstract IntVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract IntVector shiftER(int i);
+    public abstract IntVector shiftLanesRight(int i);
 
 
 
@@ -996,113 +996,121 @@
      * Logically left shifts this vector by the broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane to left shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to left shift
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract IntVector shiftL(int s);
+    public abstract IntVector shiftLeft(int s);
 
     /**
      * Logically left shifts this vector by the broadcast of an input scalar,
      * selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane to left shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to left shift
      * @param m the mask controlling lane selection
      * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract IntVector shiftL(int s, VectorMask<Integer> m);
+    public abstract IntVector shiftLeft(int s, VectorMask<Integer> m);
 
     /**
      * Logically left shifts this vector by an input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of logically left shifting this vector by the input
      * vector
      */
-    public abstract IntVector shiftL(Vector<Integer> v);
+    public abstract IntVector shiftLeft(Vector<Integer> v);
 
     /**
      * Logically left shifts this vector by an input vector, selecting lane
      * elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of logically left shifting this vector by the input
      * vector
      */
-    public IntVector shiftL(Vector<Integer> v, VectorMask<Integer> m) {
-        return bOp(v, m, (i, a, b) -> (int) (a << b));
+    public IntVector shiftLeft(Vector<Integer> v, VectorMask<Integer> m) {
+        return blend(shiftLeft(v), m);
     }
 
     // logical, or unsigned, shift right
 
-    /**
+     /**
      * Logically right shifts (or unsigned right shifts) this vector by the
      * broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane to logically right shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract IntVector shiftR(int s);
+    public abstract IntVector shiftRight(int s);
 
-    /**
+     /**
      * Logically right shifts (or unsigned right shifts) this vector by the
      * broadcast of an input scalar, selecting lane elements controlled by a
      * mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>}) to each lane to logically right shift the
+     * element by shift value as specified by the input scalar.
      *
      * @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
      */
-    public abstract IntVector shiftR(int s, VectorMask<Integer> m);
+    public abstract IntVector shiftRight(int s, VectorMask<Integer> m);
 
     /**
      * Logically right shifts (or unsigned right shifts) this vector by an
      * input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of logically right shifting this vector by the
      * input vector
      */
-    public abstract IntVector shiftR(Vector<Integer> v);
+    public abstract IntVector shiftRight(Vector<Integer> v);
 
     /**
      * Logically right shifts (or unsigned right shifts) this vector by an
      * input vector, selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * input vector
      */
-    public IntVector shiftR(Vector<Integer> v, VectorMask<Integer> m) {
-        return bOp(v, m, (i, a, b) -> (int) (a >>> b));
+    public IntVector shiftRight(Vector<Integer> v, VectorMask<Integer> m) {
+        return blend(shiftRight(v), m);
     }
 
     /**
@@ -1110,13 +1118,14 @@
      * broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane to arithmetically
+     * right shift the element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract IntVector aShiftR(int s);
+    public abstract IntVector shiftArithmeticRight(int s);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1124,42 +1133,45 @@
      * mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane to arithmetically
+     * right shift the element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @param m the mask controlling lane selection
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract IntVector aShiftR(int s, VectorMask<Integer> m);
+    public abstract IntVector shiftArithmeticRight(int s, VectorMask<Integer> m);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by an
      * input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of arithmetically right shifting this vector by the
      * input vector
      */
-    public abstract IntVector aShiftR(Vector<Integer> v);
+    public abstract IntVector shiftArithmeticRight(Vector<Integer> v);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by an
      * input vector, selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of arithmetically right shifting this vector by the
      * input vector
      */
-    public IntVector aShiftR(Vector<Integer> v, VectorMask<Integer> m) {
-        return bOp(v, m, (i, a, b) -> (int) (a >> b));
+    public IntVector shiftArithmeticRight(Vector<Integer> v, VectorMask<Integer> m) {
+        return blend(shiftArithmeticRight(v), m);
     }
 
     /**
@@ -1176,8 +1188,8 @@
      * input scalar
      */
     @ForceInline
-    public final IntVector rotateL(int s) {
-        return shiftL(s).or(shiftR(-s));
+    public final IntVector rotateLeft(int s) {
+        return shiftLeft(s).or(shiftRight(-s));
     }
 
     /**
@@ -1196,8 +1208,8 @@
      * input scalar
      */
     @ForceInline
-    public final IntVector rotateL(int s, VectorMask<Integer> m) {
-        return shiftL(s, m).or(shiftR(-s, m), m);
+    public final IntVector rotateLeft(int s, VectorMask<Integer> m) {
+        return shiftLeft(s, m).or(shiftRight(-s, m), m);
     }
 
     /**
@@ -1214,8 +1226,8 @@
      * input scalar
      */
     @ForceInline
-    public final IntVector rotateR(int s) {
-        return shiftR(s).or(shiftL(-s));
+    public final IntVector rotateRight(int s) {
+        return shiftRight(s).or(shiftLeft(-s));
     }
 
     /**
@@ -1234,8 +1246,8 @@
      * input scalar
      */
     @ForceInline
-    public final IntVector rotateR(int s, VectorMask<Integer> m) {
-        return shiftR(s, m).or(shiftL(-s, m), m);
+    public final IntVector rotateRight(int s, VectorMask<Integer> m) {
+        return shiftRight(s, m).or(shiftLeft(-s, m), m);
     }
 
     /**
@@ -1273,7 +1285,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract int addAll();
+    public abstract int addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1286,7 +1298,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract int addAll(VectorMask<Integer> m);
+    public abstract int addLanes(VectorMask<Integer> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1297,7 +1309,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract int mulAll();
+    public abstract int mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1310,7 +1322,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract int mulAll(VectorMask<Integer> m);
+    public abstract int mulLanes(VectorMask<Integer> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1322,7 +1334,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract int minAll();
+    public abstract int minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1336,7 +1348,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract int minAll(VectorMask<Integer> m);
+    public abstract int minLanes(VectorMask<Integer> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1348,7 +1360,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract int maxAll();
+    public abstract int maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1362,7 +1374,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract int maxAll(VectorMask<Integer> m);
+    public abstract int maxLanes(VectorMask<Integer> m);
 
     /**
      * Logically ORs all lane elements of this vector.
@@ -1373,7 +1385,7 @@
      *
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract int orAll();
+    public abstract int orLanes();
 
     /**
      * Logically ORs all lane elements of this vector, selecting lane elements
@@ -1386,7 +1398,7 @@
      * @param m the mask controlling lane selection
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract int orAll(VectorMask<Integer> m);
+    public abstract int orLanes(VectorMask<Integer> m);
 
     /**
      * Logically ANDs all lane elements of this vector.
@@ -1397,7 +1409,7 @@
      *
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract int andAll();
+    public abstract int andLanes();
 
     /**
      * Logically ANDs all lane elements of this vector, selecting lane elements
@@ -1410,7 +1422,7 @@
      * @param m the mask controlling lane selection
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract int andAll(VectorMask<Integer> m);
+    public abstract int andLanes(VectorMask<Integer> m);
 
     /**
      * Logically XORs all lane elements of this vector.
@@ -1421,7 +1433,7 @@
      *
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract int xorAll();
+    public abstract int xorLanes();
 
     /**
      * Logically XORs all lane elements of this vector, selecting lane elements
@@ -1434,7 +1446,7 @@
      * @param m the mask controlling lane selection
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract int xorAll(VectorMask<Integer> m);
+    public abstract int xorLanes(VectorMask<Integer> m);
 
     // Type specific accessors
 
@@ -1577,13 +1589,13 @@
         final Function<int[], IntVector> vectorFactory;
 
         private IntSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<int[], IntVector> vectorFactory,
                           Function<boolean[], VectorMask<Integer>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Integer>> shuffleFromArrayFactory,
                           fShuffleFromArray<Integer> shuffleFromOpFactory) {
-            super(shape, int.class, Integer.SIZE, boxType, maskType, maskFactory,
+            super(shape, int.class, Integer.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Long128Vector.class,
             long.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public LongVector reshape(VectorSpecies<Long> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Long64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Long64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long128Vector.class,
                 long.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Long128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Long128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long128Vector.class,
                 long.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Long256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Long256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long128Vector.class,
                 long.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Long512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Long512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long128Vector.class,
                 long.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == LongMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == LongMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long128Vector.class,
                 long.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Long128Vector shiftL(int s) {
+    public Long128Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Long128Vector.class, long.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Long128Vector shiftL(int s, VectorMask<Long> m) {
-        return blend(shiftL(s), m);
+    public Long128Vector shiftLeft(int s, VectorMask<Long> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Long128Vector shiftR(int s) {
+    public Long128Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Long128Vector.class, long.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Long128Vector shiftR(int s, VectorMask<Long> m) {
-        return blend(shiftR(s), m);
+    public Long128Vector shiftRight(int s, VectorMask<Long> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long128Vector aShiftR(int s) {
+    public Long128Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Long128Vector.class, long.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Long128Vector aShiftR(int s, VectorMask<Long> m) {
-        return blend(aShiftR(s), m);
+    public Long128Vector shiftArithmeticRight(int s, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long128Vector shiftL(Vector<Long> s) {
+    public Long128Vector shiftLeft(Vector<Long> s) {
         Long128Vector shiftv = (Long128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Long128Vector shiftR(Vector<Long> s) {
+    public Long128Vector shiftRight(Vector<Long> s) {
         Long128Vector shiftv = (Long128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Long128Vector aShiftR(Vector<Long> s) {
+    public Long128Vector shiftArithmeticRight(Vector<Long> s) {
         Long128Vector shiftv = (Long128Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public long addAll() {
+    public long addLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Long128Vector.class, long.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public long andAll() {
+    public long andLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Long128Vector.class, long.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public long andAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andAll();
+    public long andLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll() {
+    public long minLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Long128Vector.class, long.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public long maxAll() {
+    public long maxLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Long128Vector.class, long.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public long mulAll() {
+    public long mulLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Long128Vector.class, long.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public long orAll() {
+    public long orLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long128Vector.class, long.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public long orAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orAll();
+    public long orLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public long xorAll() {
+    public long xorLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Long128Vector.class, long.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public long xorAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorAll();
+    public long xorLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public long addAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addAll();
+    public long addLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public long mulAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulAll();
+    public long mulLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minAll();
+    public long minLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public long maxAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxAll();
+    public long maxLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Long128Vector rotateEL(int j) {
+    public Long128Vector rotateLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Long128Vector rotateER(int j) {
+    public Long128Vector rotateLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Long128Vector shiftEL(int j) {
+    public Long128Vector shiftLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Long128Vector shiftER(int j) {
+    public Long128Vector shiftLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Long256Vector.class,
             long.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public LongVector reshape(VectorSpecies<Long> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Long64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Long64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long256Vector.class,
                 long.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Long128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Long128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long256Vector.class,
                 long.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Long256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Long256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long256Vector.class,
                 long.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Long512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Long512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long256Vector.class,
                 long.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == LongMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == LongMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long256Vector.class,
                 long.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Long256Vector shiftL(int s) {
+    public Long256Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Long256Vector.class, long.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Long256Vector shiftL(int s, VectorMask<Long> m) {
-        return blend(shiftL(s), m);
+    public Long256Vector shiftLeft(int s, VectorMask<Long> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Long256Vector shiftR(int s) {
+    public Long256Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Long256Vector.class, long.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Long256Vector shiftR(int s, VectorMask<Long> m) {
-        return blend(shiftR(s), m);
+    public Long256Vector shiftRight(int s, VectorMask<Long> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long256Vector aShiftR(int s) {
+    public Long256Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Long256Vector.class, long.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Long256Vector aShiftR(int s, VectorMask<Long> m) {
-        return blend(aShiftR(s), m);
+    public Long256Vector shiftArithmeticRight(int s, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long256Vector shiftL(Vector<Long> s) {
+    public Long256Vector shiftLeft(Vector<Long> s) {
         Long256Vector shiftv = (Long256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Long256Vector shiftR(Vector<Long> s) {
+    public Long256Vector shiftRight(Vector<Long> s) {
         Long256Vector shiftv = (Long256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Long256Vector aShiftR(Vector<Long> s) {
+    public Long256Vector shiftArithmeticRight(Vector<Long> s) {
         Long256Vector shiftv = (Long256Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public long addAll() {
+    public long addLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Long256Vector.class, long.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public long andAll() {
+    public long andLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Long256Vector.class, long.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public long andAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andAll();
+    public long andLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll() {
+    public long minLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Long256Vector.class, long.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public long maxAll() {
+    public long maxLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Long256Vector.class, long.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public long mulAll() {
+    public long mulLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Long256Vector.class, long.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public long orAll() {
+    public long orLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long256Vector.class, long.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public long orAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orAll();
+    public long orLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public long xorAll() {
+    public long xorLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Long256Vector.class, long.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public long xorAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorAll();
+    public long xorLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public long addAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addAll();
+    public long addLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public long mulAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulAll();
+    public long mulLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minAll();
+    public long minLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public long maxAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxAll();
+    public long maxLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Long256Vector rotateEL(int j) {
+    public Long256Vector rotateLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Long256Vector rotateER(int j) {
+    public Long256Vector rotateLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Long256Vector shiftEL(int j) {
+    public Long256Vector shiftLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Long256Vector shiftER(int j) {
+    public Long256Vector shiftLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             Long512Vector.class,
             long.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public LongVector reshape(VectorSpecies<Long> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Long64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Long64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long512Vector.class,
                 long.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Long128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Long128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long512Vector.class,
                 long.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Long256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Long256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long512Vector.class,
                 long.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Long512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Long512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long512Vector.class,
                 long.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == LongMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == LongMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long512Vector.class,
                 long.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Long512Vector shiftL(int s) {
+    public Long512Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Long512Vector.class, long.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public Long512Vector shiftL(int s, VectorMask<Long> m) {
-        return blend(shiftL(s), m);
+    public Long512Vector shiftLeft(int s, VectorMask<Long> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Long512Vector shiftR(int s) {
+    public Long512Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Long512Vector.class, long.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public Long512Vector shiftR(int s, VectorMask<Long> m) {
-        return blend(shiftR(s), m);
+    public Long512Vector shiftRight(int s, VectorMask<Long> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long512Vector aShiftR(int s) {
+    public Long512Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Long512Vector.class, long.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public Long512Vector aShiftR(int s, VectorMask<Long> m) {
-        return blend(aShiftR(s), m);
+    public Long512Vector shiftArithmeticRight(int s, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long512Vector shiftL(Vector<Long> s) {
+    public Long512Vector shiftLeft(Vector<Long> s) {
         Long512Vector shiftv = (Long512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public Long512Vector shiftR(Vector<Long> s) {
+    public Long512Vector shiftRight(Vector<Long> s) {
         Long512Vector shiftv = (Long512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public Long512Vector aShiftR(Vector<Long> s) {
+    public Long512Vector shiftArithmeticRight(Vector<Long> s) {
         Long512Vector shiftv = (Long512Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public long addAll() {
+    public long addLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Long512Vector.class, long.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public long andAll() {
+    public long andLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Long512Vector.class, long.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public long andAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andAll();
+    public long andLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll() {
+    public long minLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Long512Vector.class, long.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public long maxAll() {
+    public long maxLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Long512Vector.class, long.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public long mulAll() {
+    public long mulLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Long512Vector.class, long.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public long orAll() {
+    public long orLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long512Vector.class, long.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public long orAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orAll();
+    public long orLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public long xorAll() {
+    public long xorLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Long512Vector.class, long.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public long xorAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorAll();
+    public long xorLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public long addAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addAll();
+    public long addLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public long mulAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulAll();
+    public long mulLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minAll();
+    public long minLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public long maxAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxAll();
+    public long maxLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public Long512Vector rotateEL(int j) {
+    public Long512Vector rotateLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public Long512Vector rotateER(int j) {
+    public Long512Vector rotateLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public Long512Vector shiftEL(int j) {
+    public Long512Vector shiftLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public Long512Vector shiftER(int j) {
+    public Long512Vector shiftLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -162,7 +162,7 @@
         return VectorIntrinsics.cast(
             Long64Vector.class,
             long.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -300,7 +300,7 @@
     @ForceInline
     public LongVector reshape(VectorSpecies<Long> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Long64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Long64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long64Vector.class,
                 long.class, LENGTH,
@@ -309,7 +309,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Long128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Long128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long64Vector.class,
                 long.class, LENGTH,
@@ -318,7 +318,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Long256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Long256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long64Vector.class,
                 long.class, LENGTH,
@@ -327,7 +327,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Long512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Long512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long64Vector.class,
                 long.class, LENGTH,
@@ -337,7 +337,7 @@
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == LongMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == LongMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Long64Vector.class,
                 long.class, LENGTH,
@@ -664,7 +664,7 @@
 
     @Override
     @ForceInline
-    public Long64Vector shiftL(int s) {
+    public Long64Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Long64Vector.class, long.class, LENGTH,
             this, s,
@@ -673,13 +673,13 @@
 
     @Override
     @ForceInline
-    public Long64Vector shiftL(int s, VectorMask<Long> m) {
-        return blend(shiftL(s), m);
+    public Long64Vector shiftLeft(int s, VectorMask<Long> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Long64Vector shiftR(int s) {
+    public Long64Vector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, Long64Vector.class, long.class, LENGTH,
             this, s,
@@ -688,13 +688,13 @@
 
     @Override
     @ForceInline
-    public Long64Vector shiftR(int s, VectorMask<Long> m) {
-        return blend(shiftR(s), m);
+    public Long64Vector shiftRight(int s, VectorMask<Long> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long64Vector aShiftR(int s) {
+    public Long64Vector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, Long64Vector.class, long.class, LENGTH,
             this, s,
@@ -703,13 +703,13 @@
 
     @Override
     @ForceInline
-    public Long64Vector aShiftR(int s, VectorMask<Long> m) {
-        return blend(aShiftR(s), m);
+    public Long64Vector shiftArithmeticRight(int s, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Long64Vector shiftL(Vector<Long> s) {
+    public Long64Vector shiftLeft(Vector<Long> s) {
         Long64Vector shiftv = (Long64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -721,7 +721,7 @@
 
     @Override
     @ForceInline
-    public Long64Vector shiftR(Vector<Long> s) {
+    public Long64Vector shiftRight(Vector<Long> s) {
         Long64Vector shiftv = (Long64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -733,7 +733,7 @@
 
     @Override
     @ForceInline
-    public Long64Vector aShiftR(Vector<Long> s) {
+    public Long64Vector shiftArithmeticRight(Vector<Long> s) {
         Long64Vector shiftv = (Long64Vector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -749,7 +749,7 @@
 
     @Override
     @ForceInline
-    public long addAll() {
+    public long addLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Long64Vector.class, long.class, LENGTH,
             this,
@@ -758,7 +758,7 @@
 
     @Override
     @ForceInline
-    public long andAll() {
+    public long andLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Long64Vector.class, long.class, LENGTH,
             this,
@@ -767,13 +767,13 @@
 
     @Override
     @ForceInline
-    public long andAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andAll();
+    public long andLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll() {
+    public long minLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Long64Vector.class, long.class, LENGTH,
             this,
@@ -782,7 +782,7 @@
 
     @Override
     @ForceInline
-    public long maxAll() {
+    public long maxLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Long64Vector.class, long.class, LENGTH,
             this,
@@ -791,7 +791,7 @@
 
     @Override
     @ForceInline
-    public long mulAll() {
+    public long mulLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Long64Vector.class, long.class, LENGTH,
             this,
@@ -800,7 +800,7 @@
 
     @Override
     @ForceInline
-    public long orAll() {
+    public long orLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH,
             this,
@@ -809,13 +809,13 @@
 
     @Override
     @ForceInline
-    public long orAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orAll();
+    public long orLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public long xorAll() {
+    public long xorLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Long64Vector.class, long.class, LENGTH,
             this,
@@ -824,34 +824,34 @@
 
     @Override
     @ForceInline
-    public long xorAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorAll();
+    public long xorLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public long addAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addAll();
+    public long addLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public long mulAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulAll();
+    public long mulLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minAll();
+    public long minLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public long maxAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxAll();
+    public long maxLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1094,7 +1094,7 @@
     }
 
     @Override
-    public Long64Vector rotateEL(int j) {
+    public Long64Vector rotateLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1104,7 +1104,7 @@
     }
 
     @Override
-    public Long64Vector rotateER(int j) {
+    public Long64Vector rotateLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1119,7 +1119,7 @@
     }
 
     @Override
-    public Long64Vector shiftEL(int j) {
+    public Long64Vector shiftLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1129,7 +1129,7 @@
     }
 
     @Override
-    public Long64Vector shiftER(int j) {
+    public Long64Vector shiftLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -163,7 +163,7 @@
         return VectorIntrinsics.cast(
             LongMaxVector.class,
             long.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -301,7 +301,7 @@
     @ForceInline
     public LongVector reshape(VectorSpecies<Long> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Long64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Long64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 LongMaxVector.class,
                 long.class, LENGTH,
@@ -310,7 +310,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Long128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Long128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 LongMaxVector.class,
                 long.class, LENGTH,
@@ -319,7 +319,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Long256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Long256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 LongMaxVector.class,
                 long.class, LENGTH,
@@ -328,7 +328,7 @@
                 this, s,
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Long512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Long512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 LongMaxVector.class,
                 long.class, LENGTH,
@@ -338,7 +338,7 @@
                 (species, vector) -> (LongVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == LongMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == LongMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 LongMaxVector.class,
                 long.class, LENGTH,
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public LongMaxVector shiftL(int s) {
+    public LongMaxVector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, LongMaxVector.class, long.class, LENGTH,
             this, s,
@@ -674,13 +674,13 @@
 
     @Override
     @ForceInline
-    public LongMaxVector shiftL(int s, VectorMask<Long> m) {
-        return blend(shiftL(s), m);
+    public LongMaxVector shiftLeft(int s, VectorMask<Long> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public LongMaxVector shiftR(int s) {
+    public LongMaxVector shiftRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_URSHIFT, LongMaxVector.class, long.class, LENGTH,
             this, s,
@@ -689,13 +689,13 @@
 
     @Override
     @ForceInline
-    public LongMaxVector shiftR(int s, VectorMask<Long> m) {
-        return blend(shiftR(s), m);
+    public LongMaxVector shiftRight(int s, VectorMask<Long> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public LongMaxVector aShiftR(int s) {
+    public LongMaxVector shiftArithmeticRight(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_RSHIFT, LongMaxVector.class, long.class, LENGTH,
             this, s,
@@ -704,13 +704,13 @@
 
     @Override
     @ForceInline
-    public LongMaxVector aShiftR(int s, VectorMask<Long> m) {
-        return blend(aShiftR(s), m);
+    public LongMaxVector shiftArithmeticRight(int s, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(s), m);
     }
 
     @Override
     @ForceInline
-    public LongMaxVector shiftL(Vector<Long> s) {
+    public LongMaxVector shiftLeft(Vector<Long> s) {
         LongMaxVector shiftv = (LongMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -722,7 +722,7 @@
 
     @Override
     @ForceInline
-    public LongMaxVector shiftR(Vector<Long> s) {
+    public LongMaxVector shiftRight(Vector<Long> s) {
         LongMaxVector shiftv = (LongMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -734,7 +734,7 @@
 
     @Override
     @ForceInline
-    public LongMaxVector aShiftR(Vector<Long> s) {
+    public LongMaxVector shiftArithmeticRight(Vector<Long> s) {
         LongMaxVector shiftv = (LongMaxVector)s;
         // As per shift specification for Java, mask the shift count.
         shiftv = shiftv.and(LongVector.broadcast(SPECIES, 0x3f));
@@ -750,7 +750,7 @@
 
     @Override
     @ForceInline
-    public long addAll() {
+    public long addLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -759,7 +759,7 @@
 
     @Override
     @ForceInline
-    public long andAll() {
+    public long andLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -768,13 +768,13 @@
 
     @Override
     @ForceInline
-    public long andAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andAll();
+    public long andLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll() {
+    public long minLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -783,7 +783,7 @@
 
     @Override
     @ForceInline
-    public long maxAll() {
+    public long maxLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -792,7 +792,7 @@
 
     @Override
     @ForceInline
-    public long mulAll() {
+    public long mulLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -801,7 +801,7 @@
 
     @Override
     @ForceInline
-    public long orAll() {
+    public long orLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -810,13 +810,13 @@
 
     @Override
     @ForceInline
-    public long orAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orAll();
+    public long orLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public long xorAll() {
+    public long xorLanes() {
         return (long) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, LongMaxVector.class, long.class, LENGTH,
             this,
@@ -825,34 +825,34 @@
 
     @Override
     @ForceInline
-    public long xorAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorAll();
+    public long xorLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public long addAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addAll();
+    public long addLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public long mulAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulAll();
+    public long mulLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, (long) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public long minAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minAll();
+    public long minLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public long maxAll(VectorMask<Long> m) {
-        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxAll();
+    public long maxLanes(VectorMask<Long> m) {
+        return LongVector.broadcast(SPECIES, Long.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1107,7 +1107,7 @@
     }
 
     @Override
-    public LongMaxVector rotateEL(int j) {
+    public LongMaxVector rotateLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1117,7 +1117,7 @@
     }
 
     @Override
-    public LongMaxVector rotateER(int j) {
+    public LongMaxVector rotateLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length(); i++){
@@ -1132,7 +1132,7 @@
     }
 
     @Override
-    public LongMaxVector shiftEL(int j) {
+    public LongMaxVector shiftLanesLeft(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1142,7 +1142,7 @@
     }
 
     @Override
-    public LongMaxVector shiftER(int j) {
+    public LongMaxVector shiftLanesRight(int j) {
         long[] vec = getElements();
         long[] res = new long[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -112,7 +112,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static LongVector zero(VectorSpecies<Long> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<LongVector>) species.boxType(), long.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<LongVector>) species.vectorType(), long.class, species.length(),
                                                  0, species,
                                                  ((bits, s) -> ((LongSpecies)s).op(i -> (long)bits)));
     }
@@ -142,7 +142,7 @@
     public static LongVector fromByteArray(VectorSpecies<Long> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<LongVector>) species.boxType(), long.class, species.length(),
+        return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -200,7 +200,7 @@
     public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<LongVector>) species.boxType(), long.class, species.length(),
+        return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_LONG_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((LongSpecies)s).op(n -> c[idx + n]));
@@ -266,8 +266,8 @@
 
         vix = VectorIntrinsics.checkIndex(vix, a.length);
 
-        return VectorIntrinsics.loadWithMap((Class<LongVector>) species.boxType(), long.class, species.length(),
-                                            IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_LONG_BASE_OFFSET, vix,
+        return VectorIntrinsics.loadWithMap((Class<LongVector>) species.vectorType(), long.class, species.length(),
+                                            IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_LONG_BASE_OFFSET, vix,
                                             a, a_offset, indexMap, i_offset, species,
                                             (long[] c, int idx, int[] iMap, int idy, VectorSpecies<Long> s) ->
                                                 ((LongSpecies)s).op(n -> c[idx + iMap[idy+n]]));
@@ -336,7 +336,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<LongVector>) species.boxType(), long.class, species.length(),
+        return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -392,7 +392,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -400,7 +400,7 @@
     @SuppressWarnings("unchecked")
     public static LongVector broadcast(VectorSpecies<Long> species, long e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<LongVector>) species.boxType(), long.class, species.length(),
+            (Class<LongVector>) species.vectorType(), long.class, species.length(),
             e, species,
             ((bits, sp) -> ((LongSpecies)sp).op(i -> (long)bits)));
     }
@@ -424,7 +424,7 @@
     public static LongVector scalars(VectorSpecies<Long> species, long... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<LongVector>) species.boxType(), long.class, species.length(),
+        return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
                                      es, Unsafe.ARRAY_LONG_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((LongSpecies)sp).op(n -> c[idx + n]));
@@ -802,25 +802,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract LongVector rotateEL(int i);
+    public abstract LongVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract LongVector rotateER(int i);
+    public abstract LongVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract LongVector shiftEL(int i);
+    public abstract LongVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract LongVector shiftER(int i);
+    public abstract LongVector shiftLanesRight(int i);
 
 
 
@@ -999,113 +999,121 @@
      * Logically left shifts this vector by the broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane to left shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to left shift
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract LongVector shiftL(int s);
+    public abstract LongVector shiftLeft(int s);
 
     /**
      * Logically left shifts this vector by the broadcast of an input scalar,
      * selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane to left shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to left shift
      * @param m the mask controlling lane selection
      * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract LongVector shiftL(int s, VectorMask<Long> m);
+    public abstract LongVector shiftLeft(int s, VectorMask<Long> m);
 
     /**
      * Logically left shifts this vector by an input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of logically left shifting this vector by the input
      * vector
      */
-    public abstract LongVector shiftL(Vector<Long> v);
+    public abstract LongVector shiftLeft(Vector<Long> v);
 
     /**
      * Logically left shifts this vector by an input vector, selecting lane
      * elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
-     * operation ({@code <<}) to each lane.
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of logically left shifting this vector by the input
      * vector
      */
-    public LongVector shiftL(Vector<Long> v, VectorMask<Long> m) {
-        return bOp(v, m, (i, a, b) -> (long) (a << b));
+    public LongVector shiftLeft(Vector<Long> v, VectorMask<Long> m) {
+        return blend(shiftLeft(v), m);
     }
 
     // logical, or unsigned, shift right
 
-    /**
+     /**
      * Logically right shifts (or unsigned right shifts) this vector by the
      * broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane to logically right shift the
+     * element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract LongVector shiftR(int s);
+    public abstract LongVector shiftRight(int s);
 
-    /**
+     /**
      * Logically right shifts (or unsigned right shifts) this vector by the
      * broadcast of an input scalar, selecting lane elements controlled by a
      * mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>}) to each lane to logically right shift the
+     * element by shift value as specified by the input scalar.
      *
      * @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
      */
-    public abstract LongVector shiftR(int s, VectorMask<Long> m);
+    public abstract LongVector shiftRight(int s, VectorMask<Long> m);
 
     /**
      * Logically right shifts (or unsigned right shifts) this vector by an
      * input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of logically right shifting this vector by the
      * input vector
      */
-    public abstract LongVector shiftR(Vector<Long> v);
+    public abstract LongVector shiftRight(Vector<Long> v);
 
     /**
      * Logically right shifts (or unsigned right shifts) this vector by an
      * input vector, selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane.
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of logically right shifting this vector by the
      * input vector
      */
-    public LongVector shiftR(Vector<Long> v, VectorMask<Long> m) {
-        return bOp(v, m, (i, a, b) -> (long) (a >>> b));
+    public LongVector shiftRight(Vector<Long> v, VectorMask<Long> m) {
+        return blend(shiftRight(v), m);
     }
 
     /**
@@ -1113,13 +1121,14 @@
      * broadcast of an input scalar.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane to arithmetically
+     * right shift the element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract LongVector aShiftR(int s);
+    public abstract LongVector shiftArithmeticRight(int s);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1127,42 +1136,45 @@
      * mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane to arithmetically
+     * right shift the element by shift value as specified by the input scalar.
      *
      * @param s the input scalar; the number of the bits to right shift
      * @param m the mask controlling lane selection
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract LongVector aShiftR(int s, VectorMask<Long> m);
+    public abstract LongVector shiftArithmeticRight(int s, VectorMask<Long> m);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by an
      * input vector.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @return the result of arithmetically right shifting this vector by the
      * input vector
      */
-    public abstract LongVector aShiftR(Vector<Long> v);
+    public abstract LongVector shiftArithmeticRight(Vector<Long> v);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by an
      * input vector, selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive arithmetic right
-     * shift operation ({@code >>}) to each lane.
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
      *
      * @param v the input vector
      * @param m the mask controlling lane selection
      * @return the result of arithmetically right shifting this vector by the
      * input vector
      */
-    public LongVector aShiftR(Vector<Long> v, VectorMask<Long> m) {
-        return bOp(v, m, (i, a, b) -> (long) (a >> b));
+    public LongVector shiftArithmeticRight(Vector<Long> v, VectorMask<Long> m) {
+        return blend(shiftArithmeticRight(v), m);
     }
 
     /**
@@ -1179,8 +1191,8 @@
      * input scalar
      */
     @ForceInline
-    public final LongVector rotateL(int s) {
-        return shiftL(s).or(shiftR(-s));
+    public final LongVector rotateLeft(int s) {
+        return shiftLeft(s).or(shiftRight(-s));
     }
 
     /**
@@ -1199,8 +1211,8 @@
      * input scalar
      */
     @ForceInline
-    public final LongVector rotateL(int s, VectorMask<Long> m) {
-        return shiftL(s, m).or(shiftR(-s, m), m);
+    public final LongVector rotateLeft(int s, VectorMask<Long> m) {
+        return shiftLeft(s, m).or(shiftRight(-s, m), m);
     }
 
     /**
@@ -1217,8 +1229,8 @@
      * input scalar
      */
     @ForceInline
-    public final LongVector rotateR(int s) {
-        return shiftR(s).or(shiftL(-s));
+    public final LongVector rotateRight(int s) {
+        return shiftRight(s).or(shiftLeft(-s));
     }
 
     /**
@@ -1237,8 +1249,8 @@
      * input scalar
      */
     @ForceInline
-    public final LongVector rotateR(int s, VectorMask<Long> m) {
-        return shiftR(s, m).or(shiftL(-s, m), m);
+    public final LongVector rotateRight(int s, VectorMask<Long> m) {
+        return shiftRight(s, m).or(shiftLeft(-s, m), m);
     }
 
     /**
@@ -1276,7 +1288,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract long addAll();
+    public abstract long addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1289,7 +1301,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract long addAll(VectorMask<Long> m);
+    public abstract long addLanes(VectorMask<Long> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1300,7 +1312,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract long mulAll();
+    public abstract long mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1313,7 +1325,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract long mulAll(VectorMask<Long> m);
+    public abstract long mulLanes(VectorMask<Long> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1325,7 +1337,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract long minAll();
+    public abstract long minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1339,7 +1351,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract long minAll(VectorMask<Long> m);
+    public abstract long minLanes(VectorMask<Long> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1351,7 +1363,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract long maxAll();
+    public abstract long maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1365,7 +1377,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract long maxAll(VectorMask<Long> m);
+    public abstract long maxLanes(VectorMask<Long> m);
 
     /**
      * Logically ORs all lane elements of this vector.
@@ -1376,7 +1388,7 @@
      *
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract long orAll();
+    public abstract long orLanes();
 
     /**
      * Logically ORs all lane elements of this vector, selecting lane elements
@@ -1389,7 +1401,7 @@
      * @param m the mask controlling lane selection
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract long orAll(VectorMask<Long> m);
+    public abstract long orLanes(VectorMask<Long> m);
 
     /**
      * Logically ANDs all lane elements of this vector.
@@ -1400,7 +1412,7 @@
      *
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract long andAll();
+    public abstract long andLanes();
 
     /**
      * Logically ANDs all lane elements of this vector, selecting lane elements
@@ -1413,7 +1425,7 @@
      * @param m the mask controlling lane selection
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract long andAll(VectorMask<Long> m);
+    public abstract long andLanes(VectorMask<Long> m);
 
     /**
      * Logically XORs all lane elements of this vector.
@@ -1424,7 +1436,7 @@
      *
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract long xorAll();
+    public abstract long xorLanes();
 
     /**
      * Logically XORs all lane elements of this vector, selecting lane elements
@@ -1437,7 +1449,7 @@
      * @param m the mask controlling lane selection
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract long xorAll(VectorMask<Long> m);
+    public abstract long xorLanes(VectorMask<Long> m);
 
     // Type specific accessors
 
@@ -1580,13 +1592,13 @@
         final Function<long[], LongVector> vectorFactory;
 
         private LongSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<long[], LongVector> vectorFactory,
                           Function<boolean[], VectorMask<Long>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Long>> shuffleFromArrayFactory,
                           fShuffleFromArray<Long> shuffleFromOpFactory) {
-            super(shape, long.class, Long.SIZE, boxType, maskType, maskFactory,
+            super(shape, long.class, Long.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -155,7 +155,7 @@
         return VectorIntrinsics.cast(
             Short128Vector.class,
             short.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -293,7 +293,7 @@
     @ForceInline
     public ShortVector reshape(VectorSpecies<Short> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Short64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Short64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short128Vector.class,
                 short.class, LENGTH,
@@ -302,7 +302,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Short128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Short128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short128Vector.class,
                 short.class, LENGTH,
@@ -311,7 +311,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Short256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Short256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short128Vector.class,
                 short.class, LENGTH,
@@ -320,7 +320,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Short512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Short512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short128Vector.class,
                 short.class, LENGTH,
@@ -330,7 +330,7 @@
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ShortMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ShortMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short128Vector.class,
                 short.class, LENGTH,
@@ -657,47 +657,74 @@
 
     @Override
     @ForceInline
-    public Short128Vector shiftL(int s) {
+    public Short128Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Short128Vector.class, short.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 15))));
+            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short128Vector shiftL(int s, VectorMask<Short> m) {
-        return blend(shiftL(s), m);
+    public Short128Vector shiftLeft(int s, VectorMask<Short> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Short128Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Short128Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 15))));
+    public Short128Vector shiftLeft(Vector<Short> s) {
+        Short128Vector shiftv = (Short128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a << (b & 0xF)));
     }
 
     @Override
     @ForceInline
-    public Short128Vector shiftR(int s, VectorMask<Short> m) {
-        return blend(shiftR(s), m);
+    public Short128Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Short128Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short128Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Short128Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 15))));
+    public Short128Vector shiftRight(int s, VectorMask<Short> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Short128Vector aShiftR(int s, VectorMask<Short> m) {
-        return blend(aShiftR(s), m);
+    public Short128Vector shiftRight(Vector<Short> s) {
+        Short128Vector shiftv = (Short128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >>> (b & 0xF)));
+    }
+
+    @Override
+    @ForceInline
+    public Short128Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Short128Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 0xF))));
+    }
+
+    @Override
+    @ForceInline
+    public Short128Vector shiftArithmeticRight(int s, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Short128Vector shiftArithmeticRight(Vector<Short> s) {
+        Short128Vector shiftv = (Short128Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >> (b & 0xF)));
     }
     // Ternary operations
 
@@ -706,7 +733,7 @@
 
     @Override
     @ForceInline
-    public short addAll() {
+    public short addLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Short128Vector.class, short.class, LENGTH,
             this,
@@ -715,7 +742,7 @@
 
     @Override
     @ForceInline
-    public short andAll() {
+    public short andLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Short128Vector.class, short.class, LENGTH,
             this,
@@ -724,13 +751,13 @@
 
     @Override
     @ForceInline
-    public short andAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andAll();
+    public short andLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll() {
+    public short minLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Short128Vector.class, short.class, LENGTH,
             this,
@@ -739,7 +766,7 @@
 
     @Override
     @ForceInline
-    public short maxAll() {
+    public short maxLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Short128Vector.class, short.class, LENGTH,
             this,
@@ -748,7 +775,7 @@
 
     @Override
     @ForceInline
-    public short mulAll() {
+    public short mulLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Short128Vector.class, short.class, LENGTH,
             this,
@@ -757,7 +784,7 @@
 
     @Override
     @ForceInline
-    public short orAll() {
+    public short orLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short128Vector.class, short.class, LENGTH,
             this,
@@ -766,13 +793,13 @@
 
     @Override
     @ForceInline
-    public short orAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orAll();
+    public short orLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public short xorAll() {
+    public short xorLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Short128Vector.class, short.class, LENGTH,
             this,
@@ -781,34 +808,34 @@
 
     @Override
     @ForceInline
-    public short xorAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorAll();
+    public short xorLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public short addAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addAll();
+    public short addLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public short mulAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulAll();
+    public short mulLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minAll();
+    public short minLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public short maxAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxAll();
+    public short maxLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1029,7 +1056,7 @@
 
 
     @Override
-    public Short128Vector rotateEL(int j) {
+    public Short128Vector rotateLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1039,7 +1066,7 @@
     }
 
     @Override
-    public Short128Vector rotateER(int j) {
+    public Short128Vector rotateLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1054,7 +1081,7 @@
     }
 
     @Override
-    public Short128Vector shiftEL(int j) {
+    public Short128Vector shiftLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1064,7 +1091,7 @@
     }
 
     @Override
-    public Short128Vector shiftER(int j) {
+    public Short128Vector shiftLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -155,7 +155,7 @@
         return VectorIntrinsics.cast(
             Short256Vector.class,
             short.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -293,7 +293,7 @@
     @ForceInline
     public ShortVector reshape(VectorSpecies<Short> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Short64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Short64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short256Vector.class,
                 short.class, LENGTH,
@@ -302,7 +302,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Short128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Short128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short256Vector.class,
                 short.class, LENGTH,
@@ -311,7 +311,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Short256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Short256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short256Vector.class,
                 short.class, LENGTH,
@@ -320,7 +320,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Short512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Short512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short256Vector.class,
                 short.class, LENGTH,
@@ -330,7 +330,7 @@
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ShortMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ShortMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short256Vector.class,
                 short.class, LENGTH,
@@ -657,47 +657,74 @@
 
     @Override
     @ForceInline
-    public Short256Vector shiftL(int s) {
+    public Short256Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Short256Vector.class, short.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 15))));
+            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short256Vector shiftL(int s, VectorMask<Short> m) {
-        return blend(shiftL(s), m);
+    public Short256Vector shiftLeft(int s, VectorMask<Short> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Short256Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Short256Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 15))));
+    public Short256Vector shiftLeft(Vector<Short> s) {
+        Short256Vector shiftv = (Short256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a << (b & 0xF)));
     }
 
     @Override
     @ForceInline
-    public Short256Vector shiftR(int s, VectorMask<Short> m) {
-        return blend(shiftR(s), m);
+    public Short256Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Short256Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short256Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Short256Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 15))));
+    public Short256Vector shiftRight(int s, VectorMask<Short> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Short256Vector aShiftR(int s, VectorMask<Short> m) {
-        return blend(aShiftR(s), m);
+    public Short256Vector shiftRight(Vector<Short> s) {
+        Short256Vector shiftv = (Short256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >>> (b & 0xF)));
+    }
+
+    @Override
+    @ForceInline
+    public Short256Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Short256Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 0xF))));
+    }
+
+    @Override
+    @ForceInline
+    public Short256Vector shiftArithmeticRight(int s, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Short256Vector shiftArithmeticRight(Vector<Short> s) {
+        Short256Vector shiftv = (Short256Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >> (b & 0xF)));
     }
     // Ternary operations
 
@@ -706,7 +733,7 @@
 
     @Override
     @ForceInline
-    public short addAll() {
+    public short addLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Short256Vector.class, short.class, LENGTH,
             this,
@@ -715,7 +742,7 @@
 
     @Override
     @ForceInline
-    public short andAll() {
+    public short andLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Short256Vector.class, short.class, LENGTH,
             this,
@@ -724,13 +751,13 @@
 
     @Override
     @ForceInline
-    public short andAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andAll();
+    public short andLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll() {
+    public short minLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Short256Vector.class, short.class, LENGTH,
             this,
@@ -739,7 +766,7 @@
 
     @Override
     @ForceInline
-    public short maxAll() {
+    public short maxLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Short256Vector.class, short.class, LENGTH,
             this,
@@ -748,7 +775,7 @@
 
     @Override
     @ForceInline
-    public short mulAll() {
+    public short mulLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Short256Vector.class, short.class, LENGTH,
             this,
@@ -757,7 +784,7 @@
 
     @Override
     @ForceInline
-    public short orAll() {
+    public short orLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short256Vector.class, short.class, LENGTH,
             this,
@@ -766,13 +793,13 @@
 
     @Override
     @ForceInline
-    public short orAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orAll();
+    public short orLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public short xorAll() {
+    public short xorLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Short256Vector.class, short.class, LENGTH,
             this,
@@ -781,34 +808,34 @@
 
     @Override
     @ForceInline
-    public short xorAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorAll();
+    public short xorLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public short addAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addAll();
+    public short addLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public short mulAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulAll();
+    public short mulLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minAll();
+    public short minLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public short maxAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxAll();
+    public short maxLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1029,7 +1056,7 @@
 
 
     @Override
-    public Short256Vector rotateEL(int j) {
+    public Short256Vector rotateLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1039,7 +1066,7 @@
     }
 
     @Override
-    public Short256Vector rotateER(int j) {
+    public Short256Vector rotateLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1054,7 +1081,7 @@
     }
 
     @Override
-    public Short256Vector shiftEL(int j) {
+    public Short256Vector shiftLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1064,7 +1091,7 @@
     }
 
     @Override
-    public Short256Vector shiftER(int j) {
+    public Short256Vector shiftLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -155,7 +155,7 @@
         return VectorIntrinsics.cast(
             Short512Vector.class,
             short.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -293,7 +293,7 @@
     @ForceInline
     public ShortVector reshape(VectorSpecies<Short> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Short64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Short64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short512Vector.class,
                 short.class, LENGTH,
@@ -302,7 +302,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Short128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Short128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short512Vector.class,
                 short.class, LENGTH,
@@ -311,7 +311,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Short256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Short256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short512Vector.class,
                 short.class, LENGTH,
@@ -320,7 +320,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Short512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Short512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short512Vector.class,
                 short.class, LENGTH,
@@ -330,7 +330,7 @@
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ShortMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ShortMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short512Vector.class,
                 short.class, LENGTH,
@@ -657,47 +657,74 @@
 
     @Override
     @ForceInline
-    public Short512Vector shiftL(int s) {
+    public Short512Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Short512Vector.class, short.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 15))));
+            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short512Vector shiftL(int s, VectorMask<Short> m) {
-        return blend(shiftL(s), m);
+    public Short512Vector shiftLeft(int s, VectorMask<Short> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Short512Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Short512Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 15))));
+    public Short512Vector shiftLeft(Vector<Short> s) {
+        Short512Vector shiftv = (Short512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a << (b & 0xF)));
     }
 
     @Override
     @ForceInline
-    public Short512Vector shiftR(int s, VectorMask<Short> m) {
-        return blend(shiftR(s), m);
+    public Short512Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Short512Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short512Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Short512Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 15))));
+    public Short512Vector shiftRight(int s, VectorMask<Short> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Short512Vector aShiftR(int s, VectorMask<Short> m) {
-        return blend(aShiftR(s), m);
+    public Short512Vector shiftRight(Vector<Short> s) {
+        Short512Vector shiftv = (Short512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >>> (b & 0xF)));
+    }
+
+    @Override
+    @ForceInline
+    public Short512Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Short512Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 0xF))));
+    }
+
+    @Override
+    @ForceInline
+    public Short512Vector shiftArithmeticRight(int s, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Short512Vector shiftArithmeticRight(Vector<Short> s) {
+        Short512Vector shiftv = (Short512Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >> (b & 0xF)));
     }
     // Ternary operations
 
@@ -706,7 +733,7 @@
 
     @Override
     @ForceInline
-    public short addAll() {
+    public short addLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Short512Vector.class, short.class, LENGTH,
             this,
@@ -715,7 +742,7 @@
 
     @Override
     @ForceInline
-    public short andAll() {
+    public short andLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Short512Vector.class, short.class, LENGTH,
             this,
@@ -724,13 +751,13 @@
 
     @Override
     @ForceInline
-    public short andAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andAll();
+    public short andLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll() {
+    public short minLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Short512Vector.class, short.class, LENGTH,
             this,
@@ -739,7 +766,7 @@
 
     @Override
     @ForceInline
-    public short maxAll() {
+    public short maxLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Short512Vector.class, short.class, LENGTH,
             this,
@@ -748,7 +775,7 @@
 
     @Override
     @ForceInline
-    public short mulAll() {
+    public short mulLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Short512Vector.class, short.class, LENGTH,
             this,
@@ -757,7 +784,7 @@
 
     @Override
     @ForceInline
-    public short orAll() {
+    public short orLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short512Vector.class, short.class, LENGTH,
             this,
@@ -766,13 +793,13 @@
 
     @Override
     @ForceInline
-    public short orAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orAll();
+    public short orLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public short xorAll() {
+    public short xorLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Short512Vector.class, short.class, LENGTH,
             this,
@@ -781,34 +808,34 @@
 
     @Override
     @ForceInline
-    public short xorAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorAll();
+    public short xorLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public short addAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addAll();
+    public short addLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public short mulAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulAll();
+    public short mulLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minAll();
+    public short minLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public short maxAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxAll();
+    public short maxLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1029,7 +1056,7 @@
 
 
     @Override
-    public Short512Vector rotateEL(int j) {
+    public Short512Vector rotateLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1039,7 +1066,7 @@
     }
 
     @Override
-    public Short512Vector rotateER(int j) {
+    public Short512Vector rotateLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1054,7 +1081,7 @@
     }
 
     @Override
-    public Short512Vector shiftEL(int j) {
+    public Short512Vector shiftLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1064,7 +1091,7 @@
     }
 
     @Override
-    public Short512Vector shiftER(int j) {
+    public Short512Vector shiftLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -155,7 +155,7 @@
         return VectorIntrinsics.cast(
             Short64Vector.class,
             short.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -293,7 +293,7 @@
     @ForceInline
     public ShortVector reshape(VectorSpecies<Short> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Short64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Short64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short64Vector.class,
                 short.class, LENGTH,
@@ -302,7 +302,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Short128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Short128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short64Vector.class,
                 short.class, LENGTH,
@@ -311,7 +311,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Short256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Short256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short64Vector.class,
                 short.class, LENGTH,
@@ -320,7 +320,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Short512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Short512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short64Vector.class,
                 short.class, LENGTH,
@@ -330,7 +330,7 @@
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ShortMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ShortMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 Short64Vector.class,
                 short.class, LENGTH,
@@ -657,47 +657,74 @@
 
     @Override
     @ForceInline
-    public Short64Vector shiftL(int s) {
+    public Short64Vector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, Short64Vector.class, short.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 15))));
+            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short64Vector shiftL(int s, VectorMask<Short> m) {
-        return blend(shiftL(s), m);
+    public Short64Vector shiftLeft(int s, VectorMask<Short> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public Short64Vector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, Short64Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 15))));
+    public Short64Vector shiftLeft(Vector<Short> s) {
+        Short64Vector shiftv = (Short64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a << (b & 0xF)));
     }
 
     @Override
     @ForceInline
-    public Short64Vector shiftR(int s, VectorMask<Short> m) {
-        return blend(shiftR(s), m);
+    public Short64Vector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, Short64Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public Short64Vector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, Short64Vector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 15))));
+    public Short64Vector shiftRight(int s, VectorMask<Short> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public Short64Vector aShiftR(int s, VectorMask<Short> m) {
-        return blend(aShiftR(s), m);
+    public Short64Vector shiftRight(Vector<Short> s) {
+        Short64Vector shiftv = (Short64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >>> (b & 0xF)));
+    }
+
+    @Override
+    @ForceInline
+    public Short64Vector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, Short64Vector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 0xF))));
+    }
+
+    @Override
+    @ForceInline
+    public Short64Vector shiftArithmeticRight(int s, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public Short64Vector shiftArithmeticRight(Vector<Short> s) {
+        Short64Vector shiftv = (Short64Vector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >> (b & 0xF)));
     }
     // Ternary operations
 
@@ -706,7 +733,7 @@
 
     @Override
     @ForceInline
-    public short addAll() {
+    public short addLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, Short64Vector.class, short.class, LENGTH,
             this,
@@ -715,7 +742,7 @@
 
     @Override
     @ForceInline
-    public short andAll() {
+    public short andLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, Short64Vector.class, short.class, LENGTH,
             this,
@@ -724,13 +751,13 @@
 
     @Override
     @ForceInline
-    public short andAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andAll();
+    public short andLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll() {
+    public short minLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, Short64Vector.class, short.class, LENGTH,
             this,
@@ -739,7 +766,7 @@
 
     @Override
     @ForceInline
-    public short maxAll() {
+    public short maxLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, Short64Vector.class, short.class, LENGTH,
             this,
@@ -748,7 +775,7 @@
 
     @Override
     @ForceInline
-    public short mulAll() {
+    public short mulLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, Short64Vector.class, short.class, LENGTH,
             this,
@@ -757,7 +784,7 @@
 
     @Override
     @ForceInline
-    public short orAll() {
+    public short orLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, Short64Vector.class, short.class, LENGTH,
             this,
@@ -766,13 +793,13 @@
 
     @Override
     @ForceInline
-    public short orAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orAll();
+    public short orLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public short xorAll() {
+    public short xorLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, Short64Vector.class, short.class, LENGTH,
             this,
@@ -781,34 +808,34 @@
 
     @Override
     @ForceInline
-    public short xorAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorAll();
+    public short xorLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public short addAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addAll();
+    public short addLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public short mulAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulAll();
+    public short mulLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minAll();
+    public short minLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public short maxAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxAll();
+    public short maxLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1029,7 +1056,7 @@
 
 
     @Override
-    public Short64Vector rotateEL(int j) {
+    public Short64Vector rotateLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1039,7 +1066,7 @@
     }
 
     @Override
-    public Short64Vector rotateER(int j) {
+    public Short64Vector rotateLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1054,7 +1081,7 @@
     }
 
     @Override
-    public Short64Vector shiftEL(int j) {
+    public Short64Vector shiftLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1064,7 +1091,7 @@
     }
 
     @Override
-    public Short64Vector shiftER(int j) {
+    public Short64Vector shiftLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -155,7 +155,7 @@
         return VectorIntrinsics.cast(
             ShortMaxVector.class,
             short.class, LENGTH,
-            s.boxType(),
+            s.vectorType(),
             s.elementType(), LENGTH,
             this, s,
             (species, vector) -> vector.castDefault(species)
@@ -293,7 +293,7 @@
     @ForceInline
     public ShortVector reshape(VectorSpecies<Short> s) {
         Objects.requireNonNull(s);
-        if (s.bitSize() == 64 && (s.boxType() == Short64Vector.class)) {
+        if (s.bitSize() == 64 && (s.vectorType() == Short64Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ShortMaxVector.class,
                 short.class, LENGTH,
@@ -302,7 +302,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 128 && (s.boxType() == Short128Vector.class)) {
+        } else if (s.bitSize() == 128 && (s.vectorType() == Short128Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ShortMaxVector.class,
                 short.class, LENGTH,
@@ -311,7 +311,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 256 && (s.boxType() == Short256Vector.class)) {
+        } else if (s.bitSize() == 256 && (s.vectorType() == Short256Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ShortMaxVector.class,
                 short.class, LENGTH,
@@ -320,7 +320,7 @@
                 this, s,
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
-        } else if (s.bitSize() == 512 && (s.boxType() == Short512Vector.class)) {
+        } else if (s.bitSize() == 512 && (s.vectorType() == Short512Vector.class)) {
             return VectorIntrinsics.reinterpret(
                 ShortMaxVector.class,
                 short.class, LENGTH,
@@ -330,7 +330,7 @@
                 (species, vector) -> (ShortVector) vector.defaultReinterpret(species)
             );
         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
-                && (s.bitSize() % 128 == 0) && (s.boxType() == ShortMaxVector.class)) {
+                && (s.bitSize() % 128 == 0) && (s.vectorType() == ShortMaxVector.class)) {
             return VectorIntrinsics.reinterpret(
                 ShortMaxVector.class,
                 short.class, LENGTH,
@@ -657,47 +657,74 @@
 
     @Override
     @ForceInline
-    public ShortMaxVector shiftL(int s) {
+    public ShortMaxVector shiftLeft(int s) {
         return VectorIntrinsics.broadcastInt(
             VECTOR_OP_LSHIFT, ShortMaxVector.class, short.class, LENGTH,
             this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 15))));
+            (v, i) -> v.uOp((__, a) -> (short) (a << (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public ShortMaxVector shiftL(int s, VectorMask<Short> m) {
-        return blend(shiftL(s), m);
+    public ShortMaxVector shiftLeft(int s, VectorMask<Short> m) {
+        return blend(shiftLeft(s), m);
     }
 
     @Override
     @ForceInline
-    public ShortMaxVector shiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_URSHIFT, ShortMaxVector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 15))));
+    public ShortMaxVector shiftLeft(Vector<Short> s) {
+        ShortMaxVector shiftv = (ShortMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a << (b & 0xF)));
     }
 
     @Override
     @ForceInline
-    public ShortMaxVector shiftR(int s, VectorMask<Short> m) {
-        return blend(shiftR(s), m);
+    public ShortMaxVector shiftRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_URSHIFT, ShortMaxVector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) ((a & 0xFFFF) >>> (i & 0xF))));
     }
 
     @Override
     @ForceInline
-    public ShortMaxVector aShiftR(int s) {
-        return VectorIntrinsics.broadcastInt(
-            VECTOR_OP_RSHIFT, ShortMaxVector.class, short.class, LENGTH,
-            this, s,
-            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 15))));
+    public ShortMaxVector shiftRight(int s, VectorMask<Short> m) {
+        return blend(shiftRight(s), m);
     }
 
     @Override
     @ForceInline
-    public ShortMaxVector aShiftR(int s, VectorMask<Short> m) {
-        return blend(aShiftR(s), m);
+    public ShortMaxVector shiftRight(Vector<Short> s) {
+        ShortMaxVector shiftv = (ShortMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >>> (b & 0xF)));
+    }
+
+    @Override
+    @ForceInline
+    public ShortMaxVector shiftArithmeticRight(int s) {
+        return VectorIntrinsics.broadcastInt(
+            VECTOR_OP_RSHIFT, ShortMaxVector.class, short.class, LENGTH,
+            this, s,
+            (v, i) -> v.uOp((__, a) -> (short) (a >> (i & 0xF))));
+    }
+
+    @Override
+    @ForceInline
+    public ShortMaxVector shiftArithmeticRight(int s, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(s), m);
+    }
+
+    @Override
+    @ForceInline
+    public ShortMaxVector shiftArithmeticRight(Vector<Short> s) {
+        ShortMaxVector shiftv = (ShortMaxVector)s;
+        // As per shift specification for Java, mask the shift count.
+        shiftv = shiftv.and(ShortVector.broadcast(SPECIES, (short) 0xF));
+        return this.bOp(shiftv, (i, a, b) -> (short) (a >> (b & 0xF)));
     }
     // Ternary operations
 
@@ -706,7 +733,7 @@
 
     @Override
     @ForceInline
-    public short addAll() {
+    public short addLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_ADD, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -715,7 +742,7 @@
 
     @Override
     @ForceInline
-    public short andAll() {
+    public short andLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_AND, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -724,13 +751,13 @@
 
     @Override
     @ForceInline
-    public short andAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andAll();
+    public short andLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) -1).blend(this, m).andLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll() {
+    public short minLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MIN, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -739,7 +766,7 @@
 
     @Override
     @ForceInline
-    public short maxAll() {
+    public short maxLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MAX, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -748,7 +775,7 @@
 
     @Override
     @ForceInline
-    public short mulAll() {
+    public short mulLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_MUL, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -757,7 +784,7 @@
 
     @Override
     @ForceInline
-    public short orAll() {
+    public short orLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_OR, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -766,13 +793,13 @@
 
     @Override
     @ForceInline
-    public short orAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orAll();
+    public short orLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).orLanes();
     }
 
     @Override
     @ForceInline
-    public short xorAll() {
+    public short xorLanes() {
         return (short) VectorIntrinsics.reductionCoerced(
             VECTOR_OP_XOR, ShortMaxVector.class, short.class, LENGTH,
             this,
@@ -781,34 +808,34 @@
 
     @Override
     @ForceInline
-    public short xorAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorAll();
+    public short xorLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).xorLanes();
     }
 
 
     @Override
     @ForceInline
-    public short addAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addAll();
+    public short addLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 0).blend(this, m).addLanes();
     }
 
 
     @Override
     @ForceInline
-    public short mulAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulAll();
+    public short mulLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, (short) 1).blend(this, m).mulLanes();
     }
 
     @Override
     @ForceInline
-    public short minAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minAll();
+    public short minLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MAX_VALUE).blend(this, m).minLanes();
     }
 
     @Override
     @ForceInline
-    public short maxAll(VectorMask<Short> m) {
-        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxAll();
+    public short maxLanes(VectorMask<Short> m) {
+        return ShortVector.broadcast(SPECIES, Short.MIN_VALUE).blend(this, m).maxLanes();
     }
 
     @Override
@@ -1029,7 +1056,7 @@
 
 
     @Override
-    public ShortMaxVector rotateEL(int j) {
+    public ShortMaxVector rotateLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1039,7 +1066,7 @@
     }
 
     @Override
-    public ShortMaxVector rotateER(int j) {
+    public ShortMaxVector rotateLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length(); i++){
@@ -1054,7 +1081,7 @@
     }
 
     @Override
-    public ShortMaxVector shiftEL(int j) {
+    public ShortMaxVector shiftLanesLeft(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++) {
@@ -1064,7 +1091,7 @@
     }
 
     @Override
-    public ShortMaxVector shiftER(int j) {
+    public ShortMaxVector shiftLanesRight(int j) {
         short[] vec = getElements();
         short[] res = new short[length()];
         for (int i = 0; i < length() - j; i++){
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -112,7 +112,7 @@
     @ForceInline
     @SuppressWarnings("unchecked")
     public static ShortVector zero(VectorSpecies<Short> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<ShortVector>) species.boxType(), short.class, species.length(),
+        return VectorIntrinsics.broadcastCoerced((Class<ShortVector>) species.vectorType(), short.class, species.length(),
                                                  0, species,
                                                  ((bits, s) -> ((ShortSpecies)s).op(i -> (short)bits)));
     }
@@ -142,7 +142,7 @@
     public static ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset) {
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<ShortVector>) species.boxType(), short.class, species.length(),
+        return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> {
@@ -200,7 +200,7 @@
     public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset){
         Objects.requireNonNull(a);
         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
-        return VectorIntrinsics.load((Class<ShortVector>) species.boxType(), short.class, species.length(),
+        return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_SHORT_BASE_OFFSET,
                                      a, offset, species,
                                      (c, idx, s) -> ((ShortSpecies)s).op(n -> c[idx + n]));
@@ -313,7 +313,7 @@
             throw new IllegalArgumentException();
         }
         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
-        return VectorIntrinsics.load((Class<ShortVector>) species.boxType(), short.class, species.length(),
+        return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
                                      bb, offset, species,
                                      (c, idx, s) -> {
@@ -369,7 +369,7 @@
      * value {@code e}.
      *
      * @param species species of the desired vector
-     * @param e the value
+     * @param e the value to be broadcasted
      * @return a vector of vector where all lane elements are set to
      * the primitive value {@code e}
      */
@@ -377,7 +377,7 @@
     @SuppressWarnings("unchecked")
     public static ShortVector broadcast(VectorSpecies<Short> species, short e) {
         return VectorIntrinsics.broadcastCoerced(
-            (Class<ShortVector>) species.boxType(), short.class, species.length(),
+            (Class<ShortVector>) species.vectorType(), short.class, species.length(),
             e, species,
             ((bits, sp) -> ((ShortSpecies)sp).op(i -> (short)bits)));
     }
@@ -401,7 +401,7 @@
     public static ShortVector scalars(VectorSpecies<Short> species, short... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
-        return VectorIntrinsics.load((Class<ShortVector>) species.boxType(), short.class, species.length(),
+        return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
                                      es, Unsafe.ARRAY_SHORT_BASE_OFFSET,
                                      es, ix, species,
                                      (c, idx, sp) -> ((ShortSpecies)sp).op(n -> c[idx + n]));
@@ -779,25 +779,25 @@
      * {@inheritDoc}
      */
     @Override
-    public abstract ShortVector rotateEL(int i);
+    public abstract ShortVector rotateLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ShortVector rotateER(int i);
+    public abstract ShortVector rotateLanesRight(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ShortVector shiftEL(int i);
+    public abstract ShortVector shiftLanesLeft(int i);
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public abstract ShortVector shiftER(int i);
+    public abstract ShortVector shiftLanesRight(int i);
 
 
 
@@ -977,16 +977,16 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
      * operation ({@code <<}) to each lane 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
+     * 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 ({@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
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector shiftL(int s);
+    public abstract ShortVector shiftLeft(int s);
 
     /**
      * Logically left shifts this vector by the broadcast of an input scalar,
@@ -994,18 +994,53 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical left shift
      * operation ({@code <<}) to each lane 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
+     * 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 ({@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
      * @param m the mask controlling lane selection
-     * @return the result of logically left shifting left this vector by the
+     * @return the result of logically left shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector shiftL(int s, VectorMask<Short> m);
+    public abstract ShortVector shiftLeft(int s, VectorMask<Short> m);
 
+    /**
+     * Logically left shifts this vector by an input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical left shift
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of logically left shifting this vector by the input
+     * vector
+     */
+    public abstract ShortVector shiftLeft(Vector<Short> v);
+
+    /**
+     * Logically left shifts this vector by an input vector, selecting lane
+     * elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical left shift
+     * operation ({@code <<}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of logically left shifting this vector by the input
+     * vector
+     */
+    public ShortVector shiftLeft(Vector<Short> v, VectorMask<Short> m) {
+        return blend(shiftLeft(v), m);
+    }
 
     // logical, or unsigned, shift right
 
@@ -1015,8 +1050,8 @@
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
      * operation ({@code >>>}) to each lane 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
+     * 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 ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
@@ -1024,7 +1059,7 @@
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector shiftR(int s);
+    public abstract ShortVector shiftRight(int s);
 
      /**
      * Logically right shifts (or unsigned right shifts) this vector by the
@@ -1032,9 +1067,9 @@
      * mask.
      * <p>
      * This is a lane-wise binary operation which applies the primitive logical right shift
-     * operation ({@code >>>}) to each lane 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
+     * operation ({@code >>}) to each lane 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 ({@code &}) with the mask value 0xF.
      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
      *
@@ -1043,8 +1078,44 @@
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector shiftR(int s, VectorMask<Short> m);
+    public abstract ShortVector shiftRight(int s, VectorMask<Short> m);
 
+    /**
+     * Logically right shifts (or unsigned right shifts) this vector by an
+     * input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical right shift
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of logically right shifting this vector by the
+     * input vector
+     */
+    public abstract ShortVector shiftRight(Vector<Short> v);
+
+    /**
+     * Logically right shifts (or unsigned right shifts) this vector by an
+     * input vector, selecting lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive logical right shift
+     * operation ({@code >>>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of logically right shifting this vector by the
+     * input vector
+     */
+    public ShortVector shiftRight(Vector<Short> v, VectorMask<Short> m) {
+        return blend(shiftRight(v), m);
+    }
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1061,7 +1132,7 @@
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector aShiftR(int s);
+    public abstract ShortVector shiftArithmeticRight(int s);
 
     /**
      * Arithmetically right shifts (or signed right shifts) this vector by the
@@ -1080,8 +1151,120 @@
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ShortVector aShiftR(int s, VectorMask<Short> m);
+    public abstract ShortVector shiftArithmeticRight(int s, VectorMask<Short> m);
 
+    /**
+     * Arithmetically right shifts (or signed right shifts) this vector by an
+     * input vector.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive arithmetic right
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @return the result of arithmetically right shifting this vector by the
+     * input vector
+     */
+    public abstract ShortVector shiftArithmeticRight(Vector<Short> v);
+
+    /**
+     * Arithmetically right shifts (or signed right shifts) this vector by an
+     * input vector, selecting lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which applies the primitive arithmetic right
+     * shift operation ({@code >>}) to each lane. For each lane of this vector, the
+     * shift value is the corresponding lane of input vector.
+     * 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 ({@code &}) with the mask value 0xF.
+     * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
+     *
+     * @param v the input vector
+     * @param m the mask controlling lane selection
+     * @return the result of arithmetically right shifting this vector by the
+     * input vector
+     */
+    public ShortVector shiftArithmeticRight(Vector<Short> v, VectorMask<Short> m) {
+        return blend(shiftArithmeticRight(v), m);
+    }
+
+    /**
+     * Rotates left this vector by the broadcast of an input scalar.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating left the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0xF.
+     *
+     * @param s the input scalar; the number of the bits to rotate left
+     * @return the result of rotating left this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ShortVector rotateLeft(int s) {
+        return shiftLeft(s).or(shiftRight(-s));
+    }
+
+    /**
+     * Rotates left this vector by the broadcast of an input scalar, selecting
+     * lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating left the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0xF.
+     *
+     * @param s the input scalar; the number of the bits to rotate left
+     * @param m the mask controlling lane selection
+     * @return the result of rotating left this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ShortVector rotateLeft(int s, VectorMask<Short> m) {
+        return shiftLeft(s, m).or(shiftRight(-s, m), m);
+    }
+
+    /**
+     * Rotates right this vector by the broadcast of an input scalar.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating right the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0xF.
+     *
+     * @param s the input scalar; the number of the bits to rotate right
+     * @return the result of rotating right this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ShortVector rotateRight(int s) {
+        return shiftRight(s).or(shiftLeft(-s));
+    }
+
+    /**
+     * Rotates right this vector by the broadcast of an input scalar, selecting
+     * lane elements controlled by a mask.
+     * <p>
+     * This is a lane-wise binary operation which produces the result of rotating right the two's
+     * complement binary representation of each lane of first operand (this vector) by input scalar.
+     * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
+     * It is as if the input value were subjected to a bitwise logical
+     * AND operator ({@code &}) with the mask value 0xF.
+     *
+     * @param s the input scalar; the number of the bits to rotate right
+     * @param m the mask controlling lane selection
+     * @return the result of rotating right this vector by the broadcast of an
+     * input scalar
+     */
+    @ForceInline
+    public final ShortVector rotateRight(int s, VectorMask<Short> m) {
+        return shiftRight(s, m).or(shiftLeft(-s, m), m);
+    }
 
     /**
      * {@inheritDoc}
@@ -1118,7 +1301,7 @@
      *
      * @return the addition of all the lane elements of this vector
      */
-    public abstract short addAll();
+    public abstract short addLanes();
 
     /**
      * Adds all lane elements of this vector, selecting lane elements
@@ -1131,7 +1314,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract short addAll(VectorMask<Short> m);
+    public abstract short addLanes(VectorMask<Short> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1142,7 +1325,7 @@
      *
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract short mulAll();
+    public abstract short mulLanes();
 
     /**
      * Multiplies all lane elements of this vector, selecting lane elements
@@ -1155,7 +1338,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract short mulAll(VectorMask<Short> m);
+    public abstract short mulLanes(VectorMask<Short> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1167,7 +1350,7 @@
      *
      * @return the minimum lane element of this vector
      */
-    public abstract short minAll();
+    public abstract short minLanes();
 
     /**
      * Returns the minimum lane element of this vector, selecting lane elements
@@ -1181,7 +1364,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract short minAll(VectorMask<Short> m);
+    public abstract short minLanes(VectorMask<Short> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1193,7 +1376,7 @@
      *
      * @return the maximum lane element of this vector
      */
-    public abstract short maxAll();
+    public abstract short maxLanes();
 
     /**
      * Returns the maximum lane element of this vector, selecting lane elements
@@ -1207,7 +1390,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract short maxAll(VectorMask<Short> m);
+    public abstract short maxLanes(VectorMask<Short> m);
 
     /**
      * Logically ORs all lane elements of this vector.
@@ -1218,7 +1401,7 @@
      *
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract short orAll();
+    public abstract short orLanes();
 
     /**
      * Logically ORs all lane elements of this vector, selecting lane elements
@@ -1231,7 +1414,7 @@
      * @param m the mask controlling lane selection
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract short orAll(VectorMask<Short> m);
+    public abstract short orLanes(VectorMask<Short> m);
 
     /**
      * Logically ANDs all lane elements of this vector.
@@ -1242,7 +1425,7 @@
      *
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract short andAll();
+    public abstract short andLanes();
 
     /**
      * Logically ANDs all lane elements of this vector, selecting lane elements
@@ -1255,7 +1438,7 @@
      * @param m the mask controlling lane selection
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract short andAll(VectorMask<Short> m);
+    public abstract short andLanes(VectorMask<Short> m);
 
     /**
      * Logically XORs all lane elements of this vector.
@@ -1266,7 +1449,7 @@
      *
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract short xorAll();
+    public abstract short xorLanes();
 
     /**
      * Logically XORs all lane elements of this vector, selecting lane elements
@@ -1279,7 +1462,7 @@
      * @param m the mask controlling lane selection
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract short xorAll(VectorMask<Short> m);
+    public abstract short xorLanes(VectorMask<Short> m);
 
     // Type specific accessors
 
@@ -1426,13 +1609,13 @@
         final Function<short[], ShortVector> vectorFactory;
 
         private ShortSpecies(VectorShape shape,
-                          Class<?> boxType,
+                          Class<?> vectorType,
                           Class<?> maskType,
                           Function<short[], ShortVector> vectorFactory,
                           Function<boolean[], VectorMask<Short>> maskFactory,
                           Function<IntUnaryOperator, VectorShuffle<Short>> shuffleFromArrayFactory,
                           fShuffleFromArray<Short> shuffleFromOpFactory) {
-            super(shape, short.class, Short.SIZE, boxType, maskType, maskFactory,
+            super(shape, short.class, Short.SIZE, vectorType, maskType, maskFactory,
                   shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
         }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Vector.java	Wed Apr 24 22:44:15 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Vector.java	Sat Apr 27 00:59:32 2019 +0200
@@ -105,7 +105,7 @@
  * EVector a = ...;
  * e[] ar = new e[a.length()];
  * for (int i = 0; i < a.length(); i++) {
- *     ar[i] = scalar_unary_op(a.get(i));
+ *     ar[i] = scalar_unary_op(a.lane(i));
  * }
  * EVector r = EVector.fromArray(a.species(), ar, 0);
  * }</pre>
@@ -127,7 +127,7 @@
  * EVector b = ...;
  * e[] ar = new e[a.length()];
  * for (int i = 0; i < a.length(); i++) {
- *     ar[i] = scalar_binary_op(a.get(i), b.get(i));
+ *     ar[i] = scalar_binary_op(a.lane(i), b.lane(i));
  * }
  * EVector r = EVector.fromArray(a.species(), ar, 0);
  * }</pre>
@@ -159,7 +159,7 @@
  * EVector a = ...;
  * e r = <identity value>;
  * for (int i = 0; i < a.length(); i++) {
- *     r = assoc_scalar_binary_op(r, a.get(i));
+ *     r = assoc_scalar_binary_op(r, a.lane(i));
  * }
  * }</pre>
  *
@@ -178,7 +178,7 @@
  * EVector b = ...;
  * boolean[] ar = new boolean[a.length()];
  * for (int i = 0; i < a.length(); i++) {
- *     ar[i] = scalar_binary_test_op(a.get(i), b.get(i));
+ *     ar[i] = scalar_binary_test_op(a.lane(i), b.lane(i));
  * }
  * VectorMask r = VectorMask.fromArray(a.species(), ar, 0);
  * }</pre>
@@ -278,7 +278,7 @@
     /**
      * Returns the element size, in bits, of this vector.
      *
-     * @return the element size, in bits
+     * @return the element size, in bits, of this vector
      */
     public int elementSize() { return species().elementSize(); }
 
@@ -297,9 +297,9 @@
     public int length() { return species().length(); }
 
     /**
-     * Returns the total vector size, in bits.
+     * Returns the total size, in bits, of this vector.
      *
-     * @return the total vector size, in bits
+     * @return the total size, in bits, of this vector
      */
     public int bitSize() { return species().bitSize(); }
 
@@ -391,7 +391,7 @@
      * Negates this vector, selecting lane elements controlled by a mask.
      * <p>
      * This is a lane-wise unary operation which applies the primitive negation operation
-     * ({@code -})to each lane.
+     * ({@code -}) to each lane.
      *
      * @param m the mask controlling lane selection
      * @return the negation this vector
@@ -475,7 +475,7 @@
     /**
      * Tests if this vector is equal to an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive equals
+     * This is a lane-wise binary test operation which applies the primitive equals
      * operation ({@code ==}) to each lane.
      *
      * @param v the input vector
@@ -487,7 +487,7 @@
     /**
      * Tests if this vector is not equal to an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive not equals
+     * This is a lane-wise binary test operation which applies the primitive not equals
      * operation ({@code !=}) to each lane.
      *
      * @param v the input vector
@@ -499,7 +499,7 @@
     /**
      * Tests if this vector is less than an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive less than
+     * This is a lane-wise binary test operation which applies the primitive less than
      * operation ({@code <}) to each lane.
      *
      * @param v the input vector
@@ -511,7 +511,7 @@
     /**
      * Tests if this vector is less or equal to an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive less than
+     * This is a lane-wise binary test operation which applies the primitive less than
      * or equal to operation ({@code <=}) to each lane.
      *
      * @param v the input vector
@@ -523,7 +523,7 @@
     /**
      * Tests if this vector is greater than an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive greater than
+     * This is a lane-wise binary test operation which applies the primitive greater than
      * operation ({@code >}) to each lane.
      *
      * @param v the input vector
@@ -535,7 +535,7 @@
     /**
      * Tests if this vector is greater than or equal to an input vector.
      * <p>
-     * This is a lane-wise binary test operation where the primitive greater than
+     * This is a lane-wise binary test operation which applies the primitive greater than
      * or equal to operation ({@code >=}) to each lane.
      *
      * @param v the input vector
@@ -560,7 +560,7 @@
      * @return the result of rotating left lane elements of this vector by the
      * given number of lanes
      */
-    public abstract Vector<E> rotateEL(int i);
+    public abstract Vector<E> rotateLanesLeft(int i);
 
     /**
      * Rotates right the lane elements of this vector by the given number of
@@ -572,11 +572,11 @@
      * element is placed into the result vector at lane index
      * {@code (N + length() - (i % length())) % length()}
      *
-     * @param i the number of lanes to rotate left
+     * @param i the number of lanes to rotate right
      * @return the result of rotating right lane elements of this vector by the
      * given number of lanes
      */
-    public abstract Vector<E> rotateER(int i);
+    public abstract Vector<E> rotateLanesRight(int i);
 
     /**
      * Shift left the lane elements of this vector by the given number of
@@ -592,7 +592,7 @@
      * given number of lanes
      * @throws IllegalArgumentException if {@code i} is {@code < 0}.
      */
-    public abstract Vector<E> shiftEL(int i);
+    public abstract Vector<E> shiftLanesLeft(int i);
 
     /**
      * Shift right the lane elements of this vector by the given number of
@@ -608,7 +608,7 @@
      * given number of lanes
      * @throws IllegalArgumentException if {@code i} is {@code < 0}.
      */
-    public abstract Vector<E> shiftER(int i);
+    public abstract Vector<E> shiftLanesRight(int i);
 
     /**
      * Blends the lane elements of this vector with those of an input vector,
@@ -628,6 +628,21 @@
     public abstract Vector<E> blend(Vector<E> v, VectorMask<E> m);
 
     /**
+     * Rearranges the lane elements of this vector selecting lane indexes
+     * controlled by a shuffle.