1 /*
   2  * Copyright (c) 2017, 2022, 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 any
  23  * questions.
  24  */
  25 package jdk.incubator.vector;
  26 
  27 import java.util.Arrays;
  28 import java.util.Objects;
  29 import java.util.function.IntUnaryOperator;
  30 
  31 import jdk.incubator.foreign.MemorySegment;
  32 import jdk.internal.vm.annotation.ForceInline;
  33 import jdk.internal.vm.vector.VectorSupport;
  34 
  35 import static jdk.internal.vm.vector.VectorSupport.*;
  36 
  37 import static jdk.incubator.vector.VectorOperators.*;
  38 
  39 // -- This file was mechanically generated: Do not edit! -- //
  40 
  41 @SuppressWarnings("cast")  // warning: redundant cast
  42 final class Byte512Vector extends ByteVector {
  43     static final ByteSpecies VSPECIES =
  44         (ByteSpecies) ByteVector.SPECIES_512;
  45 
  46     static final VectorShape VSHAPE =
  47         VSPECIES.vectorShape();
  48 
  49     static final Class<Byte512Vector> VCLASS = Byte512Vector.class;
  50 
  51     static final int VSIZE = VSPECIES.vectorBitSize();
  52 
  53     static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM
  54 
  55     static final Class<Byte> ETYPE = byte.class; // used by the JVM
  56 
  57     Byte512Vector(byte[] v) {
  58         super(v);
  59     }
  60 
  61     // For compatibility as Byte512Vector::new,
  62     // stored into species.vectorFactory.
  63     Byte512Vector(Object v) {
  64         this((byte[]) v);
  65     }
  66 
  67     static final Byte512Vector ZERO = new Byte512Vector(new byte[VLENGTH]);
  68     static final Byte512Vector IOTA = new Byte512Vector(VSPECIES.iotaArray());
  69 
  70     static {
  71         // Warm up a few species caches.
  72         // If we do this too much we will
  73         // get NPEs from bootstrap circularity.
  74         VSPECIES.dummyVector();
  75         VSPECIES.withLanes(LaneType.BYTE);
  76     }
  77 
  78     // Specialized extractors
  79 
  80     @ForceInline
  81     final @Override
  82     public ByteSpecies vspecies() {
  83         // ISSUE:  This should probably be a @Stable
  84         // field inside AbstractVector, rather than
  85         // a megamorphic method.
  86         return VSPECIES;
  87     }
  88 
  89     @ForceInline
  90     @Override
  91     public final Class<Byte> elementType() { return byte.class; }
  92 
  93     @ForceInline
  94     @Override
  95     public final int elementSize() { return Byte.SIZE; }
  96 
  97     @ForceInline
  98     @Override
  99     public final VectorShape shape() { return VSHAPE; }
 100 
 101     @ForceInline
 102     @Override
 103     public final int length() { return VLENGTH; }
 104 
 105     @ForceInline
 106     @Override
 107     public final int bitSize() { return VSIZE; }
 108 
 109     @ForceInline
 110     @Override
 111     public final int byteSize() { return VSIZE / Byte.SIZE; }
 112 
 113     /*package-private*/
 114     @ForceInline
 115     final @Override
 116     byte[] vec() {
 117         return (byte[])getPayload();
 118     }
 119 
 120     // Virtualized constructors
 121 
 122     @Override
 123     @ForceInline
 124     public final Byte512Vector broadcast(byte e) {
 125         return (Byte512Vector) super.broadcastTemplate(e);  // specialize
 126     }
 127 
 128     @Override
 129     @ForceInline
 130     public final Byte512Vector broadcast(long e) {
 131         return (Byte512Vector) super.broadcastTemplate(e);  // specialize
 132     }
 133 
 134     @Override
 135     @ForceInline
 136     Byte512Mask maskFromArray(boolean[] bits) {
 137         return new Byte512Mask(bits);
 138     }
 139 
 140     @Override
 141     @ForceInline
 142     Byte512Shuffle iotaShuffle() { return Byte512Shuffle.IOTA; }
 143 
 144     @ForceInline
 145     Byte512Shuffle iotaShuffle(int start, int step, boolean wrap) {
 146       if (wrap) {
 147         return (Byte512Shuffle)VectorSupport.shuffleIota(ETYPE, Byte512Shuffle.class, VSPECIES, VLENGTH, start, step, 1,
 148                 (l, lstart, lstep, s) -> s.shuffleFromOp(i -> (VectorIntrinsics.wrapToRange(i*lstep + lstart, l))));
 149       } else {
 150         return (Byte512Shuffle)VectorSupport.shuffleIota(ETYPE, Byte512Shuffle.class, VSPECIES, VLENGTH, start, step, 0,
 151                 (l, lstart, lstep, s) -> s.shuffleFromOp(i -> (i*lstep + lstart)));
 152       }
 153     }
 154 
 155     @Override
 156     @ForceInline
 157     Byte512Shuffle shuffleFromBytes(byte[] reorder) { return new Byte512Shuffle(reorder); }
 158 
 159     @Override
 160     @ForceInline
 161     Byte512Shuffle shuffleFromArray(int[] indexes, int i) { return new Byte512Shuffle(indexes, i); }
 162 
 163     @Override
 164     @ForceInline
 165     Byte512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Byte512Shuffle(fn); }
 166 
 167     // Make a vector of the same species but the given elements:
 168     @ForceInline
 169     final @Override
 170     Byte512Vector vectorFactory(byte[] vec) {
 171         return new Byte512Vector(vec);
 172     }
 173 
 174     @ForceInline
 175     final @Override
 176     Byte512Vector asByteVectorRaw() {
 177         return (Byte512Vector) super.asByteVectorRawTemplate();  // specialize
 178     }
 179 
 180     @ForceInline
 181     final @Override
 182     AbstractVector<?> asVectorRaw(LaneType laneType) {
 183         return super.asVectorRawTemplate(laneType);  // specialize
 184     }
 185 
 186     // Unary operator
 187 
 188     @ForceInline
 189     final @Override
 190     Byte512Vector uOp(FUnOp f) {
 191         return (Byte512Vector) super.uOpTemplate(f);  // specialize
 192     }
 193 
 194     @ForceInline
 195     final @Override
 196     Byte512Vector uOp(VectorMask<Byte> m, FUnOp f) {
 197         return (Byte512Vector)
 198             super.uOpTemplate((Byte512Mask)m, f);  // specialize
 199     }
 200 
 201     // Binary operator
 202 
 203     @ForceInline
 204     final @Override
 205     Byte512Vector bOp(Vector<Byte> v, FBinOp f) {
 206         return (Byte512Vector) super.bOpTemplate((Byte512Vector)v, f);  // specialize
 207     }
 208 
 209     @ForceInline
 210     final @Override
 211     Byte512Vector bOp(Vector<Byte> v,
 212                      VectorMask<Byte> m, FBinOp f) {
 213         return (Byte512Vector)
 214             super.bOpTemplate((Byte512Vector)v, (Byte512Mask)m,
 215                               f);  // specialize
 216     }
 217 
 218     // Ternary operator
 219 
 220     @ForceInline
 221     final @Override
 222     Byte512Vector tOp(Vector<Byte> v1, Vector<Byte> v2, FTriOp f) {
 223         return (Byte512Vector)
 224             super.tOpTemplate((Byte512Vector)v1, (Byte512Vector)v2,
 225                               f);  // specialize
 226     }
 227 
 228     @ForceInline
 229     final @Override
 230     Byte512Vector tOp(Vector<Byte> v1, Vector<Byte> v2,
 231                      VectorMask<Byte> m, FTriOp f) {
 232         return (Byte512Vector)
 233             super.tOpTemplate((Byte512Vector)v1, (Byte512Vector)v2,
 234                               (Byte512Mask)m, f);  // specialize
 235     }
 236 
 237     @ForceInline
 238     final @Override
 239     byte rOp(byte v, VectorMask<Byte> m, FBinOp f) {
 240         return super.rOpTemplate(v, m, f);  // specialize
 241     }
 242 
 243     @Override
 244     @ForceInline
 245     public final <F>
 246     Vector<F> convertShape(VectorOperators.Conversion<Byte,F> conv,
 247                            VectorSpecies<F> rsp, int part) {
 248         return super.convertShapeTemplate(conv, rsp, part);  // specialize
 249     }
 250 
 251     @Override
 252     @ForceInline
 253     public final <F>
 254     Vector<F> reinterpretShape(VectorSpecies<F> toSpecies, int part) {
 255         return super.reinterpretShapeTemplate(toSpecies, part);  // specialize
 256     }
 257 
 258     // Specialized algebraic operations:
 259 
 260     // The following definition forces a specialized version of this
 261     // crucial method into the v-table of this class.  A call to add()
 262     // will inline to a call to lanewise(ADD,), at which point the JIT
 263     // intrinsic will have the opcode of ADD, plus all the metadata
 264     // for this particular class, enabling it to generate precise
 265     // code.
 266     //
 267     // There is probably no benefit to the JIT to specialize the
 268     // masked or broadcast versions of the lanewise method.
 269 
 270     @Override
 271     @ForceInline
 272     public Byte512Vector lanewise(Unary op) {
 273         return (Byte512Vector) super.lanewiseTemplate(op);  // specialize
 274     }
 275 
 276     @Override
 277     @ForceInline
 278     public Byte512Vector lanewise(Unary op, VectorMask<Byte> m) {
 279         return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, (Byte512Mask) m);  // specialize
 280     }
 281 
 282     @Override
 283     @ForceInline
 284     public Byte512Vector lanewise(Binary op, Vector<Byte> v) {
 285         return (Byte512Vector) super.lanewiseTemplate(op, v);  // specialize
 286     }
 287 
 288     @Override
 289     @ForceInline
 290     public Byte512Vector lanewise(Binary op, Vector<Byte> v, VectorMask<Byte> m) {
 291         return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, v, (Byte512Mask) m);  // specialize
 292     }
 293 
 294     /*package-private*/
 295     @Override
 296     @ForceInline Byte512Vector
 297     lanewiseShift(VectorOperators.Binary op, int e) {
 298         return (Byte512Vector) super.lanewiseShiftTemplate(op, e);  // specialize
 299     }
 300 
 301     /*package-private*/
 302     @Override
 303     @ForceInline Byte512Vector
 304     lanewiseShift(VectorOperators.Binary op, int e, VectorMask<Byte> m) {
 305         return (Byte512Vector) super.lanewiseShiftTemplate(op, Byte512Mask.class, e, (Byte512Mask) m);  // specialize
 306     }
 307 
 308     /*package-private*/
 309     @Override
 310     @ForceInline
 311     public final
 312     Byte512Vector
 313     lanewise(Ternary op, Vector<Byte> v1, Vector<Byte> v2) {
 314         return (Byte512Vector) super.lanewiseTemplate(op, v1, v2);  // specialize
 315     }
 316 
 317     @Override
 318     @ForceInline
 319     public final
 320     Byte512Vector
 321     lanewise(Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m) {
 322         return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, v1, v2, (Byte512Mask) m);  // specialize
 323     }
 324 
 325     @Override
 326     @ForceInline
 327     public final
 328     Byte512Vector addIndex(int scale) {
 329         return (Byte512Vector) super.addIndexTemplate(scale);  // specialize
 330     }
 331 
 332     // Type specific horizontal reductions
 333 
 334     @Override
 335     @ForceInline
 336     public final byte reduceLanes(VectorOperators.Associative op) {
 337         return super.reduceLanesTemplate(op);  // specialized
 338     }
 339 
 340     @Override
 341     @ForceInline
 342     public final byte reduceLanes(VectorOperators.Associative op,
 343                                     VectorMask<Byte> m) {
 344         return super.reduceLanesTemplate(op, Byte512Mask.class, (Byte512Mask) m);  // specialized
 345     }
 346 
 347     @Override
 348     @ForceInline
 349     public final long reduceLanesToLong(VectorOperators.Associative op) {
 350         return (long) super.reduceLanesTemplate(op);  // specialized
 351     }
 352 
 353     @Override
 354     @ForceInline
 355     public final long reduceLanesToLong(VectorOperators.Associative op,
 356                                         VectorMask<Byte> m) {
 357         return (long) super.reduceLanesTemplate(op, Byte512Mask.class, (Byte512Mask) m);  // specialized
 358     }
 359 
 360     @ForceInline
 361     public VectorShuffle<Byte> toShuffle() {
 362         return super.toShuffleTemplate(Byte512Shuffle.class); // specialize
 363     }
 364 
 365     // Specialized unary testing
 366 
 367     @Override
 368     @ForceInline
 369     public final Byte512Mask test(Test op) {
 370         return super.testTemplate(Byte512Mask.class, op);  // specialize
 371     }
 372 
 373     @Override
 374     @ForceInline
 375     public final Byte512Mask test(Test op, VectorMask<Byte> m) {
 376         return super.testTemplate(Byte512Mask.class, op, (Byte512Mask) m);  // specialize
 377     }
 378 
 379     // Specialized comparisons
 380 
 381     @Override
 382     @ForceInline
 383     public final Byte512Mask compare(Comparison op, Vector<Byte> v) {
 384         return super.compareTemplate(Byte512Mask.class, op, v);  // specialize
 385     }
 386 
 387     @Override
 388     @ForceInline
 389     public final Byte512Mask compare(Comparison op, byte s) {
 390         return super.compareTemplate(Byte512Mask.class, op, s);  // specialize
 391     }
 392 
 393     @Override
 394     @ForceInline
 395     public final Byte512Mask compare(Comparison op, long s) {
 396         return super.compareTemplate(Byte512Mask.class, op, s);  // specialize
 397     }
 398 
 399     @Override
 400     @ForceInline
 401     public final Byte512Mask compare(Comparison op, Vector<Byte> v, VectorMask<Byte> m) {
 402         return super.compareTemplate(Byte512Mask.class, op, v, (Byte512Mask) m);
 403     }
 404 
 405 
 406     @Override
 407     @ForceInline
 408     public Byte512Vector blend(Vector<Byte> v, VectorMask<Byte> m) {
 409         return (Byte512Vector)
 410             super.blendTemplate(Byte512Mask.class,
 411                                 (Byte512Vector) v,
 412                                 (Byte512Mask) m);  // specialize
 413     }
 414 
 415     @Override
 416     @ForceInline
 417     public Byte512Vector slice(int origin, Vector<Byte> v) {
 418         return (Byte512Vector) super.sliceTemplate(origin, v);  // specialize
 419     }
 420 
 421     @Override
 422     @ForceInline
 423     public Byte512Vector slice(int origin) {
 424         return (Byte512Vector) super.sliceTemplate(origin);  // specialize
 425     }
 426 
 427     @Override
 428     @ForceInline
 429     public Byte512Vector unslice(int origin, Vector<Byte> w, int part) {
 430         return (Byte512Vector) super.unsliceTemplate(origin, w, part);  // specialize
 431     }
 432 
 433     @Override
 434     @ForceInline
 435     public Byte512Vector unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m) {
 436         return (Byte512Vector)
 437             super.unsliceTemplate(Byte512Mask.class,
 438                                   origin, w, part,
 439                                   (Byte512Mask) m);  // specialize
 440     }
 441 
 442     @Override
 443     @ForceInline
 444     public Byte512Vector unslice(int origin) {
 445         return (Byte512Vector) super.unsliceTemplate(origin);  // specialize
 446     }
 447 
 448     @Override
 449     @ForceInline
 450     public Byte512Vector rearrange(VectorShuffle<Byte> s) {
 451         return (Byte512Vector)
 452             super.rearrangeTemplate(Byte512Shuffle.class,
 453                                     (Byte512Shuffle) s);  // specialize
 454     }
 455 
 456     @Override
 457     @ForceInline
 458     public Byte512Vector rearrange(VectorShuffle<Byte> shuffle,
 459                                   VectorMask<Byte> m) {
 460         return (Byte512Vector)
 461             super.rearrangeTemplate(Byte512Shuffle.class,
 462                                     Byte512Mask.class,
 463                                     (Byte512Shuffle) shuffle,
 464                                     (Byte512Mask) m);  // specialize
 465     }
 466 
 467     @Override
 468     @ForceInline
 469     public Byte512Vector rearrange(VectorShuffle<Byte> s,
 470                                   Vector<Byte> v) {
 471         return (Byte512Vector)
 472             super.rearrangeTemplate(Byte512Shuffle.class,
 473                                     (Byte512Shuffle) s,
 474                                     (Byte512Vector) v);  // specialize
 475     }
 476 
 477     @Override
 478     @ForceInline
 479     public Byte512Vector compress(VectorMask<Byte> m) {
 480         return (Byte512Vector)
 481             super.compressTemplate(Byte512Mask.class,
 482                                    (Byte512Mask) m);  // specialize
 483     }
 484 
 485     @Override
 486     @ForceInline
 487     public Byte512Vector expand(VectorMask<Byte> m) {
 488         return (Byte512Vector)
 489             super.expandTemplate(Byte512Mask.class,
 490                                    (Byte512Mask) m);  // specialize
 491     }
 492 
 493     @Override
 494     @ForceInline
 495     public Byte512Vector selectFrom(Vector<Byte> v) {
 496         return (Byte512Vector)
 497             super.selectFromTemplate((Byte512Vector) v);  // specialize
 498     }
 499 
 500     @Override
 501     @ForceInline
 502     public Byte512Vector selectFrom(Vector<Byte> v,
 503                                    VectorMask<Byte> m) {
 504         return (Byte512Vector)
 505             super.selectFromTemplate((Byte512Vector) v,
 506                                      (Byte512Mask) m);  // specialize
 507     }
 508 
 509 
 510     @ForceInline
 511     @Override
 512     public byte lane(int i) {
 513         switch(i) {
 514             case 0: return laneHelper(0);
 515             case 1: return laneHelper(1);
 516             case 2: return laneHelper(2);
 517             case 3: return laneHelper(3);
 518             case 4: return laneHelper(4);
 519             case 5: return laneHelper(5);
 520             case 6: return laneHelper(6);
 521             case 7: return laneHelper(7);
 522             case 8: return laneHelper(8);
 523             case 9: return laneHelper(9);
 524             case 10: return laneHelper(10);
 525             case 11: return laneHelper(11);
 526             case 12: return laneHelper(12);
 527             case 13: return laneHelper(13);
 528             case 14: return laneHelper(14);
 529             case 15: return laneHelper(15);
 530             case 16: return laneHelper(16);
 531             case 17: return laneHelper(17);
 532             case 18: return laneHelper(18);
 533             case 19: return laneHelper(19);
 534             case 20: return laneHelper(20);
 535             case 21: return laneHelper(21);
 536             case 22: return laneHelper(22);
 537             case 23: return laneHelper(23);
 538             case 24: return laneHelper(24);
 539             case 25: return laneHelper(25);
 540             case 26: return laneHelper(26);
 541             case 27: return laneHelper(27);
 542             case 28: return laneHelper(28);
 543             case 29: return laneHelper(29);
 544             case 30: return laneHelper(30);
 545             case 31: return laneHelper(31);
 546             case 32: return laneHelper(32);
 547             case 33: return laneHelper(33);
 548             case 34: return laneHelper(34);
 549             case 35: return laneHelper(35);
 550             case 36: return laneHelper(36);
 551             case 37: return laneHelper(37);
 552             case 38: return laneHelper(38);
 553             case 39: return laneHelper(39);
 554             case 40: return laneHelper(40);
 555             case 41: return laneHelper(41);
 556             case 42: return laneHelper(42);
 557             case 43: return laneHelper(43);
 558             case 44: return laneHelper(44);
 559             case 45: return laneHelper(45);
 560             case 46: return laneHelper(46);
 561             case 47: return laneHelper(47);
 562             case 48: return laneHelper(48);
 563             case 49: return laneHelper(49);
 564             case 50: return laneHelper(50);
 565             case 51: return laneHelper(51);
 566             case 52: return laneHelper(52);
 567             case 53: return laneHelper(53);
 568             case 54: return laneHelper(54);
 569             case 55: return laneHelper(55);
 570             case 56: return laneHelper(56);
 571             case 57: return laneHelper(57);
 572             case 58: return laneHelper(58);
 573             case 59: return laneHelper(59);
 574             case 60: return laneHelper(60);
 575             case 61: return laneHelper(61);
 576             case 62: return laneHelper(62);
 577             case 63: return laneHelper(63);
 578             default: throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH);
 579         }
 580     }
 581 
 582     public byte laneHelper(int i) {
 583         return (byte) VectorSupport.extract(
 584                                 VCLASS, ETYPE, VLENGTH,
 585                                 this, i,
 586                                 (vec, ix) -> {
 587                                     byte[] vecarr = vec.vec();
 588                                     return (long)vecarr[ix];
 589                                 });
 590     }
 591 
 592     @ForceInline
 593     @Override
 594     public Byte512Vector withLane(int i, byte e) {
 595         switch (i) {
 596             case 0: return withLaneHelper(0, e);
 597             case 1: return withLaneHelper(1, e);
 598             case 2: return withLaneHelper(2, e);
 599             case 3: return withLaneHelper(3, e);
 600             case 4: return withLaneHelper(4, e);
 601             case 5: return withLaneHelper(5, e);
 602             case 6: return withLaneHelper(6, e);
 603             case 7: return withLaneHelper(7, e);
 604             case 8: return withLaneHelper(8, e);
 605             case 9: return withLaneHelper(9, e);
 606             case 10: return withLaneHelper(10, e);
 607             case 11: return withLaneHelper(11, e);
 608             case 12: return withLaneHelper(12, e);
 609             case 13: return withLaneHelper(13, e);
 610             case 14: return withLaneHelper(14, e);
 611             case 15: return withLaneHelper(15, e);
 612             case 16: return withLaneHelper(16, e);
 613             case 17: return withLaneHelper(17, e);
 614             case 18: return withLaneHelper(18, e);
 615             case 19: return withLaneHelper(19, e);
 616             case 20: return withLaneHelper(20, e);
 617             case 21: return withLaneHelper(21, e);
 618             case 22: return withLaneHelper(22, e);
 619             case 23: return withLaneHelper(23, e);
 620             case 24: return withLaneHelper(24, e);
 621             case 25: return withLaneHelper(25, e);
 622             case 26: return withLaneHelper(26, e);
 623             case 27: return withLaneHelper(27, e);
 624             case 28: return withLaneHelper(28, e);
 625             case 29: return withLaneHelper(29, e);
 626             case 30: return withLaneHelper(30, e);
 627             case 31: return withLaneHelper(31, e);
 628             case 32: return withLaneHelper(32, e);
 629             case 33: return withLaneHelper(33, e);
 630             case 34: return withLaneHelper(34, e);
 631             case 35: return withLaneHelper(35, e);
 632             case 36: return withLaneHelper(36, e);
 633             case 37: return withLaneHelper(37, e);
 634             case 38: return withLaneHelper(38, e);
 635             case 39: return withLaneHelper(39, e);
 636             case 40: return withLaneHelper(40, e);
 637             case 41: return withLaneHelper(41, e);
 638             case 42: return withLaneHelper(42, e);
 639             case 43: return withLaneHelper(43, e);
 640             case 44: return withLaneHelper(44, e);
 641             case 45: return withLaneHelper(45, e);
 642             case 46: return withLaneHelper(46, e);
 643             case 47: return withLaneHelper(47, e);
 644             case 48: return withLaneHelper(48, e);
 645             case 49: return withLaneHelper(49, e);
 646             case 50: return withLaneHelper(50, e);
 647             case 51: return withLaneHelper(51, e);
 648             case 52: return withLaneHelper(52, e);
 649             case 53: return withLaneHelper(53, e);
 650             case 54: return withLaneHelper(54, e);
 651             case 55: return withLaneHelper(55, e);
 652             case 56: return withLaneHelper(56, e);
 653             case 57: return withLaneHelper(57, e);
 654             case 58: return withLaneHelper(58, e);
 655             case 59: return withLaneHelper(59, e);
 656             case 60: return withLaneHelper(60, e);
 657             case 61: return withLaneHelper(61, e);
 658             case 62: return withLaneHelper(62, e);
 659             case 63: return withLaneHelper(63, e);
 660             default: throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH);
 661         }
 662     }
 663 
 664     public Byte512Vector withLaneHelper(int i, byte e) {
 665         return VectorSupport.insert(
 666                                 VCLASS, ETYPE, VLENGTH,
 667                                 this, i, (long)e,
 668                                 (v, ix, bits) -> {
 669                                     byte[] res = v.vec().clone();
 670                                     res[ix] = (byte)bits;
 671                                     return v.vectorFactory(res);
 672                                 });
 673     }
 674 
 675     // Mask
 676 
 677     static final class Byte512Mask extends AbstractMask<Byte> {
 678         static final int VLENGTH = VSPECIES.laneCount();    // used by the JVM
 679         static final Class<Byte> ETYPE = byte.class; // used by the JVM
 680 
 681         Byte512Mask(boolean[] bits) {
 682             this(bits, 0);
 683         }
 684 
 685         Byte512Mask(boolean[] bits, int offset) {
 686             super(prepare(bits, offset));
 687         }
 688 
 689         Byte512Mask(boolean val) {
 690             super(prepare(val));
 691         }
 692 
 693         private static boolean[] prepare(boolean[] bits, int offset) {
 694             boolean[] newBits = new boolean[VSPECIES.laneCount()];
 695             for (int i = 0; i < newBits.length; i++) {
 696                 newBits[i] = bits[offset + i];
 697             }
 698             return newBits;
 699         }
 700 
 701         private static boolean[] prepare(boolean val) {
 702             boolean[] bits = new boolean[VSPECIES.laneCount()];
 703             Arrays.fill(bits, val);
 704             return bits;
 705         }
 706 
 707         @ForceInline
 708         final @Override
 709         public ByteSpecies vspecies() {
 710             // ISSUE:  This should probably be a @Stable
 711             // field inside AbstractMask, rather than
 712             // a megamorphic method.
 713             return VSPECIES;
 714         }
 715 
 716         @ForceInline
 717         boolean[] getBits() {
 718             return (boolean[])getPayload();
 719         }
 720 
 721         @Override
 722         Byte512Mask uOp(MUnOp f) {
 723             boolean[] res = new boolean[vspecies().laneCount()];
 724             boolean[] bits = getBits();
 725             for (int i = 0; i < res.length; i++) {
 726                 res[i] = f.apply(i, bits[i]);
 727             }
 728             return new Byte512Mask(res);
 729         }
 730 
 731         @Override
 732         Byte512Mask bOp(VectorMask<Byte> m, MBinOp f) {
 733             boolean[] res = new boolean[vspecies().laneCount()];
 734             boolean[] bits = getBits();
 735             boolean[] mbits = ((Byte512Mask)m).getBits();
 736             for (int i = 0; i < res.length; i++) {
 737                 res[i] = f.apply(i, bits[i], mbits[i]);
 738             }
 739             return new Byte512Mask(res);
 740         }
 741 
 742         @ForceInline
 743         @Override
 744         public final
 745         Byte512Vector toVector() {
 746             return (Byte512Vector) super.toVectorTemplate();  // specialize
 747         }
 748 
 749         /**
 750          * Helper function for lane-wise mask conversions.
 751          * This function kicks in after intrinsic failure.
 752          */
 753         @ForceInline
 754         private final <E>
 755         VectorMask<E> defaultMaskCast(AbstractSpecies<E> dsp) {
 756             if (length() != dsp.laneCount())
 757                 throw new IllegalArgumentException("VectorMask length and species length differ");
 758             boolean[] maskArray = toArray();
 759             return  dsp.maskFactory(maskArray).check(dsp);
 760         }
 761 
 762         @Override
 763         @ForceInline
 764         public <E> VectorMask<E> cast(VectorSpecies<E> dsp) {
 765             AbstractSpecies<E> species = (AbstractSpecies<E>) dsp;
 766             if (length() != species.laneCount())
 767                 throw new IllegalArgumentException("VectorMask length and species length differ");
 768 
 769             return VectorSupport.convert(VectorSupport.VECTOR_OP_CAST,
 770                 this.getClass(), ETYPE, VLENGTH,
 771                 species.maskType(), species.elementType(), VLENGTH,
 772                 this, species,
 773                 (m, s) -> s.maskFactory(m.toArray()).check(s));
 774         }
 775 
 776         @Override
 777         @ForceInline
 778         public Byte512Mask eq(VectorMask<Byte> mask) {
 779             Objects.requireNonNull(mask);
 780             Byte512Mask m = (Byte512Mask)mask;
 781             return xor(m.not());
 782         }
 783 
 784         // Unary operations
 785 
 786         @Override
 787         @ForceInline
 788         public Byte512Mask not() {
 789             return xor(maskAll(true));
 790         }
 791 
 792         @Override
 793         @ForceInline
 794         public Byte512Mask compress() {
 795             return (Byte512Mask)VectorSupport.comExpOp(VectorSupport.VECTOR_OP_MASK_COMPRESS,
 796                 Byte512Vector.class, Byte512Mask.class, ETYPE, VLENGTH, null, this,
 797                 (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount()));
 798         }
 799 
 800 
 801         // Binary operations
 802 
 803         @Override
 804         @ForceInline
 805         public Byte512Mask and(VectorMask<Byte> mask) {
 806             Objects.requireNonNull(mask);
 807             Byte512Mask m = (Byte512Mask)mask;
 808             return VectorSupport.binaryOp(VECTOR_OP_AND, Byte512Mask.class, null, byte.class, VLENGTH,
 809                                           this, m, null,
 810                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
 811         }
 812 
 813         @Override
 814         @ForceInline
 815         public Byte512Mask or(VectorMask<Byte> mask) {
 816             Objects.requireNonNull(mask);
 817             Byte512Mask m = (Byte512Mask)mask;
 818             return VectorSupport.binaryOp(VECTOR_OP_OR, Byte512Mask.class, null, byte.class, VLENGTH,
 819                                           this, m, null,
 820                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
 821         }
 822 
 823         @ForceInline
 824         /* package-private */
 825         Byte512Mask xor(VectorMask<Byte> mask) {
 826             Objects.requireNonNull(mask);
 827             Byte512Mask m = (Byte512Mask)mask;
 828             return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte512Mask.class, null, byte.class, VLENGTH,
 829                                           this, m, null,
 830                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b));
 831         }
 832 
 833         // Mask Query operations
 834 
 835         @Override
 836         @ForceInline
 837         public int trueCount() {
 838             return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Byte512Mask.class, byte.class, VLENGTH, this,
 839                                                       (m) -> trueCountHelper(m.getBits()));
 840         }
 841 
 842         @Override
 843         @ForceInline
 844         public int firstTrue() {
 845             return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Byte512Mask.class, byte.class, VLENGTH, this,
 846                                                       (m) -> firstTrueHelper(m.getBits()));
 847         }
 848 
 849         @Override
 850         @ForceInline
 851         public int lastTrue() {
 852             return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Byte512Mask.class, byte.class, VLENGTH, this,
 853                                                       (m) -> lastTrueHelper(m.getBits()));
 854         }
 855 
 856         @Override
 857         @ForceInline
 858         public long toLong() {
 859             if (length() > Long.SIZE) {
 860                 throw new UnsupportedOperationException("too many lanes for one long");
 861             }
 862             return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Byte512Mask.class, byte.class, VLENGTH, this,
 863                                                       (m) -> toLongHelper(m.getBits()));
 864         }
 865 
 866         // Reductions
 867 
 868         @Override
 869         @ForceInline
 870         public boolean anyTrue() {
 871             return VectorSupport.test(BT_ne, Byte512Mask.class, byte.class, VLENGTH,
 872                                          this, vspecies().maskAll(true),
 873                                          (m, __) -> anyTrueHelper(((Byte512Mask)m).getBits()));
 874         }
 875 
 876         @Override
 877         @ForceInline
 878         public boolean allTrue() {
 879             return VectorSupport.test(BT_overflow, Byte512Mask.class, byte.class, VLENGTH,
 880                                          this, vspecies().maskAll(true),
 881                                          (m, __) -> allTrueHelper(((Byte512Mask)m).getBits()));
 882         }
 883 
 884         @ForceInline
 885         /*package-private*/
 886         static Byte512Mask maskAll(boolean bit) {
 887             return VectorSupport.fromBitsCoerced(Byte512Mask.class, byte.class, VLENGTH,
 888                                                  (bit ? -1 : 0), MODE_BROADCAST, null,
 889                                                  (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK));
 890         }
 891         private static final Byte512Mask  TRUE_MASK = new Byte512Mask(true);
 892         private static final Byte512Mask FALSE_MASK = new Byte512Mask(false);
 893 
 894     }
 895 
 896     // Shuffle
 897 
 898     static final class Byte512Shuffle extends AbstractShuffle<Byte> {
 899         static final int VLENGTH = VSPECIES.laneCount();    // used by the JVM
 900         static final Class<Byte> ETYPE = byte.class; // used by the JVM
 901 
 902         Byte512Shuffle(byte[] reorder) {
 903             super(VLENGTH, reorder);
 904         }
 905 
 906         public Byte512Shuffle(int[] reorder) {
 907             super(VLENGTH, reorder);
 908         }
 909 
 910         public Byte512Shuffle(int[] reorder, int i) {
 911             super(VLENGTH, reorder, i);
 912         }
 913 
 914         public Byte512Shuffle(IntUnaryOperator fn) {
 915             super(VLENGTH, fn);
 916         }
 917 
 918         @Override
 919         public ByteSpecies vspecies() {
 920             return VSPECIES;
 921         }
 922 
 923         static {
 924             // There must be enough bits in the shuffle lanes to encode
 925             // VLENGTH valid indexes and VLENGTH exceptional ones.
 926             assert(VLENGTH < Byte.MAX_VALUE);
 927             assert(Byte.MIN_VALUE <= -VLENGTH);
 928         }
 929         static final Byte512Shuffle IOTA = new Byte512Shuffle(IDENTITY);
 930 
 931         @Override
 932         @ForceInline
 933         public Byte512Vector toVector() {
 934             return VectorSupport.shuffleToVector(VCLASS, ETYPE, Byte512Shuffle.class, this, VLENGTH,
 935                                                     (s) -> ((Byte512Vector)(((AbstractShuffle<Byte>)(s)).toVectorTemplate())));
 936         }
 937 
 938         @Override
 939         @ForceInline
 940         public <F> VectorShuffle<F> cast(VectorSpecies<F> s) {
 941             AbstractSpecies<F> species = (AbstractSpecies<F>) s;
 942             if (length() != species.laneCount())
 943                 throw new IllegalArgumentException("VectorShuffle length and species length differ");
 944             int[] shuffleArray = toArray();
 945             return s.shuffleFromArray(shuffleArray, 0).check(s);
 946         }
 947 
 948         @ForceInline
 949         @Override
 950         public Byte512Shuffle rearrange(VectorShuffle<Byte> shuffle) {
 951             Byte512Shuffle s = (Byte512Shuffle) shuffle;
 952             byte[] reorder1 = reorder();
 953             byte[] reorder2 = s.reorder();
 954             byte[] r = new byte[reorder1.length];
 955             for (int i = 0; i < reorder1.length; i++) {
 956                 int ssi = reorder2[i];
 957                 r[i] = reorder1[ssi];  // throws on exceptional index
 958             }
 959             return new Byte512Shuffle(r);
 960         }
 961     }
 962 
 963     // ================================================
 964 
 965     // Specialized low-level memory operations.
 966 
 967     @ForceInline
 968     @Override
 969     final
 970     ByteVector fromArray0(byte[] a, int offset) {
 971         return super.fromArray0Template(a, offset);  // specialize
 972     }
 973 
 974     @ForceInline
 975     @Override
 976     final
 977     ByteVector fromArray0(byte[] a, int offset, VectorMask<Byte> m) {
 978         return super.fromArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m);  // specialize
 979     }
 980 
 981 
 982 
 983     @ForceInline
 984     @Override
 985     final
 986     ByteVector fromBooleanArray0(boolean[] a, int offset) {
 987         return super.fromBooleanArray0Template(a, offset);  // specialize
 988     }
 989 
 990     @ForceInline
 991     @Override
 992     final
 993     ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask<Byte> m) {
 994         return super.fromBooleanArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m);  // specialize
 995     }
 996 
 997     @ForceInline
 998     @Override
 999     final
