Java Type.OBJECT属性代码示例

/**
 * 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, we just 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.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();
}
 

/**
 * Merges two frame types.
 *
 * @param ft1 {@code non-null;} a frame type
 * @param ft2 {@code non-null;} another frame type
 * @return {@code non-null;} the result of merging the two types
 */
public static TypeBearer mergeType(TypeBearer ft1, TypeBearer ft2) {
    if ((ft1 == null) || ft1.equals(ft2)) {
        return ft1;
    } else if (ft2 == null) {
        return null;
    } else {
        Type type1 = ft1.getType();
        Type type2 = ft2.getType();

        if (type1 == type2) {
            return type1;
        } else if (type1.isReference() && type2.isReference()) {
            if (type1 == Type.KNOWN_NULL) {
                /*
                 * A known-null merges with any other reference type to
                 * be that reference type.
                 */
                return type2;
            } else if (type2 == Type.KNOWN_NULL) {
                /*
                 * The same as above, but this time it's type2 that's
                 * the known-null.
                 */
                return type1;
            } else if (type1.isArray() && type2.isArray()) {
                TypeBearer componentUnion =
                    mergeType(type1.getComponentType(),
                            type2.getComponentType());
                if (componentUnion == null) {
                    /*
                     * At least one of the types is a primitive type,
                     * so the merged result is just Object.
                     */
                    return Type.OBJECT;
                }
                return ((Type) componentUnion).getArrayType();
            } else {
                /*
                 * All other unequal reference types get merged to be
                 * Object in this phase. This is fine here, but it
                 * won't be the right thing to do in the verifier.
                 */
                return Type.OBJECT;
            }
        } else if (type1.isIntlike() && type2.isIntlike()) {
            /*
             * Merging two non-identical int-like types results in
             * the type int.
             */
            return Type.INT;
        } else {
            return null;
        }
    }
}
 

/**
 * Gets the target local register spec of the current operation, if any.
 * The local target spec is the combination of the values indicated
 * by a previous call to {@link #localTarget} with the type of what
 * should be the sole result set by a call to {@link #setResult} (or
 * the combination {@link #clearResult} then {@link #addResult}.
 *
 * @param isMove {@code true} if the operation being performed on the
 * local is a move. This will cause constant values to be propagated
 * to the returned local
 * @return {@code null-ok;} the salient register spec or {@code null} if no
 * local target was set since the last time {@link #clearArgs} was
 * called
 */
protected final RegisterSpec getLocalTarget(boolean isMove) {
    if (localTarget == null) {
        return null;
    }

    if (resultCount != 1) {
        throw new SimException("local target with " +
                ((resultCount == 0) ? "no" : "multiple") + " results");
    }

    TypeBearer result = results[0];
    Type resultType = result.getType();
    Type localType = localTarget.getType();

    if (resultType == localType) {
        /*
         * If this is to be a move operation and the result is a
         * known value, make the returned localTarget embody that
         * value.
         */
        if (isMove) {
            return localTarget.withType(result);
        } else {
            return localTarget;
        }
    }

    if (! Merger.isPossiblyAssignableFrom(localType, resultType)) {
        // The result and local types are inconsistent. Complain!
        throwLocalMismatch(resultType, localType);
        return null;
    }

    if (localType == Type.OBJECT) {
        /*
         * The result type is more specific than the local type,
         * so use that instead.
         */
        localTarget = localTarget.withType(result);
    }

    return localTarget;
}
 

/**
 * 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();
}