android-12.1.0_r1/s

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package dalvik.system;

import java.lang.invoke.MethodType;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

/**
 * Provides typed (read-only) access to method arguments and a slot to store a return value.
 *
 * Used to implement method handle transforms. See {@link java.lang.invoke.Transformers}.
 *
 * @hide
 */
public class EmulatedStackFrame {
    /**
     * The type of this stack frame, i.e, the types of its arguments and the type of its
     * return value.
     */
    private final MethodType type;

    /**
     * The type of the callsite that produced this stack frame. This contains the types of
     * the original arguments, before any conversions etc. were performed.
     */
    private final MethodType callsiteType;

    /**
     * All reference arguments and reference return values that belong to this argument array.
     *
     * If the return type is a reference, it will be the last element of this array.
     */
    private final Object[] references;

    /**
     * Contains all primitive values on the stack. Primitive values always take 4 or 8 bytes of
     * space and all {@code short}, {@code char} and {@code boolean} arguments are promoted to ints.
     *
     * Reference values do not appear on the stack frame but they appear (in order)
     * in the {@code references} array. No additional slots or space for reference arguments or
     * return values are reserved in the stackFrame.
     *
     * By convention, if the return value is a primitive, it will occupy the last 4 or 8 bytes
     * of the stack frame, depending on the type.
     *
     * The size of this array is known at the time of creation of this {@code EmulatedStackFrame}
     * and is determined by the {@code MethodType} of the frame.
     *
     * Example :
     * <pre>
     *     Function : String foo(String a, String b, int c, long d) { }
     *
     *     EmulatedStackFrame :
     *     references = { a, b, [return_value] }
     *     stackFrame = { c0, c1, c2, c3, d0, d1, d2, d3, d4, d5, d6, d7 }
     *
     *     Function : int foo(String a)
     *
     *     EmulatedStackFrame :
     *     references = { a }
     *     stackFrame = { rv0, rv1, rv2, rv3 }  // rv is the return value.
     *
     * </pre>
     *
     */
    private final byte[] stackFrame;

    private EmulatedStackFrame(MethodType type, MethodType callsiteType, Object[] references,
                               byte[] stackFrame) {
        this.type = type;
        this.callsiteType = callsiteType;
        this.references = references;
        this.stackFrame = stackFrame;
    }

    /**
     * Returns the {@code MethodType} that the frame was created for.
     */
    public final MethodType getMethodType() { return type; }

    /**
     * Returns the {@code MethodType} corresponding to the callsite of the
     */
    public final MethodType getCallsiteType() { return callsiteType; }

    /**
     * Represents a range of arguments on an {@code EmulatedStackFrame}.
     *
     * @hide
     */
    public static final class Range {
        public final int referencesStart;
        public final int numReferences;

        public final int stackFrameStart;
        public final int numBytes;

        private Range(int referencesStart, int numReferences, int stackFrameStart, int numBytes) {
            this.referencesStart = referencesStart;
            this.numReferences = numReferences;
            this.stackFrameStart = stackFrameStart;
            this.numBytes = numBytes;
        }

        public static Range all(MethodType frameType) {
            return of(frameType, 0, frameType.parameterCount());
        }

        public static Range of(MethodType frameType, int startArg, int endArg) {
            final Class<?>[] ptypes = frameType.ptypes();

            int referencesStart = 0;
            int numReferences = 0;
            int stackFrameStart = 0;
            int numBytes = 0;

            for (int i = 0; i < startArg; ++i) {
                Class<?> cl = ptypes[i];
                if (!cl.isPrimitive()) {
                    referencesStart++;
                } else {
                    stackFrameStart += getSize(cl);
                }
            }

            for (int i = startArg; i < endArg; ++i) {
                Class<?> cl = ptypes[i];
                if (!cl.isPrimitive()) {
                    numReferences++;
                } else {
                    numBytes += getSize(cl);
                }
            }

            return new Range(referencesStart, numReferences, stackFrameStart, numBytes);
        }
    }

    /**
     * Creates an emulated stack frame for a given {@code MethodType}.
     */
    public static EmulatedStackFrame create(MethodType frameType) {
        int numRefs = 0;
        int frameSize = 0;
        for (Class<?> ptype : frameType.ptypes()) {
            if (!ptype.isPrimitive()) {
                numRefs++;
            } else {
                frameSize += getSize(ptype);
            }
        }

        final Class<?> rtype = frameType.rtype();
        if (!rtype.isPrimitive()) {
            numRefs++;
        } else {
            frameSize += getSize(rtype);
        }

        return new EmulatedStackFrame(frameType, frameType, new Object[numRefs],
                new byte[frameSize]);
    }

    /**
     * Sets the {@code idx} to {@code reference}. Type checks are performed.
     */
    public void setReference(int idx, Object reference) {
        final Class<?>[] ptypes = type.ptypes();
        if (idx < 0 || idx >= ptypes.length) {
            throw new IllegalArgumentException("Invalid index: " + idx);
        }

        if (reference != null && !ptypes[idx].isInstance(reference)) {
            throw new IllegalStateException("reference is not of type: " + type.ptypes()[idx]);
        }

        references[idx] = reference;
    }

