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

/**
 * Helper for {@link #processFields}, which translates constants into
 * more specific types if necessary.
 *
 * @param constant {@code non-null;} the constant in question
 * @param type {@code non-null;} the desired type
 */
private static TypedConstant coerceConstant(TypedConstant constant,
        Type type) {
    Type constantType = constant.getType();

    if (constantType.equals(type)) {
        return constant;
    }

    switch (type.getBasicType()) {
        case Type.BT_BOOLEAN: {
            return CstBoolean.make(((CstInteger) constant).getValue());
        }
        case Type.BT_BYTE: {
            return CstByte.make(((CstInteger) constant).getValue());
        }
        case Type.BT_CHAR: {
            return CstChar.make(((CstInteger) constant).getValue());
        }
        case Type.BT_SHORT: {
            return CstShort.make(((CstInteger) constant).getValue());
        }
        default: {
            throw new UnsupportedOperationException("can't coerce " +
                    constant + " to " + type);
        }
    }
}
 

/**
 * Helper for {@link #processFields}, which translates constants into
 * more specific types if necessary.
 *
 * @param constant {@code non-null;} the constant in question
 * @param type {@code non-null;} the desired type
 */
private static TypedConstant coerceConstant(TypedConstant constant,
        Type type) {
    Type constantType = constant.getType();

    if (constantType.equals(type)) {
        return constant;
    }

    switch (type.getBasicType()) {
        case Type.BT_BOOLEAN: {
            return CstBoolean.make(((CstInteger) constant).getValue());
        }
        case Type.BT_BYTE: {
            return CstByte.make(((CstInteger) constant).getValue());
        }
        case Type.BT_CHAR: {
            return CstChar.make(((CstInteger) constant).getValue());
        }
        case Type.BT_SHORT: {
            return CstShort.make(((CstInteger) constant).getValue());
        }
        default: {
            throw new UnsupportedOperationException("can't coerce " +
                    constant + " to " + type);
        }
    }
}
 

/**
 * Helper for {@link #processFields}, which translates constants into
 * more specific types if necessary.
 *
 * @param constant {@code non-null;} the constant in question
 * @param type {@code non-null;} the desired type
 */
private static TypedConstant coerceConstant(TypedConstant constant,
        Type type) {
    Type constantType = constant.getType();

    if (constantType.equals(type)) {
        return constant;
    }

    switch (type.getBasicType()) {
        case Type.BT_BOOLEAN: {
            return CstBoolean.make(((CstInteger) constant).getValue());
        }
        case Type.BT_BYTE: {
            return CstByte.make(((CstInteger) constant).getValue());
        }
        case Type.BT_CHAR: {
            return CstChar.make(((CstInteger) constant).getValue());
        }
        case Type.BT_SHORT: {
            return CstShort.make(((CstInteger) constant).getValue());
        }
        default: {
            throw new UnsupportedOperationException("can't coerce " +
                    constant + " to " + type);
        }
    }
}
 

/**
 * Helper for {@link #processFields}, which translates constants into
 * more specific types if necessary.
 *
 * @param constant {@code non-null;} the constant in question
 * @param type {@code non-null;} the desired type
 */
private static TypedConstant coerceConstant(TypedConstant constant,
        Type type) {
    Type constantType = constant.getType();

    if (constantType.equals(type)) {
        return constant;
    }

    switch (type.getBasicType()) {
        case Type.BT_BOOLEAN: {
            return CstBoolean.make(((CstInteger) constant).getValue());
        }
        case Type.BT_BYTE: {
            return CstByte.make(((CstInteger) constant).getValue());
        }
        case Type.BT_CHAR: {
            return CstChar.make(((CstInteger) constant).getValue());
        }
        case Type.BT_SHORT: {
            return CstShort.make(((CstInteger) constant).getValue());
        }
        default: {
            throw new UnsupportedOperationException("can't coerce " +
                    constant + " to " + type);
        }
    }
}
 

/**
 * Makes the {@link CatchHandlerList} for the given basic block.
 *
 * @param block {@code non-null;} block to get entries for
 * @param addresses {@code non-null;} address objects for each block
 * @return {@code non-null;} array of entries
 */
