* 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. * @@ -985,7 +985,7 @@ * @return the result of logically left shifting left 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,8 +993,8 @@ *

* 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.
*
@@ -1003,8 +1003,43 @@
* @return the result of logically left shifting left this vector by the
* broadcast of an input scalar
*/
- public abstract ByteVector shiftL(int s, VectorMask

+ * 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

+ * 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

* 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 @@ *

* 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

+ * 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

+ * 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

+ * 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

+ * 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

+ * 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. + *

+ * 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

+ * 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. + *

+ * 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