1 /* 2 * Copyright (c) 2017, 2019, 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.LongBuffer; 30 import java.nio.ReadOnlyBufferException; 31 import java.util.Arrays; 32 import java.util.Objects; 33 import java.util.function.IntUnaryOperator; 34 35 import jdk.internal.misc.Unsafe; 36 import jdk.internal.vm.annotation.ForceInline; 37 import jdk.internal.vm.annotation.Stable; 38 39 import static jdk.incubator.vector.VectorIntrinsics.*; 40 import static jdk.incubator.vector.VectorOperators.*; 41 42 // -- This file was mechanically generated: Do not edit! -- // 43 44 @SuppressWarnings("cast") // warning: redundant cast 45 final class Long64Vector extends LongVector { 46 static final LongSpecies VSPECIES = 47 (LongSpecies) LongVector.SPECIES_64; 48 49 static final VectorShape VSHAPE = 50 VSPECIES.vectorShape(); 51 52 static final Class<Long64Vector> VCLASS = Long64Vector.class; 53 54 static final int VSIZE = VSPECIES.vectorBitSize(); 55 56 static final int VLENGTH = VSPECIES.laneCount(); 57 58 static final Class<Long> ETYPE = long.class; 59 60 // The JVM expects to find the state here. 61 private final long[] vec; // Don't access directly, use vec() instead. 62 63 Long64Vector(long[] v) { 64 vec = v; 65 } 66 67 // For compatibility as Long64Vector::new, 68 // stored into species.vectorFactory. 69 Long64Vector(Object v) { 70 this((long[]) v); 71 } 72 73 static final Long64Vector ZERO = new Long64Vector(new long[VLENGTH]); 74 static final Long64Vector IOTA = new Long64Vector(VSPECIES.iotaArray()); 75 76 static { 77 // Warm up a few species caches. 78 // If we do this too much we will 79 // get NPEs from bootstrap circularity. 80 VSPECIES.dummyVector(); 81 VSPECIES.withLanes(LaneType.BYTE); 82 } 83 84 // Specialized extractors 85 86 @ForceInline 87 final @Override 88 public LongSpecies vspecies() { 89 // ISSUE: This should probably be a @Stable 90 // field inside AbstractVector, rather than 91 // a megamorphic method. 92 return VSPECIES; 93 } 94 95 @ForceInline 96 @Override 97 public final Class<Long> elementType() { return long.class; } 98 99 @ForceInline 100 @Override 101 public final int elementSize() { return Long.SIZE; } 102 103 @ForceInline 104 @Override 105 public final VectorShape shape() { return VSHAPE; } 106 107 @ForceInline 108 @Override 109 public final int length() { return VLENGTH; } 110 111 @ForceInline 112 @Override 113 public final int bitSize() { return VSIZE; } 114 115 @ForceInline 116 @Override 117 public final int byteSize() { return VSIZE / Byte.SIZE; } 118 119 /*package-private*/ 120 @ForceInline 121 final @Override 122 long[] vec() { 123 return VectorIntrinsics.maybeRebox(this).vec; 124 } 125 126 // Virtualized constructors 127 128 @Override 129 @ForceInline 130 public final Long64Vector broadcast(long e) { 131 return (Long64Vector) super.broadcastTemplate(e); // specialize 132 } 133 134 135 @Override 136 @ForceInline 137 Long64Mask maskFromArray(boolean[] bits) { 138 return new Long64Mask(bits); 139 } 140 141 @Override 142 @ForceInline 143 Long64Shuffle iotaShuffle() { return Long64Shuffle.IOTA; } 144 145 @ForceInline 146 Long64Shuffle iotaShuffle(int start) { 147 return (Long64Shuffle)VectorIntrinsics.shuffleIota(ETYPE, Long64Shuffle.class, VSPECIES, VLENGTH, start, (val, l) -> new Long64Shuffle(i -> (VectorIntrinsics.wrapToRange(i + val, l)))); 148 } 149 150 @Override 151 @ForceInline 152 Long64Shuffle shuffleFromBytes(byte[] reorder) { return new Long64Shuffle(reorder); } 153 154 @Override 155 @ForceInline 156 Long64Shuffle shuffleFromArray(int[] indexes, int i) { return new Long64Shuffle(indexes, i); } 157 158 @Override 159 @ForceInline 160 Long64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Long64Shuffle(fn); } 161 162 // Make a vector of the same species but the given elements: 163 @ForceInline 164 final @Override 165 Long64Vector vectorFactory(long[] vec) { 166 return new Long64Vector(vec); 167 } 168 169 @ForceInline 170 final @Override 171 Byte64Vector asByteVectorRaw() { 172 return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize 173 } 174 175 @ForceInline 176 final @Override 177 AbstractVector<?> asVectorRaw(LaneType laneType) { 178 return super.asVectorRawTemplate(laneType); // specialize 179 } 180 181 // Unary operator 182 183 final @Override 184 Long64Vector uOp(FUnOp f) { 185 return (Long64Vector) super.uOpTemplate(f); // specialize 186 } 187 188 @ForceInline 189 final @Override 190 Long64Vector uOp(VectorMask<Long> m, FUnOp f) { 191 return (Long64Vector) 192 super.uOpTemplate((Long64Mask)m, f); // specialize 193 } 194 195 // Binary operator 196 197 @ForceInline 198 final @Override 199 Long64Vector bOp(Vector<Long> v, FBinOp f) { 200 return (Long64Vector) super.bOpTemplate((Long64Vector)v, f); // specialize 201 } 202 203 @ForceInline 204 final @Override 205 Long64Vector bOp(Vector<Long> v, 206 VectorMask<Long> m, FBinOp f) { 207 return (Long64Vector) 208 super.bOpTemplate((Long64Vector)v, (Long64Mask)m, 209 f); // specialize 210 } 211 212 // Ternary operator 213 214 @ForceInline 215 final @Override 216 Long64Vector tOp(Vector<Long> v1, Vector<Long> v2, FTriOp f) { 217 return (Long64Vector) 218 super.tOpTemplate((Long64Vector)v1, (Long64Vector)v2, 219 f); // specialize 220 } 221 222 @ForceInline 223 final @Override 224 Long64Vector tOp(Vector<Long> v1, Vector<Long> v2, 225 VectorMask<Long> m, FTriOp f) { 226 return (Long64Vector) 227 super.tOpTemplate((Long64Vector)v1, (Long64Vector)v2, 228 (Long64Mask)m, f); // specialize 229 } 230 231 @ForceInline 232 final @Override 233 long rOp(long v, FBinOp f) { 234 return super.rOpTemplate(v, f); // specialize 235 } 236 237 @Override 238 @ForceInline 239 public final <F> 240 Vector<F> convertShape(VectorOperators.Conversion<Long,F> conv, 241 VectorSpecies<F> rsp, int part) { 242 return super.convertShapeTemplate(conv, rsp, part); // specialize 243 } 244 245 @Override 246 @ForceInline 247 public final <F> 248 Vector<F> reinterpretShape(VectorSpecies<F> toSpecies, int part) { 249 return super.reinterpretShapeTemplate(toSpecies, part); // specialize 250 } 251 252 // Specialized algebraic operations: 253 254 // The following definition forces a specialized version of this 255 // crucial method into the v-table of this class. A call to add() 256 // will inline to a call to lanewise(ADD,), at which point the JIT 257 // intrinsic will have the opcode of ADD, plus all the metadata 258 // for this particular class, enabling it to generate precise 259 // code. 260 // 261 // There is probably no benefit to the JIT to specialize the 262 // masked or broadcast versions of the lanewise method. 263 264 @Override 265 @ForceInline 266 public Long64Vector lanewise(Unary op) { 267 return (Long64Vector) super.lanewiseTemplate(op); // specialize 268 } 269 270 @Override 271 @ForceInline 272 public Long64Vector lanewise(Binary op, Vector<Long> v) { 273 return (Long64Vector) super.lanewiseTemplate(op, v); // specialize 274 } 275 276 /*package-private*/ 277 @Override 278 @ForceInline Long64Vector 279 lanewiseShift(VectorOperators.Binary op, int e) { 280 return (Long64Vector) super.lanewiseShiftTemplate(op, e); // specialize 281 } 282 283 /*package-private*/ 284 @Override 285 @ForceInline 286 public final 287 Long64Vector 288 lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2) { 289 return (Long64Vector) super.lanewiseTemplate(op, v1, v2); // specialize 290 } 291 292 @Override 293 @ForceInline 294 public final 295 Long64Vector addIndex(int scale) { 296 return (Long64Vector) super.addIndexTemplate(scale); // specialize 297 } 298 299 // Type specific horizontal reductions 300 301 @Override 302 @ForceInline 303 public final long reduceLanes(VectorOperators.Associative op) { 304 return super.reduceLanesTemplate(op); // specialized 305 } 306 307 @Override 308 @ForceInline 309 public final long reduceLanes(VectorOperators.Associative op, 310 VectorMask<Long> m) { 311 return super.reduceLanesTemplate(op, m); // specialized 312 } 313 314 @Override 315 @ForceInline 316 public final long reduceLanesToLong(VectorOperators.Associative op) { 317 return (long) super.reduceLanesTemplate(op); // specialized 318 } 319 320 @Override 321 @ForceInline 322 public final long reduceLanesToLong(VectorOperators.Associative op, 323 VectorMask<Long> m) { 324 return (long) super.reduceLanesTemplate(op, m); // specialized 325 } 326 327 @Override 328 @ForceInline 329 public VectorShuffle<Long> toShuffle() { 330 long[] a = toArray(); 331 int[] sa = new int[a.length]; 332 for (int i = 0; i < a.length; i++) { 333 sa[i] = (int) a[i]; 334 } 335 return VectorShuffle.fromArray(VSPECIES, sa, 0); 336 } 337 338 // Specialized unary testing 339 340 @Override 341 @ForceInline 342 public final Long64Mask test(Test op) { 343 return super.testTemplate(Long64Mask.class, op); // specialize 344 } 345 346 // Specialized comparisons 347 348 @Override 349 @ForceInline 350 public final Long64Mask compare(Comparison op, Vector<Long> v) { 351 return super.compareTemplate(Long64Mask.class, op, v); // specialize 352 } 353 354 @Override 355 @ForceInline 356 public final Long64Mask compare(Comparison op, long s) { 357 return super.compareTemplate(Long64Mask.class, op, s); // specialize 358 } 359 360 361 @Override 362 @ForceInline 363 public Long64Vector blend(Vector<Long> v, VectorMask<Long> m) { 364 return (Long64Vector) 365 super.blendTemplate(Long64Mask.class, 366 (Long64Vector) v, 367 (Long64Mask) m); // specialize 368 } 369 370 @Override 371 @ForceInline 372 public Long64Vector slice(int origin, Vector<Long> v) { 373 return (Long64Vector) super.sliceTemplate(origin, v); // specialize 374 } 375 376 @Override 377 @ForceInline 378 public Long64Vector slice(int origin) { 379 if ((origin < 0) || (origin >= VLENGTH)) { 380 throw new ArrayIndexOutOfBoundsException("Index " + origin + " out of bounds for vector length " + VLENGTH); 381 } else { 382 Long64Shuffle Iota = (Long64Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 383 VectorMask<Long> BlendMask = Iota.toVector().compare(VectorOperators.LT, (broadcast((long)(VLENGTH-origin)))); 384 Iota = (Long64Shuffle)VectorShuffle.iota(VSPECIES, origin, 1, true); 385 return ZERO.blend(this.rearrange(Iota), BlendMask); 386 } 387 } 388 389 @Override 390 @ForceInline 391 public Long64Vector unslice(int origin, Vector<Long> w, int part) { 392 return (Long64Vector) super.unsliceTemplate(origin, w, part); // specialize 393 } 394 395 @Override 396 @ForceInline 397 public Long64Vector unslice(int origin, Vector<Long> w, int part, VectorMask<Long> m) { 398 return (Long64Vector) 399 super.unsliceTemplate(Long64Mask.class, 400 origin, w, part, 401 (Long64Mask) m); // specialize 402 } 403 404 @Override 405 @ForceInline 406 public Long64Vector unslice(int origin) { 407 if ((origin < 0) || (origin >= VLENGTH)) { 408 throw new ArrayIndexOutOfBoundsException("Index " + origin + " out of bounds for vector length " + VLENGTH); 409 } else { 410 Long64Shuffle Iota = (Long64Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 411 VectorMask<Long> BlendMask = Iota.toVector().compare(VectorOperators.GE, (broadcast((long)(origin)))); 412 Iota = (Long64Shuffle)VectorShuffle.iota(VSPECIES, -origin, 1, true); 413 return ZERO.blend(this.rearrange(Iota), BlendMask); 414 } 415 } 416 417 @Override 418 @ForceInline 419 public Long64Vector rearrange(VectorShuffle<Long> s) { 420 return (Long64Vector) 421 super.rearrangeTemplate(Long64Shuffle.class, 422 (Long64Shuffle) s); // specialize 423 } 424 425 @Override 426 @ForceInline 427 public Long64Vector rearrange(VectorShuffle<Long> shuffle, 428 VectorMask<Long> m) { 429 return (Long64Vector) 430 super.rearrangeTemplate(Long64Shuffle.class, 431 (Long64Shuffle) shuffle, 432 (Long64Mask) m); // specialize 433 } 434 435 @Override 436 @ForceInline 437 public Long64Vector rearrange(VectorShuffle<Long> s, 438 Vector<Long> v) { 439 return (Long64Vector) 440 super.rearrangeTemplate(Long64Shuffle.class, 441 (Long64Shuffle) s, 442 (Long64Vector) v); // specialize 443 } 444 445 @Override 446 @ForceInline 447 public Long64Vector selectFrom(Vector<Long> v) { 448 return (Long64Vector) 449 super.selectFromTemplate((Long64Vector) v); // specialize 450 } 451 452 @Override 453 @ForceInline 454 public Long64Vector selectFrom(Vector<Long> v, 455 VectorMask<Long> m) { 456 return (Long64Vector) 457 super.selectFromTemplate((Long64Vector) v, 458 (Long64Mask) m); // specialize 459 } 460 461 462 @Override 463 public long lane(int i) { 464 if (i < 0 || i >= VLENGTH) { 465 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); 466 } 467 return (long) VectorIntrinsics.extract( 468 VCLASS, ETYPE, VLENGTH, 469 this, i, 470 (vec, ix) -> { 471 long[] vecarr = vec.vec(); 472 return (long)vecarr[ix]; 473 }); 474 } 475 476 @Override 477 public Long64Vector withLane(int i, long e) { 478 if (i < 0 || i >= VLENGTH) { 479 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); 480 } 481 return VectorIntrinsics.insert( 482 VCLASS, ETYPE, VLENGTH, 483 this, i, (long)e, 484 (v, ix, bits) -> { 485 long[] res = v.vec().clone(); 486 res[ix] = (long)bits; 487 return v.vectorFactory(res); 488 }); 489 } 490 491 // Mask 492 493 static final class Long64Mask extends AbstractMask<Long> { 494 495 private final boolean[] bits; // Don't access directly, use getBits() instead. 496 497 public Long64Mask(boolean[] bits) { 498 this(bits, 0); 499 } 500 501 public Long64Mask(boolean[] bits, int offset) { 502 boolean[] a = new boolean[vspecies().laneCount()]; 503 for (int i = 0; i < a.length; i++) { 504 a[i] = bits[offset + i]; 505 } 506 this.bits = a; 507 } 508 509 public Long64Mask(boolean val) { 510 boolean[] bits = new boolean[vspecies().laneCount()]; 511 Arrays.fill(bits, val); 512 this.bits = bits; 513 } 514 515 @ForceInline 516 final @Override 517 public LongSpecies vspecies() { 518 // ISSUE: This should probably be a @Stable 519 // field inside AbstractMask, rather than 520 // a megamorphic method. 521 return VSPECIES; 522 } 523 524 boolean[] getBits() { 525 return VectorIntrinsics.maybeRebox(this).bits; 526 } 527 528 @Override 529 Long64Mask uOp(MUnOp f) { 530 boolean[] res = new boolean[vspecies().laneCount()]; 531 boolean[] bits = getBits(); 532 for (int i = 0; i < res.length; i++) { 533 res[i] = f.apply(i, bits[i]); 534 } 535 return new Long64Mask(res); 536 } 537 538 @Override 539 Long64Mask bOp(VectorMask<Long> m, MBinOp f) { 540 boolean[] res = new boolean[vspecies().laneCount()]; 541 boolean[] bits = getBits(); 542 boolean[] mbits = ((Long64Mask)m).getBits(); 543 for (int i = 0; i < res.length; i++) { 544 res[i] = f.apply(i, bits[i], mbits[i]); 545 } 546 return new Long64Mask(res); 547 } 548 549 @ForceInline 550 @Override 551 public final 552 Long64Vector toVector() { 553 return (Long64Vector) super.toVectorTemplate(); // specialize 554 } 555 556 @Override 557 @ForceInline 558 public <E> VectorMask<E> cast(VectorSpecies<E> s) { 559 AbstractSpecies<E> species = (AbstractSpecies<E>) s; 560 if (length() != species.laneCount()) 561 throw new IllegalArgumentException("VectorMask length and species length differ"); 562 boolean[] maskArray = toArray(); 563 // enum-switches don't optimize properly JDK-8161245 564 switch (species.laneType.switchKey) { 565 case LaneType.SK_BYTE: 566 return new Byte64Vector.Byte64Mask(maskArray).check(species); 567 case LaneType.SK_SHORT: 568 return new Short64Vector.Short64Mask(maskArray).check(species); 569 case LaneType.SK_INT: 570 return new Int64Vector.Int64Mask(maskArray).check(species); 571 case LaneType.SK_LONG: 572 return new Long64Vector.Long64Mask(maskArray).check(species); 573 case LaneType.SK_FLOAT: 574 return new Float64Vector.Float64Mask(maskArray).check(species); 575 case LaneType.SK_DOUBLE: 576 return new Double64Vector.Double64Mask(maskArray).check(species); 577 } 578 579 // Should not reach here. 580 throw new AssertionError(species); 581 } 582 583 // Unary operations 584 585 @Override 586 @ForceInline 587 public Long64Mask not() { 588 return (Long64Mask) VectorIntrinsics.unaryOp( 589 VECTOR_OP_NOT, Long64Mask.class, long.class, VLENGTH, 590 this, 591 (m1) -> m1.uOp((i, a) -> !a)); 592 } 593 594 // Binary operations 595 596 @Override 597 @ForceInline 598 public Long64Mask and(VectorMask<Long> mask) { 599 Objects.requireNonNull(mask); 600 Long64Mask m = (Long64Mask)mask; 601 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Long64Mask.class, long.class, VLENGTH, 602 this, m, 603 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 604 } 605 606 @Override 607 @ForceInline 608 public Long64Mask or(VectorMask<Long> mask) { 609 Objects.requireNonNull(mask); 610 Long64Mask m = (Long64Mask)mask; 611 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Long64Mask.class, long.class, VLENGTH, 612 this, m, 613 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b)); 614 } 615 616 // Reductions 617 618 @Override 619 @ForceInline 620 public boolean anyTrue() { 621 return VectorIntrinsics.test(BT_ne, Long64Mask.class, long.class, VLENGTH, 622 this, this, 623 (m, __) -> anyTrueHelper(((Long64Mask)m).getBits())); 624 } 625 626 @Override 627 @ForceInline 628 public boolean allTrue() { 629 return VectorIntrinsics.test(BT_overflow, Long64Mask.class, long.class, VLENGTH, 630 this, vspecies().maskAll(true), 631 (m, __) -> allTrueHelper(((Long64Mask)m).getBits())); 632 } 633 634 /*package-private*/ 635 static Long64Mask maskAll(boolean bit) { 636 return bit ? TRUE_MASK : FALSE_MASK; 637 } 638 static final Long64Mask TRUE_MASK = new Long64Mask(true); 639 static final Long64Mask FALSE_MASK = new Long64Mask(false); 640 } 641 642 // Shuffle 643 644 static final class Long64Shuffle extends AbstractShuffle<Long> { 645 Long64Shuffle(byte[] reorder) { 646 super(reorder); 647 } 648 649 public Long64Shuffle(int[] reorder) { 650 super(reorder); 651 } 652 653 public Long64Shuffle(int[] reorder, int i) { 654 super(reorder, i); 655 } 656 657 public Long64Shuffle(IntUnaryOperator fn) { 658 super(fn); 659 } 660 661 @Override 662 public LongSpecies vspecies() { 663 return VSPECIES; 664 } 665 666 static { 667 // There must be enough bits in the shuffle lanes to encode 668 // VLENGTH valid indexes and VLENGTH exceptional ones. 669 assert(VLENGTH < Byte.MAX_VALUE); 670 assert(Byte.MIN_VALUE <= -VLENGTH); 671 } 672 static final Long64Shuffle IOTA = new Long64Shuffle(IDENTITY); 673 674 @Override 675 @ForceInline 676 public Long64Vector toVector() { 677 return VectorIntrinsics.shuffleToVector(VCLASS, ETYPE, Long64Shuffle.class, this, VLENGTH, 678 (s) -> ((Long64Vector)(((AbstractShuffle<Long>)(s)).toVectorTemplate()))); 679 } 680 681 @Override 682 @ForceInline 683 public <F> VectorShuffle<F> cast(VectorSpecies<F> s) { 684 AbstractSpecies<F> species = (AbstractSpecies<F>) s; 685 if (length() != species.laneCount()) 686 throw new IllegalArgumentException("VectorShuffle length and species length differ"); 687 int[] shuffleArray = toArray(); 688 // enum-switches don't optimize properly JDK-8161245 689 switch (species.laneType.switchKey) { 690 case LaneType.SK_BYTE: 691 return new Byte64Vector.Byte64Shuffle(shuffleArray).check(species); 692 case LaneType.SK_SHORT: 693 return new Short64Vector.Short64Shuffle(shuffleArray).check(species); 694 case LaneType.SK_INT: 695 return new Int64Vector.Int64Shuffle(shuffleArray).check(species); 696 case LaneType.SK_LONG: 697 return new Long64Vector.Long64Shuffle(shuffleArray).check(species); 698 case LaneType.SK_FLOAT: 699 return new Float64Vector.Float64Shuffle(shuffleArray).check(species); 700 case LaneType.SK_DOUBLE: 701 return new Double64Vector.Double64Shuffle(shuffleArray).check(species); 702 } 703 704 // Should not reach here. 705 throw new AssertionError(species); 706 } 707 708 @Override 709 public Long64Shuffle rearrange(VectorShuffle<Long> shuffle) { 710 Long64Shuffle s = (Long64Shuffle) shuffle; 711 byte[] r = new byte[reorder.length]; 712 for (int i = 0; i < reorder.length; i++) { 713 int ssi = s.reorder[i]; 714 r[i] = this.reorder[ssi]; // throws on exceptional index 715 } 716 return new Long64Shuffle(r); 717 } 718 } 719 720 // ================================================ 721 722 // Specialized low-level memory operations. 723 724 @ForceInline 725 @Override 726 final 727 LongVector fromArray0(long[] a, int offset) { 728 return super.fromArray0Template(a, offset); // specialize 729 } 730 731 @ForceInline 732 @Override 733 final 734 LongVector fromByteArray0(byte[] a, int offset) { 735 return super.fromByteArray0Template(a, offset); // specialize 736 } 737 738 @ForceInline 739 @Override 740 final 741 LongVector fromByteBuffer0(ByteBuffer bb, int offset) { 742 return super.fromByteBuffer0Template(bb, offset); // specialize 743 } 744 745 @ForceInline 746 @Override 747 final 748 void intoArray0(long[] a, int offset) { 749 super.intoArray0Template(a, offset); // specialize 750 } 751 752 @ForceInline 753 @Override 754 final 755 void intoByteArray0(byte[] a, int offset) { 756 super.intoByteArray0Template(a, offset); // specialize 757 } 758 759 // End of specialized low-level memory operations. 760 761 // ================================================ 762 763 }