Java Code Examples for com.android.dx.rop.type.Type#getArrayType()

The following examples show how to use com.android.dx.rop.type.Type#getArrayType() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: Simulator.java    From Box with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the required array type for an array load or store
 * instruction, based on a given implied type and an observed
 * actual array type.
 *
 * <p>The interesting cases here have to do with object arrays,
 * <code>byte[]</code>s, <code>boolean[]</code>s, and
 * known-nulls.</p>
 *
 * <p>In the case of arrays of objects, we want to narrow the type
 * to the actual array present on the stack, as long as what is
 * present is an object type. Similarly, due to a quirk of the
 * original bytecode representation, the instructions for dealing
 * with <code>byte[]</code> and <code>boolean[]</code> are
 * undifferentiated, and we aim here to return whichever one was
 * actually present on the stack.</p>
 *
 * <p>In the case where there is a known-null on the stack where
 * an array is expected, our behavior depends on the implied type
 * of the instruction. When the implied type is a reference, we
 * don't attempt to infer anything, as we don't know the dimension
 * of the null constant and thus any explicit inferred type could
 * be wrong. When the implied type is a primitive, we fall back to
 * the implied type of the instruction. Due to the quirk described
 * above, this means that source code that uses
 * <code>boolean[]</code> might get translated surprisingly -- but
 * correctly -- into an instruction that specifies a
 * <code>byte[]</code>. It will be correct, because should the
 * code actually execute, it will necessarily throw a
 * <code>NullPointerException</code>, and it won't matter what
 * opcode variant is used to achieve that result.</p>
 *
 * @param impliedType {@code non-null;} type implied by the
 * instruction; is <i>not</i> an array type
 * @param foundArrayType {@code non-null;} type found on the
 * stack; is either an array type or a known-null
 * @return {@code non-null;} the array type that should be
 * required in this context
 */
private static Type requiredArrayTypeFor(Type impliedType,
        Type foundArrayType) {
    if (foundArrayType == Type.KNOWN_NULL) {
        return impliedType.isReference()
            ? Type.KNOWN_NULL
            : impliedType.getArrayType();
    }

    if ((impliedType == Type.OBJECT)
            && foundArrayType.isArray()
            && foundArrayType.getComponentType().isReference()) {
        return foundArrayType;
    }

    if ((impliedType == Type.BYTE)
            && (foundArrayType == Type.BOOLEAN_ARRAY)) {
        /*
         * Per above, an instruction with implied byte[] is also
         * allowed to be used on boolean[].
         */
        return Type.BOOLEAN_ARRAY;
    }

    return impliedType.getArrayType();
}
Example 2
Source File: Simulator.java    From Box with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the required array type for an array load or store
 * instruction, based on a given implied type and an observed
 * actual array type.
 *
 * <p>The interesting cases here have to do with object arrays,
 * <code>byte[]</code>s, <code>boolean[]</code>s, and
 * known-nulls.</p>
 *
 * <p>In the case of arrays of objects, we want to narrow the type
 * to the actual array present on the stack, as long as what is
 * present is an object type. Similarly, due to a quirk of the
 * original bytecode representation, the instructions for dealing
 * with <code>byte[]</code> and <code>boolean[]</code> are
 * undifferentiated, and we aim here to return whichever one was
 * actually present on the stack.</p>
 *
 * <p>In the case where there is a known-null on the stack where
 * an array is expected, our behavior depends on the implied type
 * of the instruction. When the implied type is a reference, we
 * don't attempt to infer anything, as we don't know the dimension
 * of the null constant and thus any explicit inferred type could
 * be wrong. When the implied type is a primitive, we fall back to
 * the implied type of the instruction. Due to the quirk described
 * above, this means that source code that uses
 * <code>boolean[]</code> might get translated surprisingly -- but
 * correctly -- into an instruction that specifies a
 * <code>byte[]</code>. It will be correct, because should the
 * code actually execute, it will necessarily throw a
 * <code>NullPointerException</code>, and it won't matter what
 * opcode variant is used to achieve that result.</p>
 *
 * @param impliedType {@code non-null;} type implied by the
 * instruction; is <i>not</i> an array type
 * @param foundArrayType {@code non-null;} type found on the
 * stack; is either an array type or a known-null
 * @return {@code non-null;} the array type that should be
 * required in this context
 */
