com.android.dx.rop.type.StdTypeList Java Examples

/**
 * Returns a rop-style catches list equivalent to this one.
 *
 * @return {@code non-null;} the converted instance
 */
public TypeList toRopCatchList() {
    int sz = size();
    if (sz == 0) {
        return StdTypeList.EMPTY;
    }

    StdTypeList result = new StdTypeList(sz);

    for (int i = 0; i < sz; i++) {
        result.set(i, get(i).getExceptionClass().getClassType());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns a rop-style catches list equivalent to this one.
 *
 * @return {@code non-null;} the converted instance
 */
public TypeList toRopCatchList() {
    int sz = size();
    if (sz == 0) {
        return StdTypeList.EMPTY;
    }

    StdTypeList result = new StdTypeList(sz);

    for (int i = 0; i < sz; i++) {
        result.set(i, get(i).getExceptionClass().getClassType());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns the appropriate {@code filled-new-array} rop for the given
 * type. The result may be a shared instance.
 *
 * @param arrayType {@code non-null;} type of array being created
 * @param count {@code count >= 0;} number of elements that the array should have
 * @return {@code non-null;} an appropriate instance
 */
public static Rop opFilledNewArray(TypeBearer arrayType, int count) {
    Type type = arrayType.getType();
    Type elementType = type.getComponentType();

    if (elementType.isCategory2()) {
        return throwBadType(arrayType);
    }

    if (count < 0) {
        throw new IllegalArgumentException("count < 0");
    }

    StdTypeList sourceTypes = new StdTypeList(count);

    for (int i = 0; i < count; i++) {
        sourceTypes.set(i, elementType);
    }

    // Note: The resulting rop is considered call-like.
    return new Rop(RegOps.FILLED_NEW_ARRAY,
                   sourceTypes,
                   Exceptions.LIST_Error);
}
 

/**
 * Returns a rop-style catches list equivalent to this one.
 *
 * @return {@code non-null;} the converted instance
 */
public TypeList toRopCatchList() {
    int sz = size();
    if (sz == 0) {
        return StdTypeList.EMPTY;
    }

    StdTypeList result = new StdTypeList(sz);

    for (int i = 0; i < sz; i++) {
        result.set(i, get(i).getExceptionClass().getClassType());
    }

    result.setImmutable();
    return result;
}
 

/**
 * Returns the appropriate {@code new-array} rop for the given
 * type. The result is a shared instance.
 *
 * @param arrayType {@code non-null;} array type of array being created
 * @return {@code non-null;} an appropriate instance
 */
public static Rop opNewArray(TypeBearer arrayType) {
    Type type = arrayType.getType();
    Type elementType = type.getComponentType();

    switch (elementType.getBasicType()) {
        case Type.BT_INT:     return NEW_ARRAY_INT;
        case Type.BT_LONG:    return NEW_ARRAY_LONG;
        case Type.BT_FLOAT:   return NEW_ARRAY_FLOAT;
        case Type.BT_DOUBLE:  return NEW_ARRAY_DOUBLE;
        case Type.BT_BOOLEAN: return NEW_ARRAY_BOOLEAN;
        case Type.BT_BYTE:    return NEW_ARRAY_BYTE;
        case Type.BT_CHAR:    return NEW_ARRAY_CHAR;
        case Type.BT_SHORT:   return NEW_ARRAY_SHORT;
        case Type.BT_OBJECT: {
            return new Rop(RegOps.NEW_ARRAY, type, StdTypeList.INT,
                    Exceptions.LIST_Error_NegativeArraySizeException,
                    "new-array-object");
        }
    }

    return throwBadType(type);
}
 

/**
 * Returns the appropriate {@code new-array} rop for the given
 * type. The result is a shared instance.
 *
 * @param arrayType {@code non-null;} array type of array being created
 * @return {@code non-null;} an appropriate instance
 */
public static Rop opNewArray(TypeBearer arrayType) {
    Type type = arrayType.getType();
    Type elementType = type.getComponentType();

    switch (elementType.getBasicType()) {
        case Type.BT_INT:     return NEW_ARRAY_INT;
        case Type.BT_LONG:    return NEW_ARRAY_LONG;
        case Type.BT_FLOAT:   return NEW_ARRAY_FLOAT;
        case Type.BT_DOUBLE:  return NEW_ARRAY_DOUBLE;
        case Type.BT_BOOLEAN: return NEW_ARRAY_BOOLEAN;
        case Type.BT_BYTE:    return NEW_ARRAY_BYTE;
        case Type.BT_CHAR:    return NEW_ARRAY_CHAR;
        case Type.BT_SHORT:   return NEW_ARRAY_SHORT;
        case Type.BT_OBJECT: {
            return new Rop(RegOps.NEW_ARRAY, type, StdTypeList.INT,
                    Exceptions.LIST_Error_NegativeArraySizeException,
                    "new-array-object");
        }
    }

    return throwBadType(type);
}
 

/**
 * Returns the appropriate {@code new-array} rop for the given
 * type. The result is a shared instance.
 *
 * @param arrayType {@code non-null;} array type of array being created
 * @return {@code non-null;} an appropriate instance
 */
public static Rop opNewArray(TypeBearer arrayType) {
    Type type = arrayType.getType();
    Type elementType = type.getComponentType();

    switch (elementType.getBasicType()) {
        case Type.BT_INT:     return NEW_ARRAY_INT;
        case Type.BT_LONG:    return NEW_ARRAY_LONG;
        case Type.BT_FLOAT:   return NEW_ARRAY_FLOAT;
        case Type.BT_DOUBLE:  return NEW_ARRAY_DOUBLE;
        case Type.BT_BOOLEAN: return NEW_ARRAY_BOOLEAN;
        case Type.BT_BYTE:    return NEW_ARRAY_BYTE;
        case Type.BT_CHAR:    return NEW_ARRAY_CHAR;
        case Type.BT_SHORT:   return NEW_ARRAY_SHORT;
        case Type.BT_OBJECT: {
            return new Rop(RegOps.NEW_ARRAY, type, StdTypeList.INT,
                    Exceptions.LIST_Error_NegativeArraySizeException,
                    "new-array-object");
        }
    }

    return throwBadType(type);
}
 

/**
 * Returns the appropriate {@code filled-new-array} rop for the given
 * type. The result may be a shared instance.
 *
 * @param arrayType {@code non-null;} type of array being created
 * @param count {@code count >= 0;} number of elements that the array should have
 * @return {@code non-null;} an appropriate instance
 */
public static Rop opFilledNewArray(TypeBearer arrayType, int count) {
    Type type = arrayType.getType();
    Type elementType = type.getComponentType();

    if (elementType.isCategory2()) {
        return throwBadType(arrayType);
    }

    if (count < 0) {
        throw new IllegalArgumentException("count < 0");
    }

    StdTypeList sourceTypes = new StdTypeList(count);

    for (int i = 0; i < count; i++) {
        sourceTypes.set(i, elementType);
    }

    // Note: The resulting rop is considered call-like.
    return new Rop(RegOps.FILLED_NEW_ARRAY,
                   sourceTypes,
                   Exceptions.LIST_Error);
}
 

/** {@inheritDoc} */
public void popArgs(Frame frame, Prototype prototype) {
    StdTypeList types = prototype.getParameterTypes();
    int size = types.size();

    // Use the above method to do the actual popping...
    popArgs(frame, size);

    // ...and then verify the popped types.

    for (int i = 0; i < size; i++) {
        if (! Merger.isPossiblyAssignableFrom(types.getType(i), args[i])) {
            throw new SimException("at stack depth " + (size - 1 - i) +
                    ", expected type " + types.getType(i).toHuman() +
                    " but found " + args[i].getType().toHuman());
        }
    }
}
 

/**
 * Gets the list of interfaces implemented.
 *
 * @return {@code non-null;} the interfaces list
 */
public TypeList getInterfaces() {
    if (interfaces == null) {
        return StdTypeList.EMPTY;
    }

    return interfaces.getList();
}
 

/**
 * Creates the short-form of the given prototype.
 *
 * @param prototype {@code non-null;} the prototype
 * @return {@code non-null;} the short form
 */
private static CstString makeShortForm(Prototype prototype) {
    StdTypeList parameters = prototype.getParameterTypes();
    int size = parameters.size();
    StringBuilder sb = new StringBuilder(size + 1);

    sb.append(shortFormCharFor(prototype.getReturnType()));

    for (int i = 0; i < size; i++) {
        sb.append(shortFormCharFor(parameters.getType(i)));
    }

    return new CstString(sb.toString());
}
 

/** {@inheritDoc} */
@Override
protected int compareTo0(OffsettedItem other) {
    TypeList thisList = this.list;
    TypeList otherList = ((TypeListItem) other).list;

    return StdTypeList.compareContents(thisList, otherList);
}
 

/** {@inheritDoc} */
@Override
public void writeTo(DexFile file, AnnotatedOutput out) {
    int shortyIdx = file.getStringIds().indexOf(shortForm);
    int returnIdx = file.getTypeIds().indexOf(prototype.getReturnType());
    int paramsOff = OffsettedItem.getAbsoluteOffsetOr0(parameterTypes);

    if (out.annotates()) {
        StringBuilder sb = new StringBuilder();
        sb.append(prototype.getReturnType().toHuman());
        sb.append(" proto(");

        StdTypeList params = prototype.getParameterTypes();
        int size = params.size();

        for (int i = 0; i < size; i++) {
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(params.getType(i).toHuman());
        }

        sb.append(")");
        out.annotate(0, indexString() + ' ' + sb.toString());
        out.annotate(4, "  shorty_idx:      " + Hex.u4(shortyIdx) +
                " // " + shortForm.toQuoted());
        out.annotate(4, "  return_type_idx: " + Hex.u4(returnIdx) +
                " // " + prototype.getReturnType().toHuman());
        out.annotate(4, "  parameters_off:  " + Hex.u4(paramsOff));
    }

    out.writeInt(shortyIdx);
    out.writeInt(returnIdx);
    out.writeInt(paramsOff);
}
 

/**
 * Constructs an instance.
 *
 * @param prototype {@code non-null;} the constant for the prototype
 */
public ProtoIdItem(Prototype prototype) {
    if (prototype == null) {
        throw new NullPointerException("prototype == null");
    }

    this.prototype = prototype;
    this.shortForm = makeShortForm(prototype);

    StdTypeList parameters = prototype.getParameterTypes();
    this.parameterTypes = (parameters.size() == 0) ? null
        : new TypeListItem(parameters);
}
 

/**
 * Initialize this frame with the method's parameters. Used for the first
 * frame.
 *
 * @param params Type list of method parameters.
 */
public void initializeWithParameters(StdTypeList params) {
    int at = 0;
    int sz = params.size();

    for (int i = 0; i < sz; i++) {
         Type one = params.get(i);
         locals.set(at, one);
         at += one.getCategory();
    }
}
 

/**
 * Gets the list of interfaces implemented.
 *
 * @return {@code non-null;} the interfaces list
 */
public TypeList getInterfaces() {
    if (interfaces == null) {
        return StdTypeList.EMPTY;
    }

    return interfaces.getList();
}
 

/**
 * Initialize this frame with the method's parameters. Used for the first
 * frame.
 *
 * @param params Type list of method parameters.
 */
public void initializeWithParameters(StdTypeList params) {
    int at = 0;
    int sz = params.size();

    for (int i = 0; i < sz; i++) {
         Type one = params.get(i);
         locals.set(at, one);
         at += one.getCategory();
    }
}
 

/**
 * Compares Insn contents, since {@code Insn.equals()} is defined
 * to be an identity compare. Insn's are {@code contentEquals()}
 * if they have the same opcode, registers, source position, and other
 * metadata.
 *
 * @return true in the case described above
 */
public boolean contentEquals(Insn b) {
    return opcode == b.getOpcode()
            && position.equals(b.getPosition())
            && (getClass() == b.getClass())
            && equalsHandleNulls(result, b.getResult())
            && equalsHandleNulls(sources, b.getSources())
            && StdTypeList.equalContents(getCatches(), b.getCatches());
}
 

/**
 * Compare ints or references. If the comparison is true, execution jumps to
 * {@code trueLabel}. If it is false, execution continues to the next
 * instruction.
 */
public <T> void compare(Comparison comparison, Label trueLabel, Local<T> a, Local<T> b) {
    adopt(trueLabel);
    Rop rop = comparison.rop(StdTypeList.make(a.type.ropType, b.type.ropType));
    addInstruction(new PlainInsn(rop, sourcePosition, null,
            RegisterSpecList.make(a.spec(), b.spec())), trueLabel);
}
 

/**
 * Constructs an instance.
 *
 * @param prototype {@code non-null;} the constant for the prototype
 */
public ProtoIdItem(Prototype prototype) {
    if (prototype == null) {
        throw new NullPointerException("prototype == null");
    }

    this.prototype = prototype;
    this.shortForm = makeShortForm(prototype);

    StdTypeList parameters = prototype.getParameterTypes();
    this.parameterTypes = (parameters.size() == 0) ? null
        : new TypeListItem(parameters);
}
 

/**
 * Creates the short-form of the given prototype.
 *
 * @param prototype {@code non-null;} the prototype
 * @return {@code non-null;} the short form
 */
private static CstString makeShortForm(Prototype prototype) {
    StdTypeList parameters = prototype.getParameterTypes();
    int size = parameters.size();
    StringBuilder sb = new StringBuilder(size + 1);

    sb.append(shortFormCharFor(prototype.getReturnType()));

    for (int i = 0; i < size; i++) {
        sb.append(shortFormCharFor(parameters.getType(i)));
    }

    return new CstString(sb.toString());
}
 

/** {@inheritDoc} */
@Override
public void writeTo(DexFile file, AnnotatedOutput out) {
    int shortyIdx = file.getStringIds().indexOf(shortForm);
    int returnIdx = file.getTypeIds().indexOf(prototype.getReturnType());
    int paramsOff = OffsettedItem.getAbsoluteOffsetOr0(parameterTypes);

    if (out.annotates()) {
        StringBuilder sb = new StringBuilder();
        sb.append(prototype.getReturnType().toHuman());
        sb.append(" proto(");

        StdTypeList params = prototype.getParameterTypes();
        int size = params.size();

        for (int i = 0; i < size; i++) {
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(params.getType(i).toHuman());
        }

        sb.append(")");
        out.annotate(0, indexString() + ' ' + sb.toString());
        out.annotate(4, "  shorty_idx:      " + Hex.u4(shortyIdx) +
                " // " + shortForm.toQuoted());
        out.annotate(4, "  return_type_idx: " + Hex.u4(returnIdx) +
                " // " + prototype.getReturnType().toHuman());
        out.annotate(4, "  parameters_off:  " + Hex.u4(paramsOff));
    }

    out.writeInt(shortyIdx);
    out.writeInt(returnIdx);
    out.writeInt(paramsOff);
}
 

/**
 * Initialize this frame with the method's parameters. Used for the first
 * frame.
 *
 * @param params Type list of method parameters.
 */
public void initializeWithParameters(StdTypeList params) {
    int at = 0;
    int sz = params.size();

    for (int i = 0; i < sz; i++) {
         Type one = params.get(i);
         locals.set(at, one);
         at += one.getCategory();
    }
}
 

/**
 * Creates the short-form of the given prototype.
 *
 * @param prototype {@code non-null;} the prototype
 * @return {@code non-null;} the short form
 */
private static CstString makeShortForm(Prototype prototype) {
    StdTypeList parameters = prototype.getParameterTypes();
    int size = parameters.size();
    StringBuilder sb = new StringBuilder(size + 1);

    sb.append(shortFormCharFor(prototype.getReturnType()));

    for (int i = 0; i < size; i++) {
        sb.append(shortFormCharFor(parameters.getType(i)));
    }

    return new CstString(sb.toString());
}
 

/**
 * Compares Insn contents, since {@code Insn.equals()} is defined
 * to be an identity compare. Insn's are {@code contentEquals()}
 * if they have the same opcode, registers, source position, and other
 * metadata.
 *
 * @return true in the case described above
 */
public boolean contentEquals(Insn b) {
    return opcode == b.getOpcode()
            && position.equals(b.getPosition())
            && (getClass() == b.getClass())
            && equalsHandleNulls(result, b.getResult())
            && equalsHandleNulls(sources, b.getSources())
            && StdTypeList.equalContents(getCatches(), b.getCatches());
}
 

/**
 * Gets the list of interfaces implemented.
 *
 * @return {@code non-null;} the interfaces list
 */
public TypeList getInterfaces() {
    if (interfaces == null) {
        return StdTypeList.EMPTY;
    }

    return interfaces.getList();
}
 

EncodedMethod toEncodedMethod(DexOptions dexOptions) {
    if (code != null) {
        RopMethod ropMethod = new RopMethod(code.toBasicBlocks(), 0);
        LocalVariableInfo locals = null;
        DalvCode dalvCode = RopTranslator.translate(
                ropMethod, PositionList.NONE, locals, code.paramSize(), dexOptions);
        return new EncodedMethod(method.constant, flags, dalvCode, StdTypeList.EMPTY);
    } else return new EncodedMethod(method.constant, flags, null, StdTypeList.EMPTY);

}
 

/**
 * Initialize this frame with the method's parameters. Used for the first
 * frame.
 *
 * @param params Type list of method parameters.
 */
public void initializeWithParameters(StdTypeList params) {
    int at = 0;
    int sz = params.size();

    for (int i = 0; i < sz; i++) {
         Type one = params.get(i);
         locals.set(at, one);
         at += one.getCategory();
    }
}
 

/**
 * Compare ints or references. If the comparison is true, execution jumps to
 * {@code trueLabel}. If it is false, execution continues to the next
 * instruction.
 */
public <T> void compare(Comparison comparison, Label trueLabel, Local<T> a, Local<T> b) {
    adopt(trueLabel);
    Rop rop = comparison.rop(StdTypeList.make(a.type.ropType, b.type.ropType));
    addInstruction(new PlainInsn(rop, sourcePosition, null,
            RegisterSpecList.make(a.spec(), b.spec())), trueLabel);
}
 

/**
 * Gets the list of thrown exceptions for a given method.
 *
 * @param method {@code non-null;} the method in question
 * @return {@code non-null;} the list of thrown exceptions
 */
public static TypeList getExceptions(Method method) {
    AttributeList attribs = method.getAttributes();
    AttExceptions exceptions = (AttExceptions)
        attribs.findFirst(AttExceptions.ATTRIBUTE_NAME);

    if (exceptions == null) {
        return StdTypeList.EMPTY;
    }

    return exceptions.getExceptions();
}