< prev index next >
src/jdk.incubator.vector/share/classes/jdk/incubator/vector/VectorIntrinsics.java
Print this page
@@ -85,18 +85,18 @@
static final int BT_overflow = 2;
static final int BT_no_overflow = 6;
/* ============================================================================ */
interface BroadcastOperation<V, E> {
- V broadcast(long l, Vector.Species<E> s);
+ V broadcast(long l, Species<E> s);
}
@HotSpotIntrinsicCandidate
static
<VM, E>
VM broadcastCoerced(Class<VM> vmClass, Class<?> E, int length,
- long bits, Vector.Species<E> s,
+ long bits, Species<E> s,
BroadcastOperation<VM, E> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.broadcast(bits, s);
}
@@ -147,11 +147,11 @@
@HotSpotIntrinsicCandidate
static
<VM>
VM unaryOp(int oprId, Class<VM> vmClass, Class<?> elementType, int length,
- VM vm, /*Vector.Mask<E,S> m,*/
+ VM vm, /*Mask<E,S> m,*/
Function<VM, VM> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.apply(vm);
}
@@ -159,11 +159,11 @@
@HotSpotIntrinsicCandidate
static
<VM>
VM binaryOp(int oprId, Class<? extends VM> vmClass, Class<?> elementType, int length,
- VM vm1, VM vm2, /*Vector.Mask<E,S> m,*/
+ VM vm1, VM vm2, /*Mask<E,S> m,*/
BiFunction<VM, VM, VM> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.apply(vm1, vm2);
}
@@ -175,49 +175,49 @@
@HotSpotIntrinsicCandidate
static
<VM>
VM ternaryOp(int oprId, Class<VM> vmClass, Class<?> elementType, int length,
- VM vm1, VM vm2, VM vm3, /*Vector.Mask<E,S> m,*/
+ VM vm1, VM vm2, VM vm3, /*Mask<E,S> m,*/
TernaryOperation<VM> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.apply(vm1, vm2, vm3);
}
/* ============================================================================ */
// Memory operations
interface LoadOperation<C, V, E> {
- V load(C container, int index, Vector.Species<E> s);
+ V load(C container, int index, Species<E> s);
}
@HotSpotIntrinsicCandidate
static
<C, VM, E>
VM load(Class<VM> vmClass, Class<?> E, int length,
Object base, long offset, // Unsafe addressing
- // Vector.Mask<E,S> m,
- C container, int index, Vector.Species<E> s, // Arguments for default implementation
+ // Mask<E,S> m,
+ C container, int index, Species<E> s, // Arguments for default implementation
LoadOperation<C, VM, E> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.load(container, index, s);
}
/* ============================================================================ */
interface LoadVectorOperationWithMap<C, V extends Vector<?>, E> {
- V loadWithMap(C container, int index, int[] indexMap, int indexM, Vector.Species<E> s);
+ V loadWithMap(C container, int index, int[] indexMap, int indexM, Species<E> s);
}
@HotSpotIntrinsicCandidate
static
<C, V extends Vector<?>, W extends IntVector, E>
V loadWithMap(Class<?> vectorClass, Class<?> E, int length, Class<?> vectorIndexClass,
Object base, long offset, // Unsafe addressing
W index_vector,
- C container, int index, int[] indexMap, int indexM, Vector.Species<E> s, // Arguments for default implementation
+ C container, int index, int[] indexMap, int indexM, Species<E> s, // Arguments for default implementation
LoadVectorOperationWithMap<C, V, E> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
return defaultImpl.loadWithMap(container, index, indexMap, indexM, s);
}
@@ -231,11 +231,11 @@
static
<C, V extends Vector<?>>
void store(Class<?> vectorClass, Class<?> elementType, int length,
Object base, long offset, // Unsafe addressing
V v,
- // Vector.Mask<E,S> m,
+ // Mask<E,S> m,
C container, int index, // Arguments for default implementation
StoreVectorOperation<C, V> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
defaultImpl.store(container, index, v);
}
@@ -276,11 +276,11 @@
M apply(V v1, V v2);
}
@HotSpotIntrinsicCandidate
static <V extends Vector<E>,
- M extends Vector.Mask<E>,
+ M extends Mask<E>,
E>
M compare(int cond, Class<V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
V v1, V v2,
VectorCompareOp<V,M> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
@@ -288,19 +288,19 @@
}
/* ============================================================================ */
interface VectorRearrangeOp<V extends Vector<E>,
- Sh extends Vector.Shuffle<E>,
+ Sh extends Shuffle<E>,
E> {
V apply(V v1, Sh shuffle);
}
@HotSpotIntrinsicCandidate
static
<V extends Vector<E>,
- Sh extends Vector.Shuffle<E>,
+ Sh extends Shuffle<E>,
E>
V rearrangeOp(Class<V> vectorClass, Class<Sh> shuffleClass, Class<?> elementType, int vlen,
V v1, Sh sh,
VectorRearrangeOp<V,Sh, E> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
@@ -308,19 +308,19 @@
}
/* ============================================================================ */
interface VectorBlendOp<V extends Vector<E>,
- M extends Vector.Mask<E>,
+ M extends Mask<E>,
E> {
V apply(V v1, V v2, M mask);
}
@HotSpotIntrinsicCandidate
static
<V extends Vector<E>,
- M extends Vector.Mask<E>,
+ M extends Mask<E>,
E>
V blend(Class<V> vectorClass, Class<M> maskClass, Class<?> elementType, int length,
V v1, V v2, M m,
VectorBlendOp<V,M, E> defaultImpl) {
assert isNonCapturingLambda(defaultImpl) : defaultImpl;
< prev index next >