    /**
     * Gets the reference at {@code idx}, checking that it's of type {@code referenceType}.
     */
    public <T> T getReference(int idx, Class<T> referenceType) {
        if (referenceType != type.ptypes()[idx]) {
            throw new IllegalArgumentException("Argument: " + idx +
                    " is of type " + type.ptypes()[idx] + " expected " + referenceType + "");
        }

        return (T) references[idx];
    }

    /**
     * Copies a specified range of arguments, given by {@code fromRange} to a specified
     * EmulatedStackFrame {@code other}, with references starting at {@code referencesStart}
     * and primitives starting at {@code primitivesStart}.
     */
    public void copyRangeTo(EmulatedStackFrame other, Range fromRange, int referencesStart,
                            int primitivesStart) {
        if (fromRange.numReferences > 0) {
            System.arraycopy(references, fromRange.referencesStart,
                    other.references, referencesStart, fromRange.numReferences);
        }

        if (fromRange.numBytes > 0) {
            System.arraycopy(stackFrame, fromRange.stackFrameStart,
                    other.stackFrame, primitivesStart, fromRange.numBytes);
        }
    }

    /**
     * Copies the return value from this stack frame to {@code other}.
     */
    public void copyReturnValueTo(EmulatedStackFrame other) {
        final Class<?> returnType = type.returnType();
        if (!returnType.isPrimitive()) {
            other.references[other.references.length - 1] = references[references.length - 1];
        } else if (!is64BitPrimitive(returnType)) {
            System.arraycopy(stackFrame, stackFrame.length - 4,
                    other.stackFrame, other.stackFrame.length - 4, 4);
        } else {
            System.arraycopy(stackFrame, stackFrame.length - 8,
                    other.stackFrame, other.stackFrame.length - 8, 8);
        }
    }

    public void setReturnValueTo(Object reference) {
        final Class<?> returnType = type.returnType();
        if (returnType.isPrimitive()) {
            throw new IllegalStateException("return type is not a reference type: " + returnType);
        }

        if (reference != null && !returnType.isInstance(reference)) {
            throw new IllegalArgumentException("reference is not of type " + returnType);
        }

        references[references.length - 1] = reference;
    }

    /**
     * Returns true iff. the input {@code type} needs 64 bits (8 bytes) of storage on an
     * {@code EmulatedStackFrame}.
     */
    private static boolean is64BitPrimitive(Class<?> type) {
        return type == double.class || type == long.class;
    }

    /**
     * Returns the size (in bytes) occupied by a given primitive type on an
     * {@code EmulatedStackFrame}.
     */
    public static int getSize(Class<?> type) {
        if (!type.isPrimitive()) {
            throw new IllegalArgumentException("type.isPrimitive() == false: " + type);
        }

        if (is64BitPrimitive(type)) {
            return 8;
        } else {
            return 4;
        }
    }

    /**
     * Base class for readers and writers to stack frames.
     *
     * @hide
     */
    public static class StackFrameAccessor {
        /**
         * The current offset into the references array.
         */
        protected int referencesOffset;

        /**
         * The index of the current argument being processed. For a function of arity N,
         * values [0, N) correspond to input arguments, and the special index {@code -2}
         * maps to the return value. All other indices are invalid.
         */
        protected int argumentIdx;

        /**
         * Wrapper for {@code EmulatedStackFrame.this.stackFrame}.
         */
        protected ByteBuffer frameBuf;

        /**
         * The number of arguments that this stack frame expects.
         */
        private int numArgs;

        /**
         * The stack frame we're currently accessing.
         */
        protected EmulatedStackFrame frame;

        /**
         * The value of {@code argumentIdx} when this accessor's cursor is pointing to the
         * frame's return value.
         */
        private static final int RETURN_VALUE_IDX = -2;

        protected StackFrameAccessor() {
            referencesOffset = 0;
            argumentIdx = 0;

            frameBuf = null;
            numArgs = 0;
        }

        /**
         * Attaches this accessor to a given {@code EmulatedStackFrame} to read or write
         * values to it. Also resets all state associated with the current accessor.
         */
        public StackFrameAccessor attach(EmulatedStackFrame stackFrame) {
            return attach(stackFrame, 0 /* argumentIdx */, 0 /* referencesOffset */,
                    0 /* frameOffset */);
        }

        public StackFrameAccessor attach(EmulatedStackFrame stackFrame, int argumentIdx,
                                         int referencesOffset, int frameOffset) {
            frame = stackFrame;
            frameBuf = ByteBuffer.wrap(frame.stackFrame).order(ByteOrder.LITTLE_ENDIAN);
            numArgs = frame.type.ptypes().length;
            if (frameOffset != 0) {
                frameBuf.position(frameOffset);
            }

            this.referencesOffset = referencesOffset;
            this.argumentIdx = argumentIdx;

            return this;
        }

        private Class<?> getCurrentArgumentType() {
            if (argumentIdx >= numArgs || argumentIdx == (RETURN_VALUE_IDX + 1)) {
                throw new IllegalArgumentException("Invalid argument index: " + argumentIdx);
            }
            return (argumentIdx == RETURN_VALUE_IDX) ?
                    frame.type.rtype() : frame.type.ptypes()[argumentIdx];
        }

