/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.nashorn.internal.runtime.arrays;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCall;
import static jdk.nashorn.internal.lookup.Lookup.MH;
import static jdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex;
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.SwitchPoint;
import jdk.dynalink.CallSiteDescriptor;
import jdk.dynalink.linker.GuardedInvocation;
import jdk.dynalink.linker.LinkRequest;
import jdk.nashorn.internal.codegen.types.Type;
import jdk.nashorn.internal.lookup.Lookup;
import jdk.nashorn.internal.runtime.ScriptObject;
import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
import jdk.nashorn.internal.runtime.logging.Logger;
/**
* Interface implemented by all arrays that are directly accessible as underlying
* native arrays
*/
@Logger(name="arrays")
public abstract class ContinuousArrayData extends ArrayData {
/**
* Constructor
* @param length length (elementLength)
*/
protected ContinuousArrayData(final long length) {
super(length);
}
/**
* Check if we can put one more element at the end of this continuous
* array without reallocating, or if we are overwriting an already
* allocated element
*
* @param index index to check
* @return true if we don't need to do any array reallocation to fit an element at index
*/
public final boolean hasRoomFor(final int index) {
return has(index) || (index == length() && ensure(index) == this);
}
/**
* Check if an arraydata is empty
* @return true if empty
*/
public boolean isEmpty() {
return length() == 0L;
}
/**
* Return element getter for a certain type at a certain program point
* @param returnType return type
* @param programPoint program point
* @return element getter or null if not supported (used to implement slow linkage instead
* as fast isn't possible)
*/
public abstract MethodHandle getElementGetter(final Class<?> returnType, final int programPoint);
/**
* Return element getter for a certain type at a certain program point
* @param elementType element type
* @return element setter or null if not supported (used to implement slow linkage instead
* as fast isn't possible)
*/
public abstract MethodHandle getElementSetter(final Class<?> elementType);
/**
* Version of has that throws a class cast exception if element does not exist
* used for relinking
*
* @param index index to check - currently only int indexes
* @return index
*/
protected final int throwHas(final int index) {
if (!has(index)) {
throw new ClassCastException();
}
return index;
}
@Override
public abstract ContinuousArrayData copy();
/**
* Returns the type used to store an element in this array
* @return element type
*/
public abstract Class<?> getElementType();
@Override
public Type getOptimisticType() {
return Type.typeFor(getElementType());
}
/**
* Returns the boxed type of the type used to store an element in this array
* @return element type
*/
public abstract Class<?> getBoxedElementType();
/**
* Get the widest element type of two arrays. This can be done faster in subclasses, but
* this works for all ContinuousArrayDatas and for where more optimal checks haven't been
* implemented.
*
* @param otherData another ContinuousArrayData
* @return the widest boxed element type
*/
public ContinuousArrayData widest(final ContinuousArrayData otherData) {
final Class<?> elementType = getElementType();
return Type.widest(elementType, otherData.getElementType()) == elementType ? this : otherData;
}
/**
* Look up a continuous array element getter
* @param get getter, sometimes combined with a has check that throws CCE on failure for relink
* @param returnType return type
* @param programPoint program point
* @return array getter
*/
protected final MethodHandle getContinuousElementGetter(final MethodHandle get, final Class<?> returnType, final int programPoint) {
return getContinuousElementGetter(getClass(), get, returnType, programPoint);
}
/**
* Look up a continuous array element setter
* @param set setter, sometimes combined with a has check that throws CCE on failure for relink
* @param returnType return type
* @return array setter
*/
protected final MethodHandle getContinuousElementSetter(final MethodHandle set, final Class<?> returnType) {
return getContinuousElementSetter(getClass(), set, returnType);
}
/**
* Return element getter for a {@link ContinuousArrayData}
* @param clazz clazz for exact type guard
* @param getHas has getter
* @param returnType return type
* @param programPoint program point
* @return method handle for element setter
*/
protected MethodHandle getContinuousElementGetter(final Class<? extends ContinuousArrayData> clazz, final MethodHandle getHas, final Class<?> returnType, final int programPoint) {
final boolean isOptimistic = isValid(programPoint);
final int fti = getAccessorTypeIndex(getHas.type().returnType());
final int ti = getAccessorTypeIndex(returnType);
MethodHandle mh = getHas;
if (isOptimistic) {
if (ti < fti) {
mh = MH.insertArguments(ArrayData.THROW_UNWARRANTED.methodHandle(), 1, programPoint);
}
}
mh = MH.asType(mh, mh.type().changeReturnType(returnType).changeParameterType(0, clazz));
if (!isOptimistic) {
//for example a & array[17];
return Lookup.filterReturnType(mh, returnType);
}
return mh;
}
/**
* Return element setter for a {@link ContinuousArrayData}
* @param clazz class for exact type guard
* @param setHas set has guard
* @param elementType element type
* @return method handle for element setter
*/
protected MethodHandle getContinuousElementSetter(final Class<? extends ContinuousArrayData> clazz, final MethodHandle setHas, final Class<?> elementType) {
return MH.asType(setHas, setHas.type().changeParameterType(2, elementType).changeParameterType(0, clazz));
}
/** Fast access guard - it is impractical for JIT performance reasons to use only CCE asType as guard :-(, also we need
the null case explicitly, which is the one that CCE doesn't handle */
protected static final MethodHandle FAST_ACCESS_GUARD =
MH.dropArguments(
staticCall(
MethodHandles.lookup(),
ContinuousArrayData.class,
"guard",
boolean.class,
Class.class,
ScriptObject.class).methodHandle(),
2,
int.class);
@SuppressWarnings("unused")
private static boolean guard(final Class<? extends ContinuousArrayData> clazz, final ScriptObject sobj) {
return sobj != null && sobj.getArray().getClass() == clazz;
}
/**
* Return a fast linked array getter, or null if we have to dispatch to super class
* @param desc descriptor
* @param request link request
* @return invocation or null if needs to be sent to slow relink
*/
@Override
public GuardedInvocation findFastGetIndexMethod(final Class<? extends ArrayData> clazz, final CallSiteDescriptor desc, final LinkRequest request) {
final MethodType callType = desc.getMethodType();
final Class<?> indexType = callType.parameterType(1);
final Class<?> returnType = callType.returnType();
if (ContinuousArrayData.class.isAssignableFrom(clazz) && indexType == int.class) {
final Object[] args = request.getArguments();
final int index = (int)args[args.length - 1];
if (has(index)) {
final MethodHandle getArray = ScriptObject.GET_ARRAY.methodHandle();
final int programPoint = NashornCallSiteDescriptor.isOptimistic(desc) ? NashornCallSiteDescriptor.getProgramPoint(desc) : INVALID_PROGRAM_POINT;
MethodHandle getElement = getElementGetter(returnType, programPoint);
if (getElement != null) {
getElement = MH.filterArguments(getElement, 0, MH.asType(getArray, getArray.type().changeReturnType(clazz)));
final MethodHandle guard = MH.insertArguments(FAST_ACCESS_GUARD, 0, clazz);
return new GuardedInvocation(getElement, guard, (SwitchPoint)null, ClassCastException.class);
}
}
}
return null;
}
/**
* Return a fast linked array setter, or null if we have to dispatch to super class
* @param desc descriptor
* @param request link request
* @return invocation or null if needs to be sent to slow relink
*/
@Override
public GuardedInvocation findFastSetIndexMethod(final Class<? extends ArrayData> clazz, final CallSiteDescriptor desc, final LinkRequest request) { // array, index, value
final MethodType callType = desc.getMethodType();
final Class<?> indexType = callType.parameterType(1);
final Class<?> elementType = callType.parameterType(2);
if (ContinuousArrayData.class.isAssignableFrom(clazz) && indexType == int.class) {
final Object[] args = request.getArguments();
final int index = (int)args[args.length - 2];
if (hasRoomFor(index)) {
MethodHandle setElement = getElementSetter(elementType); //Z(continuousarraydata, int, int), return true if successful
if (setElement != null) {
//else we are dealing with a wider type than supported by this callsite
MethodHandle getArray = ScriptObject.GET_ARRAY.methodHandle();
getArray = MH.asType(getArray, getArray.type().changeReturnType(getClass()));
setElement = MH.filterArguments(setElement, 0, getArray);
final MethodHandle guard = MH.insertArguments(FAST_ACCESS_GUARD, 0, clazz);
return new GuardedInvocation(setElement, guard, (SwitchPoint)null, ClassCastException.class); //CCE if not a scriptObject anymore
}
}
}
return null;
}
/**
* Specialization - fast push implementation
* @param arg argument
* @return new array length
*/
public double fastPush(final int arg) {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast push implementation
* @param arg argument
* @return new array length
*/
public double fastPush(final long arg) {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast push implementation
* @param arg argument
* @return new array length
*/
public double fastPush(final double arg) {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast push implementation
* @param arg argument
* @return new array length
*/
public double fastPush(final Object arg) {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast pop implementation
* @return element value
*/
public int fastPopInt() {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast pop implementation
* @return element value
*/
public double fastPopDouble() {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast pop implementation
* @return element value
*/
public Object fastPopObject() {
throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
}
/**
* Specialization - fast concat implementation
* @param otherData data to concat
* @return new arraydata
*/
public ContinuousArrayData fastConcat(final ContinuousArrayData otherData) {
throw new ClassCastException(String.valueOf(getClass()) + " != " + String.valueOf(otherData.getClass()));
}
}