diff options
Diffstat (limited to 'src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java')
| -rw-r--r-- | src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java | 214 |
1 files changed, 179 insertions, 35 deletions
diff --git a/src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java b/src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java index 4bb96aae..0437cdfe 100644 --- a/src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java +++ b/src/jdk/nashorn/internal/runtime/arrays/LongArrayData.java @@ -25,6 +25,10 @@ package jdk.nashorn.internal.runtime.arrays; +import static jdk.nashorn.internal.codegen.CompilerConstants.specialCall; +import static jdk.nashorn.internal.lookup.Lookup.MH; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; import java.util.Arrays; import jdk.nashorn.internal.runtime.JSType; import jdk.nashorn.internal.runtime.ScriptRuntime; @@ -33,7 +37,7 @@ import jdk.nashorn.internal.runtime.ScriptRuntime; * Implementation of {@link ArrayData} as soon as a long has been * written to the array */ -final class LongArrayData extends ArrayData { +final class LongArrayData extends ContinuousArrayData implements IntOrLongElements { /** * The wrapped array */ @@ -47,24 +51,45 @@ final class LongArrayData extends ArrayData { LongArrayData(final long array[], final int length) { super(length); assert array.length >= length; - this.array = array; + this.array = array; } @Override - public ArrayData copy() { - return new LongArrayData(array.clone(), (int) length()); + public final Class<?> getElementType() { + return long.class; + } + + @Override + public final Class<?> getBoxedElementType() { + return Long.class; + } + + @Override + public final ContinuousArrayData widest(final ContinuousArrayData otherData) { + return otherData instanceof IntElements ? this : otherData; + } + + @Override + public final int getElementWeight() { + return 2; + } + + @Override + public LongArrayData copy() { + return new LongArrayData(array.clone(), (int)length()); } @Override public Object[] asObjectArray() { - return toObjectArray(array, (int) length()); + return toObjectArray(true); } - private static Object[] toObjectArray(final long[] array, final int length) { - assert length <= array.length : "length exceeds internal array size"; - final Object[] oarray = new Object[array.length]; + private Object[] toObjectArray(final boolean trim) { + assert length() <= array.length : "length exceeds internal array size"; + final int len = (int)length(); + final Object[] oarray = new Object[trim ? len : array.length]; - for (int index = 0; index < length; index++) { + for (int index = 0; index < len; index++) { oarray[index] = Long.valueOf(array[index]); } @@ -73,17 +98,19 @@ final class LongArrayData extends ArrayData { @Override public Object asArrayOfType(final Class<?> componentType) { - if(componentType == long.class) { - return array.length == length() ? array.clone() : Arrays.copyOf(array, (int) length()); + if (componentType == long.class) { + final int len = (int)length(); + return array.length == len ? array.clone() : Arrays.copyOf(array, len); } return super.asArrayOfType(componentType); } - private static double[] toDoubleArray(final long[] array, final int length) { - assert length <= array.length : "length exceeds internal array size"; + private double[] toDoubleArray() { + assert length() <= array.length : "length exceeds internal array size"; + final int len = (int)length(); final double[] darray = new double[array.length]; - for (int index = 0; index < length; index++) { + for (int index = 0; index < len; index++) { darray[index] = array[index]; } @@ -91,15 +118,15 @@ final class LongArrayData extends ArrayData { } @Override - public ArrayData convert(final Class<?> type) { + public ContinuousArrayData convert(final Class<?> type) { if (type == Integer.class || type == Long.class) { return this; } - final int length = (int) length(); + final int len = (int)length(); if (type == Double.class) { - return new NumberArrayData(LongArrayData.toDoubleArray(array, length), length); + return new NumberArrayData(toDoubleArray(), len); } - return new ObjectArrayData(LongArrayData.toObjectArray(array, length), length); + return new ObjectArrayData(toObjectArray(false), len); } @Override @@ -121,29 +148,21 @@ final class LongArrayData extends ArrayData { @Override public ArrayData ensure(final long safeIndex) { - if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= array.length) { + if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH) { return new SparseArrayData(this, safeIndex + 1); } - - int newLength = array.length; - - while (newLength <= safeIndex) { - newLength = ArrayData.nextSize(newLength); - } - - if (array.length <= safeIndex) { + final int alen = array.length; + if (safeIndex >= alen) { + final int newLength = ArrayData.nextSize((int)safeIndex); array = Arrays.copyOf(array, newLength); } - setLength(safeIndex + 1); - return this; } @Override public ArrayData shrink(final long newLength) { - Arrays.fill(array, (int) newLength, array.length, 0); - + Arrays.fill(array, (int)newLength, array.length, 0L); return this; } @@ -183,6 +202,39 @@ final class LongArrayData extends ArrayData { return convert(Double.class).set(index, value, strict); } + private static final MethodHandle HAS_GET_ELEM = specialCall(MethodHandles.lookup(), LongArrayData.class, "getElem", long.class, int.class).methodHandle(); + private static final MethodHandle SET_ELEM = specialCall(MethodHandles.lookup(), LongArrayData.class, "setElem", void.class, int.class, long.class).methodHandle(); + + @SuppressWarnings("unused") + private long getElem(final int index) { + if (has(index)) { + return array[index]; + } + throw new ClassCastException(); + } + + @SuppressWarnings("unused") + private void setElem(final int index, final long elem) { + if (hasRoomFor(index)) { + array[index] = elem; + return; + } + throw new ClassCastException(); + } + + @Override + public MethodHandle getElementGetter(final Class<?> returnType, final int programPoint) { + if (returnType == int.class) { + return null; + } + return getContinuousElementGetter(HAS_GET_ELEM, returnType, programPoint); + } + + @Override + public MethodHandle getElementSetter(final Class<?> elementType) { + return elementType == int.class || elementType == long.class ? getContinuousElementSetter(MH.asType(SET_ELEM, SET_ELEM.type().changeParameterType(2, elementType)), elementType) : null; + } + @Override public int getInt(final int index) { return (int)array[index]; @@ -194,11 +246,21 @@ final class LongArrayData extends ArrayData { } @Override + public long getLongOptimistic(final int index, final int programPoint) { + return array[index]; + } + + @Override public double getDouble(final int index) { return array[index]; } @Override + public double getDoubleOptimistic(final int index, final int programPoint) { + return array[index]; + } + + @Override public Object getObject(final int index) { return array[index]; } @@ -220,11 +282,12 @@ final class LongArrayData extends ArrayData { @Override public Object pop() { - if (length() == 0) { + final int len = (int)length(); + if (len == 0) { return ScriptRuntime.UNDEFINED; } - final int newLength = (int) (length() - 1); + final int newLength = len - 1; final long elem = array[newLength]; array[newLength] = 0; setLength(newLength); @@ -234,19 +297,30 @@ final class LongArrayData extends ArrayData { @Override public ArrayData slice(final long from, final long to) { - final long start = from < 0 ? (from + length()) : from; + final long start = from < 0 ? from + length() : from; final long newLength = to - start; return new LongArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength); } @Override + public final ArrayData push(final boolean strict, final long item) { + final long len = length(); + final ArrayData newData = ensure(len); + if (newData == this) { + array[(int)len] = item; + return this; + } + return newData.set((int)len, item, strict); + } + + @Override public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException { final long oldLength = length(); final long newLength = oldLength - removed + added; if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) { throw new UnsupportedOperationException(); } - final ArrayData returnValue = (removed == 0) ? + final ArrayData returnValue = removed == 0 ? EMPTY_ARRAY : new LongArrayData(Arrays.copyOfRange(array, start, start + removed), removed); if (newLength != oldLength) { @@ -266,4 +340,74 @@ final class LongArrayData extends ArrayData { return returnValue; } + + @Override + public long fastPush(final int arg) { + return fastPush((long)arg); + } + + @Override + public long fastPush(final long arg) { + final int len = (int)length(); + if (len == array.length) { + array = Arrays.copyOf(array, nextSize(len)); + } + array[len] = arg; + return increaseLength(); + } + + @Override + public long fastPopLong() { + if (length() == 0) { + throw new ClassCastException(); //undefined result + } + final int newLength = (int)decreaseLength(); + final long elem = array[newLength]; + array[newLength] = 0; + return elem; + } + + @Override + public double fastPopDouble() { + return fastPopLong(); + } + + @Override + public Object fastPopObject() { + return fastPopLong(); + } + + @Override + public ContinuousArrayData fastConcat(final ContinuousArrayData otherData) { + final int otherLength = (int)otherData.length(); + final int thisLength = (int)length(); + assert otherLength > 0 && thisLength > 0; + + final long[] otherArray = ((LongArrayData)otherData).array; + final int newLength = otherLength + thisLength; + final long[] newArray = new long[ArrayData.alignUp(newLength)]; + + System.arraycopy(array, 0, newArray, 0, thisLength); + System.arraycopy(otherArray, 0, newArray, thisLength, otherLength); + + return new LongArrayData(newArray, newLength); + } + + @Override + public String toString() { + assert length() <= array.length : length() + " > " + array.length; + + final StringBuilder sb = new StringBuilder(getClass().getSimpleName()). + append(": ["); + final int len = (int)length(); + for (int i = 0; i < len; i++) { + sb.append(array[i]).append('L'); //make sure L suffix is on elements, to discriminate this from IntArrayData.toString() + if (i + 1 < len) { + sb.append(", "); + } + } + sb.append(']'); + + return sb.toString(); + } } |