1000     ByteVector fromMemorySegment0(MemorySegment ms, long offset) {
1001         return super.fromMemorySegment0Template(ms, offset);  // specialize
1002     }
1003 
1004     @ForceInline
1005     @Override
1006     final
1007     ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask<Byte> m) {
1008         return super.fromMemorySegment0Template(Byte512Mask.class, ms, offset, (Byte512Mask) m);  // specialize
1009     }
1010 
1011     @ForceInline
1012     @Override
1013     final
1014     void intoArray0(byte[] a, int offset) {
1015         super.intoArray0Template(a, offset);  // specialize
1016     }
1017 
1018     @ForceInline
1019     @Override
1020     final
1021     void intoArray0(byte[] a, int offset, VectorMask<Byte> m) {
1022         super.intoArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m);
1023     }
1024 
1025 
1026     @ForceInline
1027     @Override
1028     final
1029     void intoBooleanArray0(boolean[] a, int offset, VectorMask<Byte> m) {
1030         super.intoBooleanArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m);
1031     }
1032 
1033     @ForceInline
1034     @Override
1035     final
1036     void intoMemorySegment0(MemorySegment ms, long offset, VectorMask<Byte> m) {
1037         super.intoMemorySegment0Template(Byte512Mask.class, ms, offset, (Byte512Mask) m);
1038     }
1039 
1040 
1041     // End of specialized low-level memory operations.
1042 
1043     // ================================================
1044 
1045 }