本文整理汇总了Java中com.android.dx.rop.type.Type.OBJECT属性的典型用法代码示例。如果您正苦于以下问题:Java Type.OBJECT属性的具体用法?Java Type.OBJECT怎么用?Java Type.OBJECT使用的例子?那么恭喜您, 这里精选的属性代码示例或许可以为您提供帮助。您也可以进一步了解该属性所在类com.android.dx.rop.type.Type
的用法示例。
在下文中一共展示了Type.OBJECT属性的4个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: requiredArrayTypeFor
/**
* 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();
}
示例2: mergeType
/**
* 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;
}
}
}
示例3: getLocalTarget
/**
* 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;
}
示例4: requiredArrayTypeFor
/**
* 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();
}