private static CatchHandlerList handlersFor(BasicBlock block,
        BlockAddresses addresses) {
    IntList successors = block.getSuccessors();
    int succSize = successors.size();
    int primary = block.getPrimarySuccessor();
    TypeList catches = block.getLastInsn().getCatches();
    int catchSize = catches.size();

    if (catchSize == 0) {
        return CatchHandlerList.EMPTY;
    }

    if (((primary == -1) && (succSize != catchSize))
            || ((primary != -1) &&
                    ((succSize != (catchSize + 1))
                            || (primary != successors.get(catchSize))))) {
        /*
         * Blocks that throw are supposed to list their primary
         * successor -- if any -- last in the successors list, but
         * that constraint appears to be violated here.
         */
        throw new RuntimeException(
                "shouldn't happen: weird successors list");
    }

    /*
     * Reduce the effective catchSize if we spot a catch-all that
     * isn't at the end.
     */
    for (int i = 0; i < catchSize; i++) {
        Type type = catches.getType(i);
        if (type.equals(Type.OBJECT)) {
            catchSize = i + 1;
            break;
        }
    }

    CatchHandlerList result = new CatchHandlerList(catchSize);

    for (int i = 0; i < catchSize; i++) {
        CstType oneType = new CstType(catches.getType(i));
        CodeAddress oneHandler = addresses.getStart(successors.get(i));
        result.set(i, oneType, oneHandler.getAddress());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns whether the given supertype is possibly assignable from
 * the given subtype. This takes into account primitiveness,
 * int-likeness, known-nullness, and array dimensions, but does
 * not assume anything about class hierarchy other than that the
 * type {@code Object} is the supertype of all reference
 * types and all arrays are assignable to
 * {@code Serializable} and {@code Cloneable}.
 *
 * @param supertypeBearer {@code non-null;} the supertype
 * @param subtypeBearer {@code non-null;} the subtype
 */
public static boolean isPossiblyAssignableFrom(TypeBearer supertypeBearer,
        TypeBearer subtypeBearer) {
    Type supertype = supertypeBearer.getType();
    Type subtype = subtypeBearer.getType();

    if (supertype.equals(subtype)) {
        // Easy out.
        return true;
    }

    int superBt = supertype.getBasicType();
    int subBt = subtype.getBasicType();

    // Treat return types as Object for the purposes of this method.

    if (superBt == Type.BT_ADDR) {
        supertype = Type.OBJECT;
        superBt = Type.BT_OBJECT;
    }

    if (subBt == Type.BT_ADDR) {
        subtype = Type.OBJECT;
        subBt = Type.BT_OBJECT;
    }

    if ((superBt != Type.BT_OBJECT) || (subBt != Type.BT_OBJECT)) {
        /*
         * No two distinct primitive types are assignable in this sense,
         * unless they are both int-like.
         */
        return supertype.isIntlike() && subtype.isIntlike();
    }

    // At this point, we know both types are reference types.

    if (supertype == Type.KNOWN_NULL) {
        /*
         * A known-null supertype is only assignable from another
         * known-null (handled in the easy out at the top of the
         * method).
         */
        return false;
    } else if (subtype == Type.KNOWN_NULL) {
        /*
         * A known-null subtype is in fact assignable to any
         * reference type.
         */
        return true;
    } else if (supertype == Type.OBJECT) {
        /*
         * Object is assignable from any reference type.
         */
        return true;
    } else if (supertype.isArray()) {
        // The supertype is an array type.
        if (! subtype.isArray()) {
            // The subtype isn't an array, and so can't be assignable.
            return false;
        }

        /*
         * Strip off as many matched component types from both
         * types as possible, and check the assignability of the
         * results.
         */
        do {
            supertype = supertype.getComponentType();
            subtype = subtype.getComponentType();
        } while (supertype.isArray() && subtype.isArray());

        return isPossiblyAssignableFrom(supertype, subtype);
    } else if (subtype.isArray()) {
        /*
         * Other than Object (handled above), array types are
         * assignable only to Serializable and Cloneable.
         */
        return (supertype == Type.SERIALIZABLE) ||
            (supertype == Type.CLONEABLE);
    } else {
        /*
         * All other unequal reference types are considered at
         * least possibly assignable.
         */
        return true;
    }
}
 

/**
 * Makes the {@link CatchHandlerList} for the given basic block.
 *
 * @param block {@code non-null;} block to get entries for
 * @param addresses {@code non-null;} address objects for each block
 * @return {@code non-null;} array of entries
 */
private static CatchHandlerList handlersFor(BasicBlock block,
        BlockAddresses addresses) {
    IntList successors = block.getSuccessors();
    int succSize = successors.size();
    int primary = block.getPrimarySuccessor();
    TypeList catches = block.getLastInsn().getCatches();
    int catchSize = catches.size();

    if (catchSize == 0) {
        return CatchHandlerList.EMPTY;
    }

    if (((primary == -1) && (succSize != catchSize))
            || ((primary != -1) &&
                    ((succSize != (catchSize + 1))
                            || (primary != successors.get(catchSize))))) {
        /*
         * Blocks that throw are supposed to list their primary
         * successor -- if any -- last in the successors list, but
         * that constraint appears to be violated here.
         */
        throw new RuntimeException(
                "shouldn't happen: weird successors list");
    }

    /*
     * Reduce the effective catchSize if we spot a catch-all that
     * isn't at the end.
     */
    for (int i = 0; i < catchSize; i++) {
        Type type = catches.getType(i);
        if (type.equals(Type.OBJECT)) {
            catchSize = i + 1;
            break;
        }
    }

    CatchHandlerList result = new CatchHandlerList(catchSize);

    for (int i = 0; i < catchSize; i++) {
        CstType oneType = new CstType(catches.getType(i));
        CodeAddress oneHandler = addresses.getStart(successors.get(i));
        result.set(i, oneType, oneHandler.getAddress());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns whether the given supertype is possibly assignable from
 * the given subtype. This takes into account primitiveness,
 * int-likeness, known-nullness, and array dimensions, but does
 * not assume anything about class hierarchy other than that the
 * type {@code Object} is the supertype of all reference
 * types and all arrays are assignable to
 * {@code Serializable} and {@code Cloneable}.
 *
 * @param supertypeBearer {@code non-null;} the supertype
 * @param subtypeBearer {@code non-null;} the subtype
 */
public static boolean isPossiblyAssignableFrom(TypeBearer supertypeBearer,
        TypeBearer subtypeBearer) {
    Type supertype = supertypeBearer.getType();
    Type subtype = subtypeBearer.getType();

    if (supertype.equals(subtype)) {
        // Easy out.
        return true;
    }

    int superBt = supertype.getBasicType();
    int subBt = subtype.getBasicType();

    // Treat return types as Object for the purposes of this method.

    if (superBt == Type.BT_ADDR) {
        supertype = Type.OBJECT;
        superBt = Type.BT_OBJECT;
    }

    if (subBt == Type.BT_ADDR) {
        subtype = Type.OBJECT;
        subBt = Type.BT_OBJECT;
    }

    if ((superBt != Type.BT_OBJECT) || (subBt != Type.BT_OBJECT)) {
        /*
         * No two distinct primitive types are assignable in this sense,
         * unless they are both int-like.
         */
        return supertype.isIntlike() && subtype.isIntlike();
    }

    // At this point, we know both types are reference types.

    if (supertype == Type.KNOWN_NULL) {
        /*
         * A known-null supertype is only assignable from another
         * known-null (handled in the easy out at the top of the
         * method).
         */
        return false;
    } else if (subtype == Type.KNOWN_NULL) {
        /*
         * A known-null subtype is in fact assignable to any
         * reference type.
         */
        return true;
    } else if (supertype == Type.OBJECT) {
        /*
         * Object is assignable from any reference type.
         */
        return true;
    } else if (supertype.isArray()) {
        // The supertype is an array type.
        if (! subtype.isArray()) {
            // The subtype isn't an array, and so can't be assignable.
            return false;
        }

        /*
         * Strip off as many matched component types from both
         * types as possible, and check the assignability of the
         * results.
         */
        do {
            supertype = supertype.getComponentType();
            subtype = subtype.getComponentType();
        } while (supertype.isArray() && subtype.isArray());

        return isPossiblyAssignableFrom(supertype, subtype);
    } else if (subtype.isArray()) {
        /*
         * Other than Object (handled above), array types are
         * assignable only to Serializable and Cloneable.
         */
        return (supertype == Type.SERIALIZABLE) ||
            (supertype == Type.CLONEABLE);
    } else {
        /*
         * All other unequal reference types are considered at
         * least possibly assignable.
         */
        return true;
    }
}
 

/**
 * Makes the {@link CatchHandlerList} for the given basic block.
 *
 * @param block {@code non-null;} block to get entries for
 * @param addresses {@code non-null;} address objects for each block
 * @return {@code non-null;} array of entries
 */
private static CatchHandlerList handlersFor(BasicBlock block,
        BlockAddresses addresses) {
    IntList successors = block.getSuccessors();
    int succSize = successors.size();
    int primary = block.getPrimarySuccessor();
    TypeList catches = block.getLastInsn().getCatches();
    int catchSize = catches.size();

    if (catchSize == 0) {
        return CatchHandlerList.EMPTY;
    }

    if (((primary == -1) && (succSize != catchSize))
            || ((primary != -1) &&
                    ((succSize != (catchSize + 1))
                            || (primary != successors.get(catchSize))))) {
        /*
         * Blocks that throw are supposed to list their primary
         * successor -- if any -- last in the successors list, but
         * that constraint appears to be violated here.
         */
        throw new RuntimeException(
                "shouldn't happen: weird successors list");
    }

    /*
     * Reduce the effective catchSize if we spot a catch-all that
     * isn't at the end.
     */
    for (int i = 0; i < catchSize; i++) {
        Type type = catches.getType(i);
        if (type.equals(Type.OBJECT)) {
            catchSize = i + 1;
            break;
        }
    }

    CatchHandlerList result = new CatchHandlerList(catchSize);

    for (int i = 0; i < catchSize; i++) {
        CstType oneType = new CstType(catches.getType(i));
        CodeAddress oneHandler = addresses.getStart(successors.get(i));
        result.set(i, oneType, oneHandler.getAddress());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns whether the given supertype is possibly assignable from
 * the given subtype. This takes into account primitiveness,
 * int-likeness, known-nullness, and array dimensions, but does
 * not assume anything about class hierarchy other than that the
 * type {@code Object} is the supertype of all reference
 * types and all arrays are assignable to
 * {@code Serializable} and {@code Cloneable}.
 *
 * @param supertypeBearer {@code non-null;} the supertype
 * @param subtypeBearer {@code non-null;} the subtype
 */
public static boolean isPossiblyAssignableFrom(TypeBearer supertypeBearer,
        TypeBearer subtypeBearer) {
    Type supertype = supertypeBearer.getType();
    Type subtype = subtypeBearer.getType();

    if (supertype.equals(subtype)) {
        // Easy out.
        return true;
    }

    int superBt = supertype.getBasicType();
    int subBt = subtype.getBasicType();

    // Treat return types as Object for the purposes of this method.

    if (superBt == Type.BT_ADDR) {
        supertype = Type.OBJECT;
        superBt = Type.BT_OBJECT;
    }

    if (subBt == Type.BT_ADDR) {
        subtype = Type.OBJECT;
        subBt = Type.BT_OBJECT;
    }

    if ((superBt != Type.BT_OBJECT) || (subBt != Type.BT_OBJECT)) {
        /*
         * No two distinct primitive types are assignable in this sense,
         * unless they are both int-like.
         */
        return supertype.isIntlike() && subtype.isIntlike();
    }

    // At this point, we know both types are reference types.

    if (supertype == Type.KNOWN_NULL) {
        /*
         * A known-null supertype is only assignable from another
         * known-null (handled in the easy out at the top of the
         * method).
         */
        return false;
    } else if (subtype == Type.KNOWN_NULL) {
        /*
         * A known-null subtype is in fact assignable to any
         * reference type.
         */
        return true;
    } else if (supertype == Type.OBJECT) {
        /*
         * Object is assignable from any reference type.
         */
        return true;
    } else if (supertype.isArray()) {
        // The supertype is an array type.
        if (! subtype.isArray()) {
            // The subtype isn't an array, and so can't be assignable.
            return false;
        }

        /*
         * Strip off as many matched component types from both
         * types as possible, and check the assignability of the
         * results.
         */
        do {
            supertype = supertype.getComponentType();
            subtype = subtype.getComponentType();
        } while (supertype.isArray() && subtype.isArray());

        return isPossiblyAssignableFrom(supertype, subtype);
    } else if (subtype.isArray()) {
        /*
         * Other than Object (handled above), array types are
         * assignable only to Serializable and Cloneable.
         */
        return (supertype == Type.SERIALIZABLE) ||
            (supertype == Type.CLONEABLE);
    } else {
        /*
         * All other unequal reference types are considered at
         * least possibly assignable.
         */
        return true;
    }
}
 

/**
 * Makes the {@link CatchHandlerList} for the given basic block.
 *
 * @param block {@code non-null;} block to get entries for
 * @param addresses {@code non-null;} address objects for each block
 * @return {@code non-null;} array of entries
 */
private static CatchHandlerList handlersFor(BasicBlock block,
        BlockAddresses addresses) {
    IntList successors = block.getSuccessors();
    int succSize = successors.size();
    int primary = block.getPrimarySuccessor();
    TypeList catches = block.getLastInsn().getCatches();
    int catchSize = catches.size();

    if (catchSize == 0) {
        return CatchHandlerList.EMPTY;
    }

    if (((primary == -1) && (succSize != catchSize))
            || ((primary != -1) &&
                    ((succSize != (catchSize + 1))
                            || (primary != successors.get(catchSize))))) {
        /*
         * Blocks that throw are supposed to list their primary
         * successor -- if any -- last in the successors list, but
         * that constraint appears to be violated here.
         */
        throw new RuntimeException(
                "shouldn't happen: weird successors list");
    }

    /*
     * Reduce the effective catchSize if we spot a catch-all that
     * isn't at the end.
     */
    for (int i = 0; i < catchSize; i++) {
        Type type = catches.getType(i);
        if (type.equals(Type.OBJECT)) {
            catchSize = i + 1;
            break;
        }
    }

    CatchHandlerList result = new CatchHandlerList(catchSize);

    for (int i = 0; i < catchSize; i++) {
        CstType oneType = new CstType(catches.getType(i));
        CodeAddress oneHandler = addresses.getStart(successors.get(i));
        result.set(i, oneType, oneHandler.getAddress());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns whether the given supertype is possibly assignable from
 * the given subtype. This takes into account primitiveness,
 * int-likeness, known-nullness, and array dimensions, but does
 * not assume anything about class hierarchy other than that the
 * type {@code Object} is the supertype of all reference
 * types and all arrays are assignable to
 * {@code Serializable} and {@code Cloneable}.
 *
 * @param supertypeBearer {@code non-null;} the supertype
 * @param subtypeBearer {@code non-null;} the subtype
 */
public static boolean isPossiblyAssignableFrom(TypeBearer supertypeBearer,
        TypeBearer subtypeBearer) {
    Type supertype = supertypeBearer.getType();
    Type subtype = subtypeBearer.getType();

    if (supertype.equals(subtype)) {
        // Easy out.
        return true;
    }

    int superBt = supertype.getBasicType();
    int subBt = subtype.getBasicType();

    // Treat return types as Object for the purposes of this method.

    if (superBt == Type.BT_ADDR) {
        supertype = Type.OBJECT;
        superBt = Type.BT_OBJECT;
    }

    if (subBt == Type.BT_ADDR) {
        subtype = Type.OBJECT;
        subBt = Type.BT_OBJECT;
    }

    if ((superBt != Type.BT_OBJECT) || (subBt != Type.BT_OBJECT)) {
        /*
         * No two distinct primitive types are assignable in this sense,
         * unless they are both int-like.
         */
        return supertype.isIntlike() && subtype.isIntlike();
    }

    // At this point, we know both types are reference types.

    if (supertype == Type.KNOWN_NULL) {
        /*
         * A known-null supertype is only assignable from another
         * known-null (handled in the easy out at the top of the
         * method).
         */
        return false;
    } else if (subtype == Type.KNOWN_NULL) {
        /*
         * A known-null subtype is in fact assignable to any
         * reference type.
         */
        return true;
    } else if (supertype == Type.OBJECT) {
        /*
         * Object is assignable from any reference type.
         */
        return true;
    } else if (supertype.isArray()) {
        // The supertype is an array type.
        if (! subtype.isArray()) {
            // The subtype isn't an array, and so can't be assignable.
            return false;
        }

        /*
         * Strip off as many matched component types from both
         * types as possible, and check the assignability of the
         * results.
         */
        do {
            supertype = supertype.getComponentType();
            subtype = subtype.getComponentType();
        } while (supertype.isArray() && subtype.isArray());

        return isPossiblyAssignableFrom(supertype, subtype);
    } else if (subtype.isArray()) {
        /*
         * Other than Object (handled above), array types are
         * assignable only to Serializable and Cloneable.
         */
        return (supertype == Type.SERIALIZABLE) ||
            (supertype == Type.CLONEABLE);
    } else {
        /*
         * All other unequal reference types are considered at
         * least possibly assignable.
         */
        return true;
    }
}