private static Type requiredArrayTypeFor(Type impliedType,
        Type foundArrayType) {
    if (foundArrayType == Type.KNOWN_NULL) {
        return impliedType.isReference()
            ? Type.KNOWN_NULL
            : impliedType.getArrayType();
    }

    if ((impliedType == Type.OBJECT)
            && foundArrayType.isArray()
            && foundArrayType.getComponentType().isReference()) {
        return foundArrayType;
    }

    if ((impliedType == Type.BYTE)
            && (foundArrayType == Type.BOOLEAN_ARRAY)) {
        /*
         * Per above, an instruction with implied byte[] is also
         * allowed to be used on boolean[].
         */
        return Type.BOOLEAN_ARRAY;
    }

    return impliedType.getArrayType();
}
Example 3
Source File: Simulator.java    From J2ME-Loader with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the required array type for an array load or store
 * instruction, based on a given implied type and an observed
 * actual array type.
 *
 * <p>The interesting cases here have to do with object arrays,
 * <code>byte[]</code>s, <code>boolean[]</code>s, and
 * known-nulls.</p>
 *
 * <p>In the case of arrays of objects, we want to narrow the type
 * to the actual array present on the stack, as long as what is
 * present is an object type. Similarly, due to a quirk of the
 * original bytecode representation, the instructions for dealing
 * with <code>byte[]</code> and <code>boolean[]</code> are
 * undifferentiated, and we aim here to return whichever one was
 * actually present on the stack.</p>
 *
 * <p>In the case where there is a known-null on the stack where
 * an array is expected, our behavior depends on the implied type
 * of the instruction. When the implied type is a reference, we
 * don't attempt to infer anything, as we don't know the dimension
 * of the null constant and thus any explicit inferred type could
 * be wrong. When the implied type is a primitive, we fall back to
 * the implied type of the instruction. Due to the quirk described
 * above, this means that source code that uses
 * <code>boolean[]</code> might get translated surprisingly -- but
 * correctly -- into an instruction that specifies a
 * <code>byte[]</code>. It will be correct, because should the
 * code actually execute, it will necessarily throw a
 * <code>NullPointerException</code>, and it won't matter what
 * opcode variant is used to achieve that result.</p>
 *
 * @param impliedType {@code non-null;} type implied by the
 * instruction; is <i>not</i> an array type
 * @param foundArrayType {@code non-null;} type found on the
 * stack; is either an array type or a known-null
 * @return {@code non-null;} the array type that should be
 * required in this context
 */
private static Type requiredArrayTypeFor(Type impliedType,
        Type foundArrayType) {
    if (foundArrayType == Type.KNOWN_NULL) {
        return impliedType.isReference()
            ? Type.KNOWN_NULL
            : impliedType.getArrayType();
    }

    if ((impliedType == Type.OBJECT)
            && foundArrayType.isArray()
            && foundArrayType.getComponentType().isReference()) {
        return foundArrayType;
    }

    if ((impliedType == Type.BYTE)
            && (foundArrayType == Type.BOOLEAN_ARRAY)) {
        /*
         * Per above, an instruction with implied byte[] is also
         * allowed to be used on boolean[].
         */
        return Type.BOOLEAN_ARRAY;
    }

    return impliedType.getArrayType();
}
Example 4
Source File: Simulator.java    From buck with Apache License 2.0 4 votes vote down vote up 
/**
 * Returns the required array type for an array load or store
 * instruction, based on a given implied type and an observed
 * actual array type.
 *
 * <p>The interesting cases here have to do with object arrays,
 * <code>byte[]</code>s, <code>boolean[]</code>s, and
 * known-nulls.</p>
 *
 * <p>In the case of arrays of objects, we want to narrow the type
 * to the actual array present on the stack, as long as what is
 * present is an object type. Similarly, due to a quirk of the
 * original bytecode representation, the instructions for dealing
 * with <code>byte[]</code> and <code>boolean[]</code> are
 * undifferentiated, and we aim here to return whichever one was
 * actually present on the stack.</p>
 *
 * <p>In the case where there is a known-null on the stack where
 * an array is expected, our behavior depends on the implied type
 * of the instruction. When the implied type is a reference, we
 * don't attempt to infer anything, as we don't know the dimension
 * of the null constant and thus any explicit inferred type could
 * be wrong. When the implied type is a primitive, we fall back to
 * the implied type of the instruction. Due to the quirk described
 * above, this means that source code that uses
 * <code>boolean[]</code> might get translated surprisingly -- but
 * correctly -- into an instruction that specifies a
 * <code>byte[]</code>. It will be correct, because should the
 * code actually execute, it will necessarily throw a
 * <code>NullPointerException</code>, and it won't matter what
 * opcode variant is used to achieve that result.</p>
 *
 * @param impliedType {@code non-null;} type implied by the
 * instruction; is <i>not</i> an array type
 * @param foundArrayType {@code non-null;} type found on the
 * stack; is either an array type or a known-null
 * @return {@code non-null;} the array type that should be
 * required in this context
 */
private static Type requiredArrayTypeFor(Type impliedType,
        Type foundArrayType) {
    if (foundArrayType == Type.KNOWN_NULL) {
        return impliedType.isReference()
            ? Type.KNOWN_NULL
            : impliedType.getArrayType();
    }

    if ((impliedType == Type.OBJECT)
            && foundArrayType.isArray()
            && foundArrayType.getComponentType().isReference()) {
        return foundArrayType;
    }

    if ((impliedType == Type.BYTE)
            && (foundArrayType == Type.BOOLEAN_ARRAY)) {
        /*
         * Per above, an instruction with implied byte[] is also
         * allowed to be used on boolean[].
         */
        return Type.BOOLEAN_ARRAY;
    }

    return impliedType.getArrayType();
}