        private static void checkAssignable(Class<?> expectedType, Class<?> actualType) {
            if (!expectedType.isAssignableFrom(actualType)) {
                throw new IllegalArgumentException("Incorrect type: " + actualType
                                                   + ", expected: " + expectedType);
            }
        }

        protected void checkWriteType(Class<?> type) {
            checkAssignable(getCurrentArgumentType(), type);
        }

        protected void checkReadType(Class<?> expectedType) {
            checkAssignable(expectedType, getCurrentArgumentType());
        }

        /**
         * Positions the cursor at the return value location, either in the references array
         * or in the stack frame array. The next put* or next* call will result in a read or
         * write to the return value.
         */
        public void makeReturnValueAccessor() {
            Class<?> rtype = frame.type.rtype();
            argumentIdx = RETURN_VALUE_IDX;

            // Position the cursor appropriately. The return value is either the last element
            // of the references array, or the last 4 or 8 bytes of the stack frame.
            if (rtype.isPrimitive()) {
                frameBuf.position(frameBuf.capacity() - getSize(rtype));
            } else {
                referencesOffset = frame.references.length - 1;
            }
        }

        public static void copyNext(StackFrameReader reader, StackFrameWriter writer,
                                    Class<?> type) {
            if (!type.isPrimitive()) {
                writer.putNextReference(reader.nextReference(type), type);
            } else if (type == boolean.class) {
                writer.putNextBoolean(reader.nextBoolean());
            } else if (type == byte.class) {
                writer.putNextByte(reader.nextByte());
            } else if (type == char.class) {
                writer.putNextChar(reader.nextChar());
            } else if (type == short.class) {
                writer.putNextShort(reader.nextShort());
            } else if (type == int.class) {
                writer.putNextInt(reader.nextInt());
            } else if (type == long.class) {
                writer.putNextLong(reader.nextLong());
            } else if (type == float.class) {
                writer.putNextFloat(reader.nextFloat());
            } else if (type == double.class) {
                writer.putNextDouble(reader.nextDouble());
            }
        }
    }

    /**
     * Provides sequential write access to an emulated stack frame. Allows writes to
     * argument slots as well as return value slots.
     */
    public static class StackFrameWriter extends StackFrameAccessor {
        public void putNextByte(byte value) {
            checkWriteType(byte.class);
            argumentIdx++;
            frameBuf.putInt(value);
        }

        public void putNextInt(int value) {
            checkWriteType(int.class);
            argumentIdx++;
            frameBuf.putInt(value);
        }

        public void putNextLong(long value) {
            checkWriteType(long.class);
            argumentIdx++;
            frameBuf.putLong(value);
        }

        public void putNextChar(char value) {
            checkWriteType(char.class);
            argumentIdx++;
            frameBuf.putInt((int) value);
        }

        public void putNextBoolean(boolean value) {
            checkWriteType(boolean.class);
            argumentIdx++;
            frameBuf.putInt(value ? 1 : 0);
        }

        public void putNextShort(short value) {
            checkWriteType(short.class);
            argumentIdx++;
            frameBuf.putInt((int) value);
        }

        public void putNextFloat(float value) {
            checkWriteType(float.class);
            argumentIdx++;
            frameBuf.putFloat(value);
        }

        public void putNextDouble(double value) {
            checkWriteType(double.class);
            argumentIdx++;
            frameBuf.putDouble(value);
        }

        public void putNextReference(Object value, Class<?> expectedType) {
            checkWriteType(expectedType);
            argumentIdx++;
            frame.references[referencesOffset++] = value;
        }
    }

    /**
     * Provides sequential read access to an emulated stack frame. Allows reads to
     * argument slots as well as to return value slots.
     */
    public static class StackFrameReader extends StackFrameAccessor {
        public byte nextByte() {
            checkReadType(byte.class);
            argumentIdx++;
            return (byte) frameBuf.getInt();
        }

        public int nextInt() {
            checkReadType(int.class);
            argumentIdx++;
            return frameBuf.getInt();
        }

        public long nextLong() {
            checkReadType(long.class);
            argumentIdx++;
            return frameBuf.getLong();
        }

        public char nextChar() {
            checkReadType(char.class);
            argumentIdx++;
            return (char) frameBuf.getInt();
        }

        public boolean nextBoolean() {
            checkReadType(boolean.class);
            argumentIdx++;
            return (frameBuf.getInt() != 0);
        }

        public short nextShort() {
            checkReadType(short.class);
            argumentIdx++;
            return (short) frameBuf.getInt();
        }

        public float nextFloat() {
            checkReadType(float.class);
            argumentIdx++;
            return frameBuf.getFloat();
        }

        public double nextDouble() {
            checkReadType(double.class);
            argumentIdx++;
            return frameBuf.getDouble();
        }

        public <T> T nextReference(Class<T> expectedType) {
            checkReadType(expectedType);
            argumentIdx++;
            return (T) frame.references[referencesOffset++];
        }
    }
}