1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have
  23  * questions.
  24  */
  25 package jdk.incubator.vector;
  26 
  27 import java.nio.ByteBuffer;
  28 import java.nio.ByteOrder;
  29 import java.nio.ReadOnlyBufferException;
  30 import java.util.Arrays;
  31 import java.util.Objects;
  32 import java.util.function.IntUnaryOperator;
  33 
  34 import jdk.internal.misc.Unsafe;
  35 import jdk.internal.vm.annotation.ForceInline;
  36 import static jdk.incubator.vector.VectorIntrinsics.*;
  37 
  38 @SuppressWarnings("cast")
  39 final class Byte128Vector extends ByteVector {
  40     static final Byte128Species SPECIES = new Byte128Species();
  41 
  42     static final Byte128Vector ZERO = new Byte128Vector();
  43 
  44     static final int LENGTH = SPECIES.length();
  45 
  46     private final byte[] vec; // Don't access directly, use getElements() instead.
  47 
  48     private byte[] getElements() {
  49         return VectorIntrinsics.maybeRebox(this).vec;
  50     }
  51 
  52     Byte128Vector() {
  53         vec = new byte[SPECIES.length()];
  54     }
  55 
  56     Byte128Vector(byte[] v) {
  57         vec = v;
  58     }
  59 
  60     @Override
  61     public int length() { return LENGTH; }
  62 
  63     // Unary operator
  64 
  65     @Override
  66     Byte128Vector uOp(FUnOp f) {
  67         byte[] vec = getElements();
  68         byte[] res = new byte[length()];
  69         for (int i = 0; i < length(); i++) {
  70             res[i] = f.apply(i, vec[i]);
  71         }
  72         return new Byte128Vector(res);
  73     }
  74 
  75     @Override
  76     Byte128Vector uOp(Mask<Byte> o, FUnOp f) {
  77         byte[] vec = getElements();
  78         byte[] res = new byte[length()];
  79         boolean[] mbits = ((Byte128Mask)o).getBits();
  80         for (int i = 0; i < length(); i++) {
  81             res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i];
  82         }
  83         return new Byte128Vector(res);
  84     }
  85 
  86     // Binary operator
  87 
  88     @Override
  89     Byte128Vector bOp(Vector<Byte> o, FBinOp f) {
  90         byte[] res = new byte[length()];
  91         byte[] vec1 = this.getElements();
  92         byte[] vec2 = ((Byte128Vector)o).getElements();
  93         for (int i = 0; i < length(); i++) {
  94             res[i] = f.apply(i, vec1[i], vec2[i]);
  95         }
  96         return new Byte128Vector(res);
  97     }
  98 
  99     @Override
 100     Byte128Vector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
 101         byte[] res = new byte[length()];
 102         byte[] vec1 = this.getElements();
 103         byte[] vec2 = ((Byte128Vector)o1).getElements();
 104         boolean[] mbits = ((Byte128Mask)o2).getBits();
 105         for (int i = 0; i < length(); i++) {
 106             res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i];
 107         }
 108         return new Byte128Vector(res);
 109     }
 110 
 111     // Trinary operator
 112 
 113     @Override
 114     Byte128Vector tOp(Vector<Byte> o1, Vector<Byte> o2, FTriOp f) {
 115         byte[] res = new byte[length()];
 116         byte[] vec1 = this.getElements();
 117         byte[] vec2 = ((Byte128Vector)o1).getElements();
 118         byte[] vec3 = ((Byte128Vector)o2).getElements();
 119         for (int i = 0; i < length(); i++) {
 120             res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]);
 121         }
 122         return new Byte128Vector(res);
 123     }
 124 
 125     @Override
 126     Byte128Vector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
 127         byte[] res = new byte[length()];
 128         byte[] vec1 = getElements();
 129         byte[] vec2 = ((Byte128Vector)o1).getElements();
 130         byte[] vec3 = ((Byte128Vector)o2).getElements();
 131         boolean[] mbits = ((Byte128Mask)o3).getBits();
 132         for (int i = 0; i < length(); i++) {
 133             res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i];
 134         }
 135         return new Byte128Vector(res);
 136     }
 137 
 138     @Override
 139     byte rOp(byte v, FBinOp f) {
 140         byte[] vec = getElements();
 141         for (int i = 0; i < length(); i++) {
 142             v = f.apply(i, v, vec[i]);
 143         }
 144         return v;
 145     }
 146 
 147     @Override
 148     @ForceInline
 149     public <F> Vector<F> cast(Species<F> s) {
 150         Objects.requireNonNull(s);
 151         if (s.length() != LENGTH)
 152             throw new IllegalArgumentException("Vector length this species length differ");
 153 
 154         return VectorIntrinsics.cast(
 155             Byte128Vector.class,
 156             byte.class, LENGTH,
 157             s.vectorType(),
 158             s.elementType(), LENGTH,
 159             this, s,
 160             (species, vector) -> vector.castDefault(species)
 161         );
 162     }
 163 
 164     @SuppressWarnings("unchecked")
 165     @ForceInline
 166     private <F> Vector<F> castDefault(Species<F> s) {
 167         int limit = s.length();
 168 
 169         Class<?> stype = s.elementType();
 170         if (stype == byte.class) {
 171             byte[] a = new byte[limit];
 172             for (int i = 0; i < limit; i++) {
 173                 a[i] = (byte) this.get(i);
 174             }
 175             return (Vector) ByteVector.fromArray((ByteVector.ByteSpecies) s, a, 0);
 176         } else if (stype == short.class) {
 177             short[] a = new short[limit];
 178             for (int i = 0; i < limit; i++) {
 179                 a[i] = (short) this.get(i);
 180             }
 181             return (Vector) ShortVector.fromArray((ShortVector.ShortSpecies) s, a, 0);
 182         } else if (stype == int.class) {
 183             int[] a = new int[limit];
 184             for (int i = 0; i < limit; i++) {
 185                 a[i] = (int) this.get(i);
 186             }
 187             return (Vector) IntVector.fromArray((IntVector.IntSpecies) s, a, 0);
 188         } else if (stype == long.class) {
 189             long[] a = new long[limit];
 190             for (int i = 0; i < limit; i++) {
 191                 a[i] = (long) this.get(i);
 192             }
 193             return (Vector) LongVector.fromArray((LongVector.LongSpecies) s, a, 0);
 194         } else if (stype == float.class) {
 195             float[] a = new float[limit];
 196             for (int i = 0; i < limit; i++) {
 197                 a[i] = (float) this.get(i);
 198             }
 199             return (Vector) FloatVector.fromArray((FloatVector.FloatSpecies) s, a, 0);
 200         } else if (stype == double.class) {
 201             double[] a = new double[limit];
 202             for (int i = 0; i < limit; i++) {
 203                 a[i] = (double) this.get(i);
 204             }
 205             return (Vector) DoubleVector.fromArray((DoubleVector.DoubleSpecies) s, a, 0);
 206         } else {
 207             throw new UnsupportedOperationException("Bad lane type for casting.");
 208         }
 209     }
 210 
 211     @Override
 212     @ForceInline
 213     @SuppressWarnings("unchecked")
 214     public <F> Vector<F> reinterpret(Species<F> s) {
 215         Objects.requireNonNull(s);
 216 
 217         if(s.elementType().equals(byte.class)) {
 218             return (Vector<F>) reshape((Species<Byte>)s);
 219         }
 220         if(s.bitSize() == bitSize()) {
 221             return reinterpretType(s);
 222         }
 223 
 224         return defaultReinterpret(s);
 225     }
 226 
 227     @ForceInline
 228     private <F> Vector<F> reinterpretType(Species<F> s) {
 229         Objects.requireNonNull(s);
 230 
 231         Class<?> stype = s.elementType();
 232         if (stype == byte.class) {
 233             return VectorIntrinsics.reinterpret(
 234                 Byte128Vector.class,
 235                 byte.class, LENGTH,
 236                 Byte128Vector.class,
 237                 byte.class, Byte128Vector.LENGTH,
 238                 this, s,
 239                 (species, vector) -> vector.defaultReinterpret(species)
 240             );
 241         } else if (stype == short.class) {
 242             return VectorIntrinsics.reinterpret(
 243                 Byte128Vector.class,
 244                 byte.class, LENGTH,
 245                 Short128Vector.class,
 246                 short.class, Short128Vector.LENGTH,
 247                 this, s,
 248                 (species, vector) -> vector.defaultReinterpret(species)
 249             );
 250         } else if (stype == int.class) {
 251             return VectorIntrinsics.reinterpret(
 252                 Byte128Vector.class,
 253                 byte.class, LENGTH,
 254                 Int128Vector.class,
 255                 int.class, Int128Vector.LENGTH,
 256                 this, s,
 257                 (species, vector) -> vector.defaultReinterpret(species)
 258             );
 259         } else if (stype == long.class) {
 260             return VectorIntrinsics.reinterpret(
 261                 Byte128Vector.class,
 262                 byte.class, LENGTH,
 263                 Long128Vector.class,
 264                 long.class, Long128Vector.LENGTH,
 265                 this, s,
 266                 (species, vector) -> vector.defaultReinterpret(species)
 267             );
 268         } else if (stype == float.class) {
 269             return VectorIntrinsics.reinterpret(
 270                 Byte128Vector.class,
 271                 byte.class, LENGTH,
 272                 Float128Vector.class,
 273                 float.class, Float128Vector.LENGTH,
 274                 this, s,
 275                 (species, vector) -> vector.defaultReinterpret(species)
 276             );
 277         } else if (stype == double.class) {
 278             return VectorIntrinsics.reinterpret(
 279                 Byte128Vector.class,
 280                 byte.class, LENGTH,
 281                 Double128Vector.class,
 282                 double.class, Double128Vector.LENGTH,
 283                 this, s,
 284                 (species, vector) -> vector.defaultReinterpret(species)
 285             );
 286         } else {
 287             throw new UnsupportedOperationException("Bad lane type for casting.");
 288         }
 289     }
 290 
 291     @Override
 292     @ForceInline
 293     public ByteVector reshape(Species<Byte> s) {
 294         Objects.requireNonNull(s);
 295         if (s.bitSize() == 64 && (s instanceof Byte64Vector.Byte64Species)) {
 296             Byte64Vector.Byte64Species ts = (Byte64Vector.Byte64Species)s;
 297             return VectorIntrinsics.reinterpret(
 298                 Byte128Vector.class,
 299                 byte.class, LENGTH,
 300                 Byte64Vector.class,
 301                 byte.class, Byte64Vector.LENGTH,
 302                 this, ts,
 303                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
 304             );
 305         } else if (s.bitSize() == 128 && (s instanceof Byte128Vector.Byte128Species)) {
 306             Byte128Vector.Byte128Species ts = (Byte128Vector.Byte128Species)s;
 307             return VectorIntrinsics.reinterpret(
 308                 Byte128Vector.class,
 309                 byte.class, LENGTH,
 310                 Byte128Vector.class,
 311                 byte.class, Byte128Vector.LENGTH,
 312                 this, ts,
 313                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
 314             );
 315         } else if (s.bitSize() == 256 && (s instanceof Byte256Vector.Byte256Species)) {
 316             Byte256Vector.Byte256Species ts = (Byte256Vector.Byte256Species)s;
 317             return VectorIntrinsics.reinterpret(
 318                 Byte128Vector.class,
 319                 byte.class, LENGTH,
 320                 Byte256Vector.class,
 321                 byte.class, Byte256Vector.LENGTH,
 322                 this, ts,
 323                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
 324             );
 325         } else if (s.bitSize() == 512 && (s instanceof Byte512Vector.Byte512Species)) {
 326             Byte512Vector.Byte512Species ts = (Byte512Vector.Byte512Species)s;
 327             return VectorIntrinsics.reinterpret(
 328                 Byte128Vector.class,
 329                 byte.class, LENGTH,
 330                 Byte512Vector.class,
 331                 byte.class, Byte512Vector.LENGTH,
 332                 this, ts,
 333                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
 334             );
 335         } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
 336                 && (s.bitSize() % 128 == 0) && (s instanceof ByteMaxVector.ByteMaxSpecies)) {
 337             ByteMaxVector.ByteMaxSpecies ts = (ByteMaxVector.ByteMaxSpecies)s;
 338             return VectorIntrinsics.reinterpret(
 339                 Byte128Vector.class,
 340                 byte.class, LENGTH,
 341                 ByteMaxVector.class,
 342                 byte.class, ByteMaxVector.LENGTH,
 343                 this, ts,
 344                 (species, vector) -> (ByteVector) vector.defaultReinterpret(species)
 345             );
 346         } else {
 347             throw new InternalError("Unimplemented size");
 348         }
 349     }
 350 
 351     // Binary operations with scalars
 352 
 353     @Override
 354     @ForceInline
 355     public ByteVector add(byte o) {
 356         return add(SPECIES.broadcast(o));
 357     }
 358 
 359     @Override
 360     @ForceInline
 361     public ByteVector add(byte o, Mask<Byte> m) {
 362         return add(SPECIES.broadcast(o), m);
 363     }
 364 
 365     @Override
 366     @ForceInline
 367     public ByteVector sub(byte o) {
 368         return sub(SPECIES.broadcast(o));
 369     }
 370 
 371     @Override
 372     @ForceInline
 373     public ByteVector sub(byte o, Mask<Byte> m) {
 374         return sub(SPECIES.broadcast(o), m);
 375     }
 376 
 377     @Override
 378     @ForceInline
 379     public ByteVector mul(byte o) {
 380         return mul(SPECIES.broadcast(o));
 381     }
 382 
 383     @Override
 384     @ForceInline
 385     public ByteVector mul(byte o, Mask<Byte> m) {
 386         return mul(SPECIES.broadcast(o), m);
 387     }
 388 
 389     @Override
 390     @ForceInline
 391     public ByteVector min(byte o) {
 392         return min(SPECIES.broadcast(o));
 393     }
 394 
 395     @Override
 396     @ForceInline
 397     public ByteVector max(byte o) {
 398         return max(SPECIES.broadcast(o));
 399     }
 400 
 401     @Override
 402     @ForceInline
 403     public Mask<Byte> equal(byte o) {
 404         return equal(SPECIES.broadcast(o));
 405     }
 406 
 407     @Override
 408     @ForceInline
 409     public Mask<Byte> notEqual(byte o) {
 410         return notEqual(SPECIES.broadcast(o));
 411     }
 412 
 413     @Override
 414     @ForceInline
 415     public Mask<Byte> lessThan(byte o) {
 416         return lessThan(SPECIES.broadcast(o));
 417     }
 418 
 419     @Override
 420     @ForceInline
 421     public Mask<Byte> lessThanEq(byte o) {
 422         return lessThanEq(SPECIES.broadcast(o));
 423     }
 424 
 425     @Override
 426     @ForceInline
 427     public Mask<Byte> greaterThan(byte o) {
 428         return greaterThan(SPECIES.broadcast(o));
 429     }
 430 
 431     @Override
 432     @ForceInline
 433     public Mask<Byte> greaterThanEq(byte o) {
 434         return greaterThanEq(SPECIES.broadcast(o));
 435     }
 436 
 437     @Override
 438     @ForceInline
 439     public ByteVector blend(byte o, Mask<Byte> m) {
 440         return blend(SPECIES.broadcast(o), m);
 441     }
 442 
 443 
 444     @Override
 445     @ForceInline
 446     public ByteVector and(byte o) {
 447         return and(SPECIES.broadcast(o));
 448     }
 449 
 450     @Override
 451     @ForceInline
 452     public ByteVector and(byte o, Mask<Byte> m) {
 453         return and(SPECIES.broadcast(o), m);
 454     }
 455 
 456     @Override
 457     @ForceInline
 458     public ByteVector or(byte o) {
 459         return or(SPECIES.broadcast(o));
 460     }
 461 
 462     @Override
 463     @ForceInline
 464     public ByteVector or(byte o, Mask<Byte> m) {
 465         return or(SPECIES.broadcast(o), m);
 466     }
 467 
 468     @Override
 469     @ForceInline
 470     public ByteVector xor(byte o) {
 471         return xor(SPECIES.broadcast(o));
 472     }
 473 
 474     @Override
 475     @ForceInline
 476     public ByteVector xor(byte o, Mask<Byte> m) {
 477         return xor(SPECIES.broadcast(o), m);
 478     }
 479 
 480     @Override
 481     @ForceInline
 482     public Byte128Vector neg() {
 483         return (Byte128Vector)zero(SPECIES).sub(this);
 484     }
 485 
 486     // Unary operations
 487 
 488     @ForceInline
 489     @Override
 490     public Byte128Vector neg(Mask<Byte> m) {
 491         return blend(neg(), m);
 492     }
 493 
 494     @Override
 495     @ForceInline
 496     public Byte128Vector abs() {
 497         return VectorIntrinsics.unaryOp(
 498             VECTOR_OP_ABS, Byte128Vector.class, byte.class, LENGTH,
 499             this,
 500             v1 -> v1.uOp((i, a) -> (byte) Math.abs(a)));
 501     }
 502 
 503     @ForceInline
 504     @Override
 505     public Byte128Vector abs(Mask<Byte> m) {
 506         return blend(abs(), m);
 507     }
 508 
 509 
 510     @Override
 511     @ForceInline
 512     public Byte128Vector not() {
 513         return VectorIntrinsics.unaryOp(
 514             VECTOR_OP_NOT, Byte128Vector.class, byte.class, LENGTH,
 515             this,
 516             v1 -> v1.uOp((i, a) -> (byte) ~a));
 517     }
 518 
 519     @ForceInline
 520     @Override
 521     public Byte128Vector not(Mask<Byte> m) {
 522         return blend(not(), m);
 523     }
 524     // Binary operations
 525 
 526     @Override
 527     @ForceInline
 528     public Byte128Vector add(Vector<Byte> o) {
 529         Objects.requireNonNull(o);
 530         Byte128Vector v = (Byte128Vector)o;
 531         return VectorIntrinsics.binaryOp(
 532             VECTOR_OP_ADD, Byte128Vector.class, byte.class, LENGTH,
 533             this, v,
 534             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a + b)));
 535     }
 536 
 537     @Override
 538     @ForceInline
 539     public Byte128Vector add(Vector<Byte> v, Mask<Byte> m) {
 540         return blend(add(v), m);
 541     }
 542 
 543     @Override
 544     @ForceInline
 545     public Byte128Vector sub(Vector<Byte> o) {
 546         Objects.requireNonNull(o);
 547         Byte128Vector v = (Byte128Vector)o;
 548         return VectorIntrinsics.binaryOp(
 549             VECTOR_OP_SUB, Byte128Vector.class, byte.class, LENGTH,
 550             this, v,
 551             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a - b)));
 552     }
 553 
 554     @Override
 555     @ForceInline
 556     public Byte128Vector sub(Vector<Byte> v, Mask<Byte> m) {
 557         return blend(sub(v), m);
 558     }
 559 
 560     @Override
 561     @ForceInline
 562     public Byte128Vector mul(Vector<Byte> o) {
 563         Objects.requireNonNull(o);
 564         Byte128Vector v = (Byte128Vector)o;
 565         return VectorIntrinsics.binaryOp(
 566             VECTOR_OP_MUL, Byte128Vector.class, byte.class, LENGTH,
 567             this, v,
 568             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a * b)));
 569     }
 570 
 571     @Override
 572     @ForceInline
 573     public Byte128Vector mul(Vector<Byte> v, Mask<Byte> m) {
 574         return blend(mul(v), m);
 575     }
 576 
 577     @Override
 578     @ForceInline
 579     public Byte128Vector min(Vector<Byte> o) {
 580         Objects.requireNonNull(o);
 581         Byte128Vector v = (Byte128Vector)o;
 582         return (Byte128Vector) VectorIntrinsics.binaryOp(
 583             VECTOR_OP_MIN, Byte128Vector.class, byte.class, LENGTH,
 584             this, v,
 585             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte) Math.min(a, b)));
 586     }
 587 
 588     @Override
 589     @ForceInline
 590     public Byte128Vector min(Vector<Byte> v, Mask<Byte> m) {
 591         return blend(min(v), m);
 592     }
 593 
 594     @Override
 595     @ForceInline
 596     public Byte128Vector max(Vector<Byte> o) {
 597         Objects.requireNonNull(o);
 598         Byte128Vector v = (Byte128Vector)o;
 599         return VectorIntrinsics.binaryOp(
 600             VECTOR_OP_MAX, Byte128Vector.class, byte.class, LENGTH,
 601             this, v,
 602             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte) Math.max(a, b)));
 603         }
 604 
 605     @Override
 606     @ForceInline
 607     public Byte128Vector max(Vector<Byte> v, Mask<Byte> m) {
 608         return blend(max(v), m);
 609     }
 610 
 611     @Override
 612     @ForceInline
 613     public Byte128Vector and(Vector<Byte> o) {
 614         Objects.requireNonNull(o);
 615         Byte128Vector v = (Byte128Vector)o;
 616         return VectorIntrinsics.binaryOp(
 617             VECTOR_OP_AND, Byte128Vector.class, byte.class, LENGTH,
 618             this, v,
 619             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a & b)));
 620     }
 621 
 622     @Override
 623     @ForceInline
 624     public Byte128Vector or(Vector<Byte> o) {
 625         Objects.requireNonNull(o);
 626         Byte128Vector v = (Byte128Vector)o;
 627         return VectorIntrinsics.binaryOp(
 628             VECTOR_OP_OR, Byte128Vector.class, byte.class, LENGTH,
 629             this, v,
 630             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a | b)));
 631     }
 632 
 633     @Override
 634     @ForceInline
 635     public Byte128Vector xor(Vector<Byte> o) {
 636         Objects.requireNonNull(o);
 637         Byte128Vector v = (Byte128Vector)o;
 638         return VectorIntrinsics.binaryOp(
 639             VECTOR_OP_XOR, Byte128Vector.class, byte.class, LENGTH,
 640             this, v,
 641             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (byte)(a ^ b)));
 642     }
 643 
 644     @Override
 645     @ForceInline
 646     public Byte128Vector and(Vector<Byte> v, Mask<Byte> m) {
 647         return blend(and(v), m);
 648     }
 649 
 650     @Override
 651     @ForceInline
 652     public Byte128Vector or(Vector<Byte> v, Mask<Byte> m) {
 653         return blend(or(v), m);
 654     }
 655 
 656     @Override
 657     @ForceInline
 658     public Byte128Vector xor(Vector<Byte> v, Mask<Byte> m) {
 659         return blend(xor(v), m);
 660     }
 661 
 662     @Override
 663     @ForceInline
 664     public Byte128Vector shiftL(int s) {
 665         return VectorIntrinsics.broadcastInt(
 666             VECTOR_OP_LSHIFT, Byte128Vector.class, byte.class, LENGTH,
 667             this, s,
 668             (v, i) -> v.uOp((__, a) -> (byte) (a << (i & 7))));
 669     }
 670 
 671     @Override
 672     @ForceInline
 673     public Byte128Vector shiftL(int s, Mask<Byte> m) {
 674         return blend(shiftL(s), m);
 675     }
 676 
 677     @Override
 678     @ForceInline
 679     public Byte128Vector shiftR(int s) {
 680         return VectorIntrinsics.broadcastInt(
 681             VECTOR_OP_URSHIFT, Byte128Vector.class, byte.class, LENGTH,
 682             this, s,
 683             (v, i) -> v.uOp((__, a) -> (byte) ((a & 0xFF) >>> (i & 7))));
 684     }
 685 
 686     @Override
 687     @ForceInline
 688     public Byte128Vector shiftR(int s, Mask<Byte> m) {
 689         return blend(shiftR(s), m);
 690     }
 691 
 692     @Override
 693     @ForceInline
 694     public Byte128Vector aShiftR(int s) {
 695         return VectorIntrinsics.broadcastInt(
 696             VECTOR_OP_RSHIFT, Byte128Vector.class, byte.class, LENGTH,
 697             this, s,
 698             (v, i) -> v.uOp((__, a) -> (byte) (a >> (i & 7))));
 699     }
 700 
 701     @Override
 702     @ForceInline
 703     public Byte128Vector aShiftR(int s, Mask<Byte> m) {
 704         return blend(aShiftR(s), m);
 705     }
 706     // Ternary operations
 707 
 708 
 709     // Type specific horizontal reductions
 710 
 711     @Override
 712     @ForceInline
 713     public byte addAll() {
 714         return (byte) VectorIntrinsics.reductionCoerced(
 715             VECTOR_OP_ADD, Byte128Vector.class, byte.class, LENGTH,
 716             this,
 717             v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a + b)));
 718     }
 719 
 720     @Override
 721     @ForceInline
 722     public byte andAll() {
 723         return (byte) VectorIntrinsics.reductionCoerced(
 724             VECTOR_OP_AND, Byte128Vector.class, byte.class, LENGTH,
 725             this,
 726             v -> (long) v.rOp((byte) -1, (i, a, b) -> (byte) (a & b)));
 727     }
 728 
 729     @Override
 730     @ForceInline
 731     public byte andAll(Mask<Byte> m) {
 732         return blend(SPECIES.broadcast((byte) -1), m).andAll();
 733     }
 734 
 735     @Override
 736     @ForceInline
 737     public byte minAll() {
 738         return (byte) VectorIntrinsics.reductionCoerced(
 739             VECTOR_OP_MIN, Byte128Vector.class, byte.class, LENGTH,
 740             this,
 741             v -> (long) v.rOp(Byte.MAX_VALUE , (i, a, b) -> (byte) Math.min(a, b)));
 742     }
 743 
 744     @Override
 745     @ForceInline
 746     public byte maxAll() {
 747         return (byte) VectorIntrinsics.reductionCoerced(
 748             VECTOR_OP_MAX, Byte128Vector.class, byte.class, LENGTH,
 749             this,
 750             v -> (long) v.rOp(Byte.MIN_VALUE , (i, a, b) -> (byte) Math.max(a, b)));
 751     }
 752 
 753     @Override
 754     @ForceInline
 755     public byte mulAll() {
 756         return (byte) VectorIntrinsics.reductionCoerced(
 757             VECTOR_OP_MUL, Byte128Vector.class, byte.class, LENGTH,
 758             this,
 759             v -> (long) v.rOp((byte) 1, (i, a, b) -> (byte) (a * b)));
 760     }
 761 
 762     @Override
 763     @ForceInline
 764     public byte subAll() {
 765         return (byte) VectorIntrinsics.reductionCoerced(
 766             VECTOR_OP_SUB, Byte128Vector.class, byte.class, LENGTH,
 767             this,
 768             v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a - b)));
 769     }
 770 
 771     @Override
 772     @ForceInline
 773     public byte orAll() {
 774         return (byte) VectorIntrinsics.reductionCoerced(
 775             VECTOR_OP_OR, Byte128Vector.class, byte.class, LENGTH,
 776             this,
 777             v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a | b)));
 778     }
 779 
 780     @Override
 781     @ForceInline
 782     public byte orAll(Mask<Byte> m) {
 783         return blend(SPECIES.broadcast((byte) 0), m).orAll();
 784     }
 785 
 786     @Override
 787     @ForceInline
 788     public byte xorAll() {
 789         return (byte) VectorIntrinsics.reductionCoerced(
 790             VECTOR_OP_XOR, Byte128Vector.class, byte.class, LENGTH,
 791             this,
 792             v -> (long) v.rOp((byte) 0, (i, a, b) -> (byte) (a ^ b)));
 793     }
 794 
 795     @Override
 796     @ForceInline
 797     public byte xorAll(Mask<Byte> m) {
 798         return blend(SPECIES.broadcast((byte) 0), m).xorAll();
 799     }
 800 
 801 
 802     @Override
 803     @ForceInline
 804     public byte addAll(Mask<Byte> m) {
 805         return blend(SPECIES.broadcast((byte) 0), m).addAll();
 806     }
 807 
 808     @Override
 809     @ForceInline
 810     public byte subAll(Mask<Byte> m) {
 811         return blend(SPECIES.broadcast((byte) 0), m).subAll();
 812     }
 813 
 814     @Override
 815     @ForceInline
 816     public byte mulAll(Mask<Byte> m) {
 817         return blend(SPECIES.broadcast((byte) 1), m).mulAll();
 818     }
 819 
 820     @Override
 821     @ForceInline
 822     public byte minAll(Mask<Byte> m) {
 823         return blend(SPECIES.broadcast(Byte.MAX_VALUE), m).minAll();
 824     }
 825 
 826     @Override
 827     @ForceInline
 828     public byte maxAll(Mask<Byte> m) {
 829         return blend(SPECIES.broadcast(Byte.MIN_VALUE), m).maxAll();
 830     }
 831 
 832     @Override
 833     @ForceInline
 834     public Shuffle<Byte> toShuffle() {
 835         byte[] a = toArray();
 836         int[] sa = new int[a.length];
 837         for (int i = 0; i < a.length; i++) {
 838             sa[i] = (int) a[i];
 839         }
 840         return ByteVector.shuffleFromArray(SPECIES, sa, 0);
 841     }
 842 
 843     // Memory operations
 844 
 845     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BYTE_INDEX_SCALE);
 846     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 847 
 848     @Override
 849     @ForceInline
 850     public void intoArray(byte[] a, int ix) {
 851         Objects.requireNonNull(a);
 852         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 853         VectorIntrinsics.store(Byte128Vector.class, byte.class, LENGTH,
 854                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 855                                this,
 856                                a, ix,
 857                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 858     }
 859 
 860     @Override
 861     @ForceInline
 862     public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
 863         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
 864         ByteVector newVal = oldVal.blend(this, m);
 865         newVal.intoArray(a, ax);
 866     }
 867 
 868     @Override
 869     @ForceInline
 870     public void intoByteArray(byte[] a, int ix) {
 871         Objects.requireNonNull(a);
 872         ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
 873         VectorIntrinsics.store(Byte128Vector.class, byte.class, LENGTH,
 874                                a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 875                                this,
 876                                a, ix,
 877                                (c, idx, v) -> {
 878                                    ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 879                                    ByteBuffer tb = bbc;
 880                                    v.forEach((i, e) -> tb.put(e));
 881                                });
 882     }
 883 
 884     @Override
 885     @ForceInline
 886     public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
 887         Byte128Vector oldVal = (Byte128Vector) ByteVector.fromByteArray(SPECIES, a, ix);
 888         Byte128Vector newVal = oldVal.blend(this, m);
 889         newVal.intoByteArray(a, ix);
 890     }
 891 
 892     @Override
 893     @ForceInline
 894     public void intoByteBuffer(ByteBuffer bb, int ix) {
 895         if (bb.order() != ByteOrder.nativeOrder()) {
 896             throw new IllegalArgumentException();
 897         }
 898         if (bb.isReadOnly()) {
 899             throw new ReadOnlyBufferException();
 900         }
 901         ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE);
 902         VectorIntrinsics.store(Byte128Vector.class, byte.class, LENGTH,
 903                                U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS),
 904                                this,
 905                                bb, ix,
 906                                (c, idx, v) -> {
 907                                    ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
 908                                    ByteBuffer tb = bbc;
 909                                    v.forEach((i, e) -> tb.put(e));
 910                                });
 911     }
 912 
 913     @Override
 914     @ForceInline
 915     public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
 916         Byte128Vector oldVal = (Byte128Vector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
 917         Byte128Vector newVal = oldVal.blend(this, m);
 918         newVal.intoByteBuffer(bb, ix);
 919     }
 920 
 921     //
 922 
 923     @Override
 924     public String toString() {
 925         return Arrays.toString(getElements());
 926     }
 927 
 928     @Override
 929     public boolean equals(Object o) {
 930         if (this == o) return true;
 931         if (o == null || this.getClass() != o.getClass()) return false;
 932 
 933         Byte128Vector that = (Byte128Vector) o;
 934         return this.equal(that).allTrue();
 935     }
 936 
 937     @Override
 938     public int hashCode() {
 939         return Arrays.hashCode(vec);
 940     }
 941 
 942     // Binary test
 943 
 944     @Override
 945     Byte128Mask bTest(Vector<Byte> o, FBinTest f) {
 946         byte[] vec1 = getElements();
 947         byte[] vec2 = ((Byte128Vector)o).getElements();
 948         boolean[] bits = new boolean[length()];
 949         for (int i = 0; i < length(); i++){
 950             bits[i] = f.apply(i, vec1[i], vec2[i]);
 951         }
 952         return new Byte128Mask(bits);
 953     }
 954 
 955     // Comparisons
 956 
 957     @Override
 958     @ForceInline
 959     public Byte128Mask equal(Vector<Byte> o) {
 960         Objects.requireNonNull(o);
 961         Byte128Vector v = (Byte128Vector)o;
 962 
 963         return VectorIntrinsics.compare(
 964             BT_eq, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
 965             this, v,
 966             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b));
 967     }
 968 
 969     @Override
 970     @ForceInline
 971     public Byte128Mask notEqual(Vector<Byte> o) {
 972         Objects.requireNonNull(o);
 973         Byte128Vector v = (Byte128Vector)o;
 974 
 975         return VectorIntrinsics.compare(
 976             BT_ne, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
 977             this, v,
 978             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b));
 979     }
 980 
 981     @Override
 982     @ForceInline
 983     public Byte128Mask lessThan(Vector<Byte> o) {
 984         Objects.requireNonNull(o);
 985         Byte128Vector v = (Byte128Vector)o;
 986 
 987         return VectorIntrinsics.compare(
 988             BT_lt, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
 989             this, v,
 990             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b));
 991     }
 992 
 993     @Override
 994     @ForceInline
 995     public Byte128Mask lessThanEq(Vector<Byte> o) {
 996         Objects.requireNonNull(o);
 997         Byte128Vector v = (Byte128Vector)o;
 998 
 999         return VectorIntrinsics.compare(
1000             BT_le, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
1001             this, v,
1002             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b));
1003     }
1004 
1005     @Override
1006     @ForceInline
1007     public Byte128Mask greaterThan(Vector<Byte> o) {
1008         Objects.requireNonNull(o);
1009         Byte128Vector v = (Byte128Vector)o;
1010 
1011         return (Byte128Mask) VectorIntrinsics.compare(
1012             BT_gt, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
1013             this, v,
1014             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b));
1015     }
1016 
1017     @Override
1018     @ForceInline
1019     public Byte128Mask greaterThanEq(Vector<Byte> o) {
1020         Objects.requireNonNull(o);
1021         Byte128Vector v = (Byte128Vector)o;
1022 
1023         return VectorIntrinsics.compare(
1024             BT_ge, Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
1025             this, v,
1026             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
1027     }
1028 
1029     // Foreach
1030 
1031     @Override
1032     void forEach(FUnCon f) {
1033         byte[] vec = getElements();
1034         for (int i = 0; i < length(); i++) {
1035             f.apply(i, vec[i]);
1036         }
1037     }
1038 
1039     @Override
1040     void forEach(Mask<Byte> o, FUnCon f) {
1041         boolean[] mbits = ((Byte128Mask)o).getBits();
1042         forEach((i, a) -> {
1043             if (mbits[i]) { f.apply(i, a); }
1044         });
1045     }
1046 
1047 
1048 
1049     @Override
1050     public Byte128Vector rotateEL(int j) {
1051         byte[] vec = getElements();
1052         byte[] res = new byte[length()];
1053         for (int i = 0; i < length(); i++){
1054             res[(j + i) % length()] = vec[i];
1055         }
1056         return new Byte128Vector(res);
1057     }
1058 
1059     @Override
1060     public Byte128Vector rotateER(int j) {
1061         byte[] vec = getElements();
1062         byte[] res = new byte[length()];
1063         for (int i = 0; i < length(); i++){
1064             int z = i - j;
1065             if(j < 0) {
1066                 res[length() + z] = vec[i];
1067             } else {
1068                 res[z] = vec[i];
1069             }
1070         }
1071         return new Byte128Vector(res);
1072     }
1073 
1074     @Override
1075     public Byte128Vector shiftEL(int j) {
1076         byte[] vec = getElements();
1077         byte[] res = new byte[length()];
1078         for (int i = 0; i < length() - j; i++) {
1079             res[i] = vec[i + j];
1080         }
1081         return new Byte128Vector(res);
1082     }
1083 
1084     @Override
1085     public Byte128Vector shiftER(int j) {
1086         byte[] vec = getElements();
1087         byte[] res = new byte[length()];
1088         for (int i = 0; i < length() - j; i++){
1089             res[i + j] = vec[i];
1090         }
1091         return new Byte128Vector(res);
1092     }
1093 
1094     @Override
1095     @ForceInline
1096     public Byte128Vector rearrange(Vector<Byte> v,
1097                                   Shuffle<Byte> s, Mask<Byte> m) {
1098         return this.rearrange(s).blend(v.rearrange(s), m);
1099     }
1100 
1101     @Override
1102     @ForceInline
1103     public Byte128Vector rearrange(Shuffle<Byte> o1) {
1104         Objects.requireNonNull(o1);
1105         Byte128Shuffle s =  (Byte128Shuffle)o1;
1106 
1107         return VectorIntrinsics.rearrangeOp(
1108             Byte128Vector.class, Byte128Shuffle.class, byte.class, LENGTH,
1109             this, s,
1110             (v1, s_) -> v1.uOp((i, a) -> {
1111                 int ei = s_.getElement(i);
1112                 return v1.get(ei);
1113             }));
1114     }
1115 
1116     @Override
1117     @ForceInline
1118     public Byte128Vector blend(Vector<Byte> o1, Mask<Byte> o2) {
1119         Objects.requireNonNull(o1);
1120         Objects.requireNonNull(o2);
1121         Byte128Vector v = (Byte128Vector)o1;
1122         Byte128Mask   m = (Byte128Mask)o2;
1123 
1124         return VectorIntrinsics.blend(
1125             Byte128Vector.class, Byte128Mask.class, byte.class, LENGTH,
1126             this, v, m,
1127             (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1128     }
1129 
1130     // Accessors
1131 
1132     @Override
1133     public byte get(int i) {
1134         if (i < 0 || i >= LENGTH) {
1135             throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1136         }
1137         return (byte) VectorIntrinsics.extract(
1138                                 Byte128Vector.class, byte.class, LENGTH,
1139                                 this, i,
1140                                 (vec, ix) -> {
1141                                     byte[] vecarr = vec.getElements();
1142                                     return (long)vecarr[ix];
1143                                 });
1144     }
1145 
1146     @Override
1147     public Byte128Vector with(int i, byte e) {
1148         if (i < 0 || i >= LENGTH) {
1149             throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1150         }
1151         return VectorIntrinsics.insert(
1152                                 Byte128Vector.class, byte.class, LENGTH,
1153                                 this, i, (long)e,
1154                                 (v, ix, bits) -> {
1155                                     byte[] res = v.getElements().clone();
1156                                     res[ix] = (byte)bits;
1157                                     return new Byte128Vector(res);
1158                                 });
1159     }
1160 
1161     // Mask
1162 
1163     static final class Byte128Mask extends AbstractMask<Byte> {
1164         static final Byte128Mask TRUE_MASK = new Byte128Mask(true);
1165         static final Byte128Mask FALSE_MASK = new Byte128Mask(false);
1166 
1167         private final boolean[] bits; // Don't access directly, use getBits() instead.
1168 
1169         public Byte128Mask(boolean[] bits) {
1170             this(bits, 0);
1171         }
1172 
1173         public Byte128Mask(boolean[] bits, int offset) {
1174             boolean[] a = new boolean[species().length()];
1175             for (int i = 0; i < a.length; i++) {
1176                 a[i] = bits[offset + i];
1177             }
1178             this.bits = a;
1179         }
1180 
1181         public Byte128Mask(boolean val) {
1182             boolean[] bits = new boolean[species().length()];
1183             Arrays.fill(bits, val);
1184             this.bits = bits;
1185         }
1186 
1187         boolean[] getBits() {
1188             return VectorIntrinsics.maybeRebox(this).bits;
1189         }
1190 
1191         @Override
1192         Byte128Mask uOp(MUnOp f) {
1193             boolean[] res = new boolean[species().length()];
1194             boolean[] bits = getBits();
1195             for (int i = 0; i < species().length(); i++) {
1196                 res[i] = f.apply(i, bits[i]);
1197             }
1198             return new Byte128Mask(res);
1199         }
1200 
1201         @Override
1202         Byte128Mask bOp(Mask<Byte> o, MBinOp f) {
1203             boolean[] res = new boolean[species().length()];
1204             boolean[] bits = getBits();
1205             boolean[] mbits = ((Byte128Mask)o).getBits();
1206             for (int i = 0; i < species().length(); i++) {
1207                 res[i] = f.apply(i, bits[i], mbits[i]);
1208             }
1209             return new Byte128Mask(res);
1210         }
1211 
1212         @Override
1213         public Byte128Species species() {
1214             return SPECIES;
1215         }
1216 
1217         @Override
1218         public Byte128Vector toVector() {
1219             byte[] res = new byte[species().length()];
1220             boolean[] bits = getBits();
1221             for (int i = 0; i < species().length(); i++) {
1222                 // -1 will result in the most significant bit being set in
1223                 // addition to some or all other bits
1224                 res[i] = (byte) (bits[i] ? -1 : 0);
1225             }
1226             return new Byte128Vector(res);
1227         }
1228 
1229         // Unary operations
1230 
1231         @Override
1232         @ForceInline
1233         public Byte128Mask not() {
1234             return (Byte128Mask) VectorIntrinsics.unaryOp(
1235                                              VECTOR_OP_NOT, Byte128Mask.class, byte.class, LENGTH,
1236                                              this,
1237                                              (m1) -> m1.uOp((i, a) -> !a));
1238         }
1239 
1240         // Binary operations
1241 
1242         @Override
1243         @ForceInline
1244         public Byte128Mask and(Mask<Byte> o) {
1245             Objects.requireNonNull(o);
1246             Byte128Mask m = (Byte128Mask)o;
1247             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Byte128Mask.class, byte.class, LENGTH,
1248                                              this, m,
1249                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
1250         }
1251 
1252         @Override
1253         @ForceInline
1254         public Byte128Mask or(Mask<Byte> o) {
1255             Objects.requireNonNull(o);
1256             Byte128Mask m = (Byte128Mask)o;
1257             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte128Mask.class, byte.class, LENGTH,
1258                                              this, m,
1259                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1260         }
1261 
1262         // Reductions
1263 
1264         @Override
1265         @ForceInline
1266         public boolean anyTrue() {
1267             return VectorIntrinsics.test(BT_ne, Byte128Mask.class, byte.class, LENGTH,
1268                                          this, this,
1269                                          (m, __) -> anyTrueHelper(((Byte128Mask)m).getBits()));
1270         }
1271 
1272         @Override
1273         @ForceInline
1274         public boolean allTrue() {
1275             return VectorIntrinsics.test(BT_overflow, Byte128Mask.class, byte.class, LENGTH,
1276                                          this, ByteVector.maskAllTrue(species()),
1277                                          (m, __) -> allTrueHelper(((Byte128Mask)m).getBits()));
1278         }
1279     }
1280 
1281     // Shuffle
1282 
1283     static final class Byte128Shuffle extends AbstractShuffle<Byte> {
1284         Byte128Shuffle(byte[] reorder) {
1285             super(reorder);
1286         }
1287 
1288         public Byte128Shuffle(int[] reorder) {
1289             super(reorder);
1290         }
1291 
1292         public Byte128Shuffle(int[] reorder, int i) {
1293             super(reorder, i);
1294         }
1295 
1296         public Byte128Shuffle(IntUnaryOperator f) {
1297             super(f);
1298         }
1299 
1300         @Override
1301         public Byte128Species species() {
1302             return SPECIES;
1303         }
1304 
1305         @Override
1306         public ByteVector toVector() {
1307             byte[] va = new byte[SPECIES.length()];
1308             for (int i = 0; i < va.length; i++) {
1309               va[i] = (byte) getElement(i);
1310             }
1311             return ByteVector.fromArray(SPECIES, va, 0);
1312         }
1313 
1314         @Override
1315         public Byte128Shuffle rearrange(Vector.Shuffle<Byte> o) {
1316             Byte128Shuffle s = (Byte128Shuffle) o;
1317             byte[] r = new byte[reorder.length];
1318             for (int i = 0; i < reorder.length; i++) {
1319                 r[i] = reorder[s.reorder[i]];
1320             }
1321             return new Byte128Shuffle(r);
1322         }
1323     }
1324 
1325     // Species
1326 
1327     @Override
1328     public Byte128Species species() {
1329         return SPECIES;
1330     }
1331 
1332     static final class Byte128Species extends ByteSpecies {
1333         static final int BIT_SIZE = Shape.S_128_BIT.bitSize();
1334 
1335         static final int LENGTH = BIT_SIZE / Byte.SIZE;
1336 
1337         @Override
1338         public String toString() {
1339            StringBuilder sb = new StringBuilder("Shape[");
1340            sb.append(bitSize()).append(" bits, ");
1341            sb.append(length()).append(" ").append(byte.class.getSimpleName()).append("s x ");
1342            sb.append(elementSize()).append(" bits");
1343            sb.append("]");
1344            return sb.toString();
1345         }
1346 
1347         @Override
1348         @ForceInline
1349         public int bitSize() {
1350             return BIT_SIZE;
1351         }
1352 
1353         @Override
1354         @ForceInline
1355         public int length() {
1356             return LENGTH;
1357         }
1358 
1359         @Override
1360         @ForceInline
1361         public Class<Byte> elementType() {
1362             return byte.class;
1363         }
1364 
1365         @Override
1366         @ForceInline
1367         public Class<?> boxType() {
1368             return Byte128Vector.class;
1369         }
1370 
1371         @Override
1372         @ForceInline
1373         public Class<?> maskType() {
1374             return Byte128Mask.class;
1375         }
1376 
1377         @Override
1378         @ForceInline
1379         public int elementSize() {
1380             return Byte.SIZE;
1381         }
1382 
1383         @Override
1384         @ForceInline
1385         @SuppressWarnings("unchecked")
1386         Class<?> vectorType() {
1387             return Byte128Vector.class;
1388         }
1389 
1390         @Override
1391         @ForceInline
1392         public Shape shape() {
1393             return Shape.S_128_BIT;
1394         }
1395 
1396         @Override
1397         Byte128Vector op(FOp f) {
1398             byte[] res = new byte[length()];
1399             for (int i = 0; i < length(); i++) {
1400                 res[i] = f.apply(i);
1401             }
1402             return new Byte128Vector(res);
1403         }
1404 
1405         @Override
1406         Byte128Vector op(Mask<Byte> o, FOp f) {
1407             byte[] res = new byte[length()];
1408             boolean[] mbits = ((Byte128Mask)o).getBits();
1409             for (int i = 0; i < length(); i++) {
1410                 if (mbits[i]) {
1411                     res[i] = f.apply(i);
1412                 }
1413             }
1414             return new Byte128Vector(res);
1415         }
1416 
1417         @Override
1418         Byte128Mask opm(FOpm f) {
1419             boolean[] res = new boolean[length()];
1420             for (int i = 0; i < length(); i++) {
1421                 res[i] = (boolean)f.apply(i);
1422             }
1423             return new Byte128Mask(res);
1424         }
1425 
1426         // Factories
1427 
1428         @Override
1429         @ForceInline
1430         public Byte128Vector zero() {
1431             return VectorIntrinsics.broadcastCoerced(Byte128Vector.class, byte.class, LENGTH,
1432                                                      0, SPECIES,
1433                                                      ((bits, s) -> ((Byte128Species)s).op(i -> (byte)bits)));
1434         }
1435 
1436         @Override
1437         @ForceInline
1438         public Byte128Vector broadcast(byte e) {
1439             return VectorIntrinsics.broadcastCoerced(
1440                 Byte128Vector.class, byte.class, LENGTH,
1441                 e, SPECIES,
1442                 ((bits, s) -> ((Byte128Species)s).op(i -> (byte)bits)));
1443         }
1444 
1445         @Override
1446         @ForceInline
1447         public Byte128Vector scalars(byte... es) {
1448             Objects.requireNonNull(es);
1449             int ix = VectorIntrinsics.checkIndex(0, es.length, LENGTH);
1450             return VectorIntrinsics.load(Byte128Vector.class, byte.class, LENGTH,
1451                                          es, Unsafe.ARRAY_BYTE_BASE_OFFSET,
1452                                          es, ix, SPECIES,
1453                                          (c, idx, s) -> ((Byte128Species)s).op(n -> c[idx + n]));
1454         }
1455 
1456         @Override
1457         @ForceInline
1458         public <E> Byte128Mask cast(Mask<E> m) {
1459             if (m.length() != LENGTH)
1460                 throw new IllegalArgumentException("Mask length this species length differ");
1461             return new Byte128Mask(m.toArray());
1462         }
1463 
1464         @Override
1465         @ForceInline
1466         public <E> Byte128Shuffle cast(Shuffle<E> s) {
1467             if (s.length() != LENGTH)
1468                 throw new IllegalArgumentException("Shuffle length this species length differ");
1469             return new Byte128Shuffle(s.toArray());
1470         }
1471     }
1472 }