Merge "Redesign array type lattice element."
diff --git a/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java b/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
index 16a03e2..53907db 100644
--- a/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
+++ b/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
@@ -193,7 +193,7 @@
if (result.isClassType()) {
return result.asClassTypeLatticeElement().getClassType();
} else if (result.isArrayType()) {
- return result.asArrayTypeLatticeElement().getArrayType();
+ return result.asArrayTypeLatticeElement().getArrayType(factory);
}
throw new CompilationError("Unexpected join " + result + " of types: " +
String.join(", ",
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 0b07644..952038a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -18,10 +18,12 @@
import com.android.tools.r8.ir.analysis.type.ArrayTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.ReferenceTypeLatticeElement;
+import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.utils.ArrayUtils;
+import com.android.tools.r8.utils.LRUCacheTable;
import com.google.common.base.Strings;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
@@ -66,6 +68,8 @@
// ReferenceTypeLattice canonicalization.
private final ConcurrentHashMap<DexType, ReferenceTypeLatticeElement>
referenceTypeLatticeElements = new ConcurrentHashMap<>();
+ public static final LRUCacheTable<Set<DexType>, Set<DexType>, Set<DexType>>
+ leastUpperBoundOfInterfacesTable = LRUCacheTable.create(8, 8);
boolean sorted = false;
@@ -1009,7 +1013,10 @@
}
} else {
assert type.isArrayType();
- typeLattice = new ArrayTypeLatticeElement(type, isNullable);
+ DexType elementType = type.toArrayElementType(this);
+ TypeLatticeElement elementTypeLattice =
+ TypeLatticeElement.fromDexType(elementType, true, appInfo, true);
+ typeLattice = new ArrayTypeLatticeElement(elementTypeLattice, isNullable);
}
referenceTypeLatticeElements.put(type, typeLattice);
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/TypeChecker.java b/src/main/java/com/android/tools/r8/ir/analysis/TypeChecker.java
index 96227c4..0da99ae 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/TypeChecker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/TypeChecker.java
@@ -70,24 +70,22 @@
instruction.isInstancePut()
? instruction.asInstancePut().value()
: instruction.asStaticPut().inValue();
- TypeLatticeElement fieldType =
- TypeLatticeElement.fromDexType(instruction.getField().type, true, appInfo);
TypeLatticeElement valueType = value.getTypeLattice();
+ TypeLatticeElement fieldType = TypeLatticeElement.fromDexType(
+ instruction.getField().type, valueType.isNullable(), appInfo);
return isSubtypeOf(valueType, fieldType);
}
public boolean check(Throw instruction) {
- TypeLatticeElement throwableType =
- TypeLatticeElement.fromDexType(appInfo.dexItemFactory.throwableType, true, appInfo);
TypeLatticeElement valueType = instruction.exception().getTypeLattice();
+ TypeLatticeElement throwableType = TypeLatticeElement.fromDexType(
+ appInfo.dexItemFactory.throwableType, valueType.isNullable(), appInfo);
return isSubtypeOf(valueType, throwableType);
}
private boolean isSubtypeOf(
TypeLatticeElement expectedSubtype, TypeLatticeElement expectedSupertype) {
return expectedSubtype.lessThanOrEqual(expectedSupertype, appInfo)
- || expectedSubtype.isBasedOnMissingClass(appInfo)
- // TODO(b/119181813): Remove this relaxation when the join of array types is fixed.
- || (expectedSubtype.isArrayType() && expectedSupertype.isArrayType());
+ || expectedSubtype.isBasedOnMissingClass(appInfo);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ArrayTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ArrayTypeLatticeElement.java
index 4ff54d3..6bb13a7 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ArrayTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ArrayTypeLatticeElement.java
@@ -9,25 +9,49 @@
public class ArrayTypeLatticeElement extends ReferenceTypeLatticeElement {
- public ArrayTypeLatticeElement(DexType type, boolean isNullable) {
- super(type, isNullable);
- assert type.isArrayType();
+ private final TypeLatticeElement memberTypeLattice;
+
+ public ArrayTypeLatticeElement(TypeLatticeElement memberTypeLattice, boolean isNullable) {
+ super(isNullable, null);
+ this.memberTypeLattice = memberTypeLattice;
}
- public DexType getArrayType() {
- return type;
+ public DexType getArrayType(DexItemFactory factory) {
+ TypeLatticeElement baseTypeLattice = getArrayBaseTypeLattice();
+ DexType baseType;
+ if (baseTypeLattice.isPrimitive()) {
+ baseType = baseTypeLattice.asPrimitiveTypeLatticeElement().toDexType(factory);
+ } else {
+ assert baseTypeLattice.isClassType();
+ baseType = baseTypeLattice.asClassTypeLatticeElement().getClassType();
+ }
+ return factory.createArrayType(getNesting(), baseType);
}
- public int getNesting() {
- return type.getNumberOfLeadingSquareBrackets();
+ int getNesting() {
+ int nesting = 1;
+ TypeLatticeElement member = getArrayMemberTypeAsMemberType();
+ while (member.isArrayType()) {
+ ++nesting;
+ member = member.asArrayTypeLatticeElement().getArrayMemberTypeAsMemberType();
+ }
+ return nesting;
}
- public DexType getArrayElementType(DexItemFactory factory) {
- return type.toArrayElementType(factory);
+ TypeLatticeElement getArrayMemberTypeAsMemberType() {
+ return memberTypeLattice;
}
- public DexType getArrayBaseType(DexItemFactory factory) {
- return type.toBaseType(factory);
+ public TypeLatticeElement getArrayMemberTypeAsValueType() {
+ return memberTypeLattice.isFineGrainedType() ? INT : memberTypeLattice;
+ }
+
+ private TypeLatticeElement getArrayBaseTypeLattice() {
+ TypeLatticeElement base = getArrayMemberTypeAsMemberType();
+ while (base.isArrayType()) {
+ base = base.asArrayTypeLatticeElement().getArrayMemberTypeAsMemberType();
+ }
+ return base;
}
@Override
@@ -37,7 +61,8 @@
}
synchronized (this) {
if (dual == null) {
- ArrayTypeLatticeElement dual = new ArrayTypeLatticeElement(type, !isNullable());
+ ArrayTypeLatticeElement dual =
+ new ArrayTypeLatticeElement(memberTypeLattice, !isNullable());
linkDualLattice(this, dual);
}
}
@@ -56,7 +81,7 @@
@Override
public boolean isBasedOnMissingClass(AppInfo appInfo) {
- return getArrayBaseType(appInfo.dexItemFactory).isMissingOrHasMissingSuperType(appInfo);
+ return memberTypeLattice.isBasedOnMissingClass(appInfo);
}
@Override
@@ -70,13 +95,55 @@
}
@Override
- public TypeLatticeElement arrayGet(AppInfo appInfo) {
- return fromDexType(getArrayElementType(appInfo.dexItemFactory), true, appInfo);
+ public String toString() {
+ return memberTypeLattice.toString() + "[]";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof ArrayTypeLatticeElement)) {
+ return false;
+ }
+ ArrayTypeLatticeElement other = (ArrayTypeLatticeElement) o;
+ if (isNullable() != other.isNullable()) {
+ return false;
+ }
+ if (type != null && other.type != null && !type.equals(other.type)) {
+ return false;
+ }
+ return memberTypeLattice.equals(other.memberTypeLattice);
}
@Override
public int hashCode() {
- return (isNullable() ? 1 : -1) * type.hashCode();
+ return (isNullable() ? 1 : -1) * memberTypeLattice.hashCode();
+ }
+
+ ReferenceTypeLatticeElement join(ArrayTypeLatticeElement other, AppInfo appInfo) {
+ TypeLatticeElement aMember = getArrayMemberTypeAsMemberType();
+ TypeLatticeElement bMember = other.getArrayMemberTypeAsMemberType();
+ if (aMember.equals(bMember)) {
+ // Return null indicating the join is the same as the member to avoid object allocation.
+ return null;
+ }
+ boolean isNullable = isNullable() || other.isNullable();
+ if (aMember.isArrayType() && bMember.isArrayType()) {
+ ReferenceTypeLatticeElement join =
+ aMember.asArrayTypeLatticeElement().join(bMember.asArrayTypeLatticeElement(), appInfo);
+ return join == null ? null : new ArrayTypeLatticeElement(join, isNullable);
+ }
+ if (aMember.isClassType() && bMember.isClassType()) {
+ ClassTypeLatticeElement join =
+ aMember.asClassTypeLatticeElement().join(bMember.asClassTypeLatticeElement(), appInfo);
+ return join == null ? null : new ArrayTypeLatticeElement(join, isNullable);
+ }
+ if (aMember.isPrimitive() || bMember.isPrimitive()) {
+ return objectClassType(appInfo, isNullable);
+ }
+ return objectArrayType(appInfo, isNullable);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/BooleanTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/BooleanTypeLatticeElement.java
new file mode 100644
index 0000000..abcdb9e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/BooleanTypeLatticeElement.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.analysis.type;
+
+public class BooleanTypeLatticeElement extends PrimitiveTypeLatticeElement {
+ private static final BooleanTypeLatticeElement INSTANCE = new BooleanTypeLatticeElement();
+
+ static BooleanTypeLatticeElement getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ boolean isBoolean() {
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "BOOLEAN";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return this == o;
+ }
+
+ @Override
+ public int hashCode() {
+ return System.identityHashCode(INSTANCE);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/BottomTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/BottomTypeLatticeElement.java
index 6931b46..e86d66f 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/BottomTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/BottomTypeLatticeElement.java
@@ -28,11 +28,6 @@
}
@Override
- public TypeLatticeElement arrayGet(AppInfo appInfo) {
- return this;
- }
-
- @Override
public TypeLatticeElement checkCast(AppInfo appInfo, DexType castType) {
return this;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ByteTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ByteTypeLatticeElement.java
new file mode 100644
index 0000000..d05c25e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ByteTypeLatticeElement.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.analysis.type;
+
+public class ByteTypeLatticeElement extends PrimitiveTypeLatticeElement {
+ private static final ByteTypeLatticeElement INSTANCE = new ByteTypeLatticeElement();
+
+ static ByteTypeLatticeElement getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ boolean isByte() {
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "BYTE";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return this == o;
+ }
+
+ @Override
+ public int hashCode() {
+ return System.identityHashCode(INSTANCE);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/CharTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/CharTypeLatticeElement.java
new file mode 100644
index 0000000..27834aa
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/CharTypeLatticeElement.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.analysis.type;
+
+public class CharTypeLatticeElement extends PrimitiveTypeLatticeElement {
+ private static final CharTypeLatticeElement INSTANCE = new CharTypeLatticeElement();
+
+ static CharTypeLatticeElement getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ boolean isChar() {
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "BYTE";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return this == o;
+ }
+
+ @Override
+ public int hashCode() {
+ return System.identityHashCode(INSTANCE);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
index 84146a2..c25395d 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ClassTypeLatticeElement.java
@@ -4,7 +4,14 @@
package com.android.tools.r8.ir.analysis.type;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexType;
+import com.google.common.collect.ImmutableSet;
+import java.util.ArrayDeque;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Queue;
import java.util.Set;
import java.util.stream.Collectors;
@@ -23,7 +30,7 @@
private ClassTypeLatticeElement(
DexType classType, boolean isNullable, Set<DexType> interfaces, AppInfo appInfo) {
- super(classType, isNullable);
+ super(isNullable, classType);
assert classType.isClassType();
appInfoForLazyInterfacesComputation = appInfo;
lazyInterfaces = interfaces;
@@ -42,8 +49,7 @@
if (lazyInterfaces == null) {
Set<DexType> itfs = type.implementedInterfaces(appInfoForLazyInterfacesComputation);
lazyInterfaces =
- TypeLatticeElement.computeLeastUpperBoundOfInterfaces(
- appInfoForLazyInterfacesComputation, itfs, itfs);
+ computeLeastUpperBoundOfInterfaces(appInfoForLazyInterfacesComputation, itfs, itfs);
appInfoForLazyInterfacesComputation = null;
}
}
@@ -96,10 +102,10 @@
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(super.toString());
- builder.append(" [");
+ builder.append(" {");
builder.append(
getInterfaces().stream().map(DexType::toString).collect(Collectors.joining(", ")));
- builder.append("]");
+ builder.append("}");
return builder.toString();
}
@@ -108,4 +114,115 @@
// The interfaces of a type do not contribute to its hashCode as they are lazily computed.
return (isNullable() ? 1 : -1) * type.hashCode();
}
+
+ ClassTypeLatticeElement join(ClassTypeLatticeElement other, AppInfo appInfo) {
+ DexType lubType = getClassType().computeLeastUpperBoundOfClasses(appInfo, other.getClassType());
+ Set<DexType> c1lubItfs = getInterfaces();
+ Set<DexType> c2lubItfs = other.getInterfaces();
+ Set<DexType> lubItfs = null;
+ if (c1lubItfs.size() == c2lubItfs.size() && c1lubItfs.containsAll(c2lubItfs)) {
+ lubItfs = c1lubItfs;
+ }
+ if (lubItfs == null) {
+ lubItfs = computeLeastUpperBoundOfInterfaces(appInfo, c1lubItfs, c2lubItfs);
+ }
+ boolean isNullable = isNullable() || other.isNullable();
+ return new ClassTypeLatticeElement(lubType, isNullable, lubItfs);
+ }
+
+ private enum InterfaceMarker {
+ LEFT,
+ RIGHT
+ }
+
+ private static class InterfaceWithMarker {
+ final DexType itf;
+ final InterfaceMarker marker;
+
+ InterfaceWithMarker(DexType itf, InterfaceMarker marker) {
+ this.itf = itf;
+ this.marker = marker;
+ }
+ }
+
+ static Set<DexType> computeLeastUpperBoundOfInterfaces(
+ AppInfo appInfo, Set<DexType> s1, Set<DexType> s2) {
+ Set<DexType> cached = appInfo.dexItemFactory.leastUpperBoundOfInterfacesTable.get(s1, s2);
+ if (cached != null) {
+ return cached;
+ }
+ cached = appInfo.dexItemFactory.leastUpperBoundOfInterfacesTable.get(s2, s1);
+ if (cached != null) {
+ return cached;
+ }
+ Map<DexType, Set<InterfaceMarker>> seen = new IdentityHashMap<>();
+ Queue<InterfaceWithMarker> worklist = new ArrayDeque<>();
+ for (DexType itf1 : s1) {
+ worklist.add(new InterfaceWithMarker(itf1, InterfaceMarker.LEFT));
+ }
+ for (DexType itf2 : s2) {
+ worklist.add(new InterfaceWithMarker(itf2, InterfaceMarker.RIGHT));
+ }
+ while (!worklist.isEmpty()) {
+ InterfaceWithMarker item = worklist.poll();
+ DexType itf = item.itf;
+ InterfaceMarker marker = item.marker;
+ Set<InterfaceMarker> markers = seen.computeIfAbsent(itf, k -> new HashSet<>());
+ // If this interface is a lower one in this set, skip.
+ if (markers.contains(marker)) {
+ continue;
+ }
+ // If this interface is already visited by the other set, add marker for this set and skip.
+ if (markers.size() == 1) {
+ markers.add(marker);
+ continue;
+ }
+ // Otherwise, this type is freshly visited.
+ markers.add(marker);
+ // Put super interfaces into the worklist.
+ DexClass itfClass = appInfo.definitionFor(itf);
+ if (itfClass != null) {
+ for (DexType superItf : itfClass.interfaces.values) {
+ markers = seen.computeIfAbsent(superItf, k -> new HashSet<>());
+ if (!markers.contains(marker)) {
+ worklist.add(new InterfaceWithMarker(superItf, marker));
+ }
+ }
+ }
+ }
+
+ ImmutableSet.Builder<DexType> commonBuilder = ImmutableSet.builder();
+ for (Map.Entry<DexType, Set<InterfaceMarker>> entry : seen.entrySet()) {
+ // Keep commonly visited interfaces only
+ if (entry.getValue().size() < 2) {
+ continue;
+ }
+ commonBuilder.add(entry.getKey());
+ }
+ Set<DexType> commonlyVisited = commonBuilder.build();
+
+ ImmutableSet.Builder<DexType> lubBuilder = ImmutableSet.builder();
+ for (DexType itf : commonlyVisited) {
+ // If there is a strict sub interface of this interface, it is not the least element.
+ boolean notTheLeast = false;
+ for (DexType other : commonlyVisited) {
+ if (other.isStrictSubtypeOf(itf, appInfo)) {
+ notTheLeast = true;
+ break;
+ }
+ }
+ if (notTheLeast) {
+ continue;
+ }
+ lubBuilder.add(itf);
+ }
+ Set<DexType> lub = lubBuilder.build();
+ // Cache the computation result only if the given two sets of interfaces are different.
+ if (s1.size() != s2.size() || !s1.containsAll(s2)) {
+ synchronized (appInfo.dexItemFactory.leastUpperBoundOfInterfacesTable) {
+ appInfo.dexItemFactory.leastUpperBoundOfInterfacesTable.put(s1, s2, lub);
+ }
+ }
+ return lub;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/PrimitiveTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/PrimitiveTypeLatticeElement.java
index 51097d8..4c633f5 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/PrimitiveTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/PrimitiveTypeLatticeElement.java
@@ -5,6 +5,7 @@
import com.android.tools.r8.errors.InternalCompilerError;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.NumericType;
@@ -32,17 +33,62 @@
return this;
}
- public static PrimitiveTypeLatticeElement fromDexType(DexType type) {
+ static PrimitiveTypeLatticeElement fromDexType(DexType type, boolean asArrayElementType) {
assert type.isPrimitiveType();
- return fromTypeDescriptorChar((char) type.descriptor.content[0]);
+ return fromTypeDescriptorChar((char) type.descriptor.content[0], asArrayElementType);
}
- public static PrimitiveTypeLatticeElement fromTypeDescriptorChar(char descriptor) {
+ DexType toDexType(DexItemFactory factory) {
+ if (isBoolean()) {
+ return factory.booleanType;
+ }
+ if (isByte()) {
+ return factory.byteType;
+ }
+ if (isShort()) {
+ return factory.shortType;
+ }
+ if (isChar()) {
+ return factory.charType;
+ }
+ if (isInt()) {
+ return factory.intType;
+ }
+ if (isFloat()) {
+ return factory.floatType;
+ }
+ if (isLong()) {
+ return factory.longType;
+ }
+ if (isDouble()) {
+ return factory.doubleType;
+ }
+ throw new Unreachable("Imprecise primitive type '" + toString() + "'");
+ }
+
+ private static PrimitiveTypeLatticeElement fromTypeDescriptorChar(
+ char descriptor, boolean asArrayElementType) {
switch (descriptor) {
case 'Z':
+ if (asArrayElementType) {
+ return TypeLatticeElement.BOOLEAN;
+ }
+ // fall through
case 'B':
+ if (asArrayElementType) {
+ return TypeLatticeElement.BYTE;
+ }
+ // fall through
case 'S':
+ if (asArrayElementType) {
+ return TypeLatticeElement.SHORT;
+ }
+ // fall through
case 'C':
+ if (asArrayElementType) {
+ return TypeLatticeElement.CHAR;
+ }
+ // fall through
case 'I':
return TypeLatticeElement.INT;
case 'F':
@@ -76,23 +122,22 @@
}
}
- public static TypeLatticeElement join(
- PrimitiveTypeLatticeElement t1, PrimitiveTypeLatticeElement t2) {
- if (t1 == t2) {
- return t1;
+ TypeLatticeElement join(PrimitiveTypeLatticeElement other) {
+ if (this == other) {
+ return this;
}
- if (t1.isSingle()) {
- if (t2.isSingle()) {
+ if (isSingle()) {
+ if (other.isSingle()) {
return TypeLatticeElement.SINGLE;
}
- assert t2.isWide();
+ assert other.isWide();
return TypeLatticeElement.TOP;
}
- assert t1.isWide();
- if (t2.isWide()) {
+ assert isWide();
+ if (other.isWide()) {
return TypeLatticeElement.WIDE;
}
- assert t2.isSingle();
+ assert other.isSingle();
return TypeLatticeElement.TOP;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ReferenceTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ReferenceTypeLatticeElement.java
index 423c8cc..e7282e1 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/ReferenceTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ReferenceTypeLatticeElement.java
@@ -11,8 +11,9 @@
public class ReferenceTypeLatticeElement extends TypeLatticeElement {
private static final ReferenceTypeLatticeElement NULL_INSTANCE =
- new ReferenceTypeLatticeElement(DexItemFactory.nullValueType, true);
+ new ReferenceTypeLatticeElement(true, DexItemFactory.nullValueType);
+ // TODO(b/72693244): Consider moving this to ClassTypeLatticeElement.
final DexType type;
// Link between maybe-null and definitely-not-null reference type lattices.
@@ -28,7 +29,7 @@
t2.dual = t1;
}
- ReferenceTypeLatticeElement(DexType type, boolean isNullable) {
+ ReferenceTypeLatticeElement(boolean isNullable, DexType type) {
super(isNullable);
this.type = type;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/ShortTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/ShortTypeLatticeElement.java
new file mode 100644
index 0000000..6b56f08
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/ShortTypeLatticeElement.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.analysis.type;
+
+public class ShortTypeLatticeElement extends PrimitiveTypeLatticeElement {
+ private static final ShortTypeLatticeElement INSTANCE = new ShortTypeLatticeElement();
+
+ static ShortTypeLatticeElement getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ boolean isShort() {
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "SHORT";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return this == o;
+ }
+
+ @Override
+ public int hashCode() {
+ return System.identityHashCode(INSTANCE);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/TopTypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/TopTypeLatticeElement.java
index 4ffe7b1..5221ae3 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/TopTypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/TopTypeLatticeElement.java
@@ -28,11 +28,6 @@
}
@Override
- public TypeLatticeElement arrayGet(AppInfo appInfo) {
- return this;
- }
-
- @Override
public TypeLatticeElement checkCast(AppInfo appInfo, DexType castType) {
return this;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeLatticeElement.java b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeLatticeElement.java
index 7b1e28a..b29cd31 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeLatticeElement.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeLatticeElement.java
@@ -5,19 +5,10 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.NumericType;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.utils.LRUCacheTable;
-import com.google.common.collect.ImmutableSet;
-import java.util.ArrayDeque;
-import java.util.HashSet;
-import java.util.IdentityHashMap;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
/**
* The base abstraction of lattice elements for local type analysis.
@@ -25,6 +16,10 @@
public abstract class TypeLatticeElement {
public static final BottomTypeLatticeElement BOTTOM = BottomTypeLatticeElement.getInstance();
public static final TopTypeLatticeElement TOP = TopTypeLatticeElement.getInstance();
+ static final BooleanTypeLatticeElement BOOLEAN = BooleanTypeLatticeElement.getInstance();
+ static final ByteTypeLatticeElement BYTE = ByteTypeLatticeElement.getInstance();
+ static final ShortTypeLatticeElement SHORT = ShortTypeLatticeElement.getInstance();
+ static final CharTypeLatticeElement CHAR = CharTypeLatticeElement.getInstance();
public static final IntTypeLatticeElement INT = IntTypeLatticeElement.getInstance();
public static final FloatTypeLatticeElement FLOAT = FloatTypeLatticeElement.getInstance();
public static final SingleTypeLatticeElement SINGLE = SingleTypeLatticeElement.getInstance();
@@ -34,8 +29,6 @@
public static final ReferenceTypeLatticeElement NULL =
ReferenceTypeLatticeElement.getNullTypeLatticeElement();
- private static final LRUCacheTable<Set<DexType>, Set<DexType>, Set<DexType>>
- leastUpperBoundOfInterfacesTable = LRUCacheTable.create(8, 8);
// TODO(b/72693244): Switch to NullLatticeElement.
private final boolean isNullable;
@@ -106,8 +99,7 @@
}
if (isPrimitive()) {
return other.isPrimitive()
- ? PrimitiveTypeLatticeElement.join(
- asPrimitiveTypeLatticeElement(), other.asPrimitiveTypeLatticeElement())
+ ? asPrimitiveTypeLatticeElement().join(other.asPrimitiveTypeLatticeElement())
: TOP;
}
if (other.isPrimitive()) {
@@ -124,157 +116,17 @@
// From now on, getClass() == other.getClass()
if (isArrayType()) {
assert other.isArrayType();
- ArrayTypeLatticeElement a1 = asArrayTypeLatticeElement();
- ArrayTypeLatticeElement a2 = other.asArrayTypeLatticeElement();
- // Identical types are the same elements
- if (a1.getArrayType() == a2.getArrayType()) {
- return a1.isNullable() ? a1 : a2;
- }
- // If non-equal, find the inner-most reference types for each.
- DexType a1BaseReferenceType = a1.getArrayBaseType(appInfo.dexItemFactory);
- int a1Nesting = a1.getNesting();
- if (a1BaseReferenceType.isPrimitiveType()) {
- a1Nesting--;
- a1BaseReferenceType = appInfo.dexItemFactory.objectType;
- }
- DexType a2BaseReferenceType = a2.getArrayBaseType(appInfo.dexItemFactory);
- int a2Nesting = a2.getNesting();
- if (a2BaseReferenceType.isPrimitiveType()) {
- a2Nesting--;
- a2BaseReferenceType = appInfo.dexItemFactory.objectType;
- }
- assert a1BaseReferenceType.isClassType() && a2BaseReferenceType.isClassType();
- // If any nestings hit zero object is the join.
- if (a1Nesting == 0 || a2Nesting == 0) {
- return objectClassType(appInfo, isNullable);
- }
- // If the nestings differ the join is the smallest nesting level.
- if (a1Nesting != a2Nesting) {
- int min = Math.min(a1Nesting, a2Nesting);
- return objectArrayType(appInfo, min, isNullable);
- }
- // For different class element types, compute the least upper bound of element types.
- DexType baseTypeLub =
- a1BaseReferenceType.computeLeastUpperBoundOfClasses(appInfo, a2BaseReferenceType);
- // Create the full array type.
- DexType arrayTypeLub = appInfo.dexItemFactory.createArrayType(a1Nesting, baseTypeLub);
- return fromDexType(arrayTypeLub, isNullable, appInfo);
+ TypeLatticeElement join =
+ asArrayTypeLatticeElement().join(other.asArrayTypeLatticeElement(), appInfo);
+ return join != null ? join : (isNullable() ? this : other);
}
if (isClassType()) {
assert other.isClassType();
- ClassTypeLatticeElement c1 = asClassTypeLatticeElement();
- ClassTypeLatticeElement c2 = other.asClassTypeLatticeElement();
- DexType lubType =
- c1.getClassType().computeLeastUpperBoundOfClasses(appInfo, c2.getClassType());
- Set<DexType> c1lubItfs = c1.getInterfaces();
- Set<DexType> c2lubItfs = c2.getInterfaces();
- Set<DexType> lubItfs = null;
- if (c1lubItfs.size() == c2lubItfs.size() && c1lubItfs.containsAll(c2lubItfs)) {
- lubItfs = c1lubItfs;
- }
- if (lubItfs == null) {
- lubItfs = computeLeastUpperBoundOfInterfaces(appInfo, c1lubItfs, c2lubItfs);
- }
- return new ClassTypeLatticeElement(lubType, isNullable, lubItfs);
+ return asClassTypeLatticeElement().join(other.asClassTypeLatticeElement(), appInfo);
}
throw new Unreachable("unless a new type lattice is introduced.");
}
- private enum InterfaceMarker {
- LEFT,
- RIGHT
- }
-
- private static class InterfaceWithMarker {
- final DexType itf;
- final InterfaceMarker marker;
-
- InterfaceWithMarker(DexType itf, InterfaceMarker marker) {
- this.itf = itf;
- this.marker = marker;
- }
- }
-
- public static Set<DexType> computeLeastUpperBoundOfInterfaces(
- AppInfo appInfo, Set<DexType> s1, Set<DexType> s2) {
- Set<DexType> cached = leastUpperBoundOfInterfacesTable.get(s1, s2);
- if (cached != null) {
- return cached;
- }
- cached = leastUpperBoundOfInterfacesTable.get(s2, s1);
- if (cached != null) {
- return cached;
- }
- Map<DexType, Set<InterfaceMarker>> seen = new IdentityHashMap<>();
- Queue<InterfaceWithMarker> worklist = new ArrayDeque<>();
- for (DexType itf1 : s1) {
- worklist.add(new InterfaceWithMarker(itf1, InterfaceMarker.LEFT));
- }
- for (DexType itf2 : s2) {
- worklist.add(new InterfaceWithMarker(itf2, InterfaceMarker.RIGHT));
- }
- while (!worklist.isEmpty()) {
- InterfaceWithMarker item = worklist.poll();
- DexType itf = item.itf;
- InterfaceMarker marker = item.marker;
- Set<InterfaceMarker> markers = seen.computeIfAbsent(itf, k -> new HashSet<>());
- // If this interface is a lower one in this set, skip.
- if (markers.contains(marker)) {
- continue;
- }
- // If this interface is already visited by the other set, add marker for this set and skip.
- if (markers.size() == 1) {
- markers.add(marker);
- continue;
- }
- // Otherwise, this type is freshly visited.
- markers.add(marker);
- // Put super interfaces into the worklist.
- DexClass itfClass = appInfo.definitionFor(itf);
- if (itfClass != null) {
- for (DexType superItf : itfClass.interfaces.values) {
- markers = seen.computeIfAbsent(superItf, k -> new HashSet<>());
- if (!markers.contains(marker)) {
- worklist.add(new InterfaceWithMarker(superItf, marker));
- }
- }
- }
- }
-
- ImmutableSet.Builder<DexType> commonBuilder = ImmutableSet.builder();
- for (Map.Entry<DexType, Set<InterfaceMarker>> entry : seen.entrySet()) {
- // Keep commonly visited interfaces only
- if (entry.getValue().size() < 2) {
- continue;
- }
- commonBuilder.add(entry.getKey());
- }
- Set<DexType> commonlyVisited = commonBuilder.build();
-
- ImmutableSet.Builder<DexType> lubBuilder = ImmutableSet.builder();
- for (DexType itf : commonlyVisited) {
- // If there is a strict sub interface of this interface, it is not the least element.
- boolean notTheLeast = false;
- for (DexType other : commonlyVisited) {
- if (other.isStrictSubtypeOf(itf, appInfo)) {
- notTheLeast = true;
- break;
- }
- }
- if (notTheLeast) {
- continue;
- }
- lubBuilder.add(itf);
- }
- Set<DexType> lub = lubBuilder.build();
- // Cache the computation result only if the given two sets of interfaces are different.
- if (s1.size() != s2.size() || !s1.containsAll(s2)) {
- synchronized (leastUpperBoundOfInterfacesTable) {
- leastUpperBoundOfInterfacesTable.put(s1, s2, lub);
- }
- }
- return lub;
- }
public static TypeLatticeElement join(
Iterable<TypeLatticeElement> typeLattices, AppInfo appInfo) {
@@ -383,6 +235,22 @@
return false;
}
+ boolean isBoolean() {
+ return false;
+ }
+
+ boolean isByte() {
+ return false;
+ }
+
+ boolean isShort() {
+ return false;
+ }
+
+ boolean isChar() {
+ return false;
+ }
+
public boolean isInt() {
return false;
}
@@ -410,6 +278,13 @@
|| isBottom();
}
+ public boolean isFineGrainedType() {
+ return isBoolean()
+ || isByte()
+ || isShort()
+ || isChar();
+ }
+
/**
* Should use {@link #isConstantNull()} or {@link #isDefinitelyNull()} instead.
*/
@@ -444,14 +319,17 @@
return isWide() ? 2 : 1;
}
- static TypeLatticeElement objectClassType(AppInfo appInfo, boolean isNullable) {
- return fromDexType(appInfo.dexItemFactory.objectType, isNullable, appInfo);
+ static ClassTypeLatticeElement objectClassType(AppInfo appInfo, boolean isNullable) {
+ return fromDexType(appInfo.dexItemFactory.objectType, isNullable, appInfo)
+ .asClassTypeLatticeElement();
}
- static TypeLatticeElement objectArrayType(AppInfo appInfo, int nesting, boolean isNullable) {
+ static ArrayTypeLatticeElement objectArrayType(AppInfo appInfo, boolean isNullable) {
return fromDexType(
- appInfo.dexItemFactory.createArrayType(nesting, appInfo.dexItemFactory.objectType),
- isNullable, appInfo);
+ appInfo.dexItemFactory.createArrayType(1, appInfo.dexItemFactory.objectType),
+ isNullable,
+ appInfo)
+ .asArrayTypeLatticeElement();
}
public static TypeLatticeElement classClassType(AppInfo appInfo) {
@@ -463,11 +341,16 @@
}
public static TypeLatticeElement fromDexType(DexType type, boolean isNullable, AppInfo appInfo) {
+ return fromDexType(type, isNullable, appInfo, false);
+ }
+
+ public static TypeLatticeElement fromDexType(
+ DexType type, boolean isNullable, AppInfo appInfo, boolean asArrayElementType) {
if (type == DexItemFactory.nullValueType) {
return NULL;
}
if (type.isPrimitiveType()) {
- return PrimitiveTypeLatticeElement.fromDexType(type);
+ return PrimitiveTypeLatticeElement.fromDexType(type, asArrayElementType);
}
return appInfo.dexItemFactory.createReferenceTypeLatticeElement(type, isNullable, appInfo);
}
@@ -496,14 +379,6 @@
|| (isWide() && other.isWide());
}
- public static TypeLatticeElement newArray(DexType arrayType, boolean isNullable) {
- return new ArrayTypeLatticeElement(arrayType, isNullable);
- }
-
- public TypeLatticeElement arrayGet(AppInfo appInfo) {
- return BOTTOM;
- }
-
public TypeLatticeElement checkCast(AppInfo appInfo, DexType castType) {
TypeLatticeElement castTypeLattice = fromDexType(castType, isNullable(), appInfo);
if (lessThanOrEqual(castTypeLattice, appInfo)) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java b/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
index 2549eaa..3879639 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.type.ArrayTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
@@ -170,29 +171,47 @@
@Override
public TypeLatticeElement evaluate(AppInfo appInfo) {
+ ArrayTypeLatticeElement arrayTypeLattice = array().getTypeLattice().isArrayType()
+ ? array().getTypeLattice().asArrayTypeLatticeElement()
+ : null;
switch (getMemberType()) {
case OBJECT:
// If the out-type of the array is bottom (the input array must be definitely null), then
// the instruction cannot return. For now we return NULL as the type to ensure we have a
// type consistent witness for the out-value type. We could consider returning bottom in
// this case as the value is indeed empty, i.e., the instruction will always fail.
- TypeLatticeElement outType = array().getTypeLattice().arrayGet(appInfo);
- return outType.isBottom() ? TypeLatticeElement.NULL : outType;
+ TypeLatticeElement valueType = arrayTypeLattice == null
+ ? TypeLatticeElement.NULL
+ : arrayTypeLattice.getArrayMemberTypeAsValueType();
+ assert valueType.isReference();
+ return valueType;
case BOOLEAN:
case BYTE:
case CHAR:
case SHORT:
case INT:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isInt();
return TypeLatticeElement.INT;
case FLOAT:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isFloat();
return TypeLatticeElement.FLOAT;
case LONG:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isLong();
return TypeLatticeElement.LONG;
case DOUBLE:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isDouble();
return TypeLatticeElement.DOUBLE;
case INT_OR_FLOAT:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isSingle();
return checkConstraint(dest(), ValueTypeConstraint.INT_OR_FLOAT);
case LONG_OR_DOUBLE:
+ assert arrayTypeLattice == null
+ || arrayTypeLattice.getArrayMemberTypeAsValueType().isWide();
return checkConstraint(dest(), ValueTypeConstraint.LONG_OR_DOUBLE);
default:
throw new Unreachable("Unexpected member type: " + getMemberType());
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index e11f1bd..6022b6d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -679,6 +679,7 @@
return verifySSATypeLattice(
v -> {
assert v.getTypeLattice().isPreciseType();
+ assert !v.getTypeLattice().isFineGrainedType();
// For now we assume no bottom types on IR values. We may want to reconsider this for
// representing unreachable code.
assert !v.getTypeLattice().isBottom();
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index 3738542..a008185 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -1208,7 +1208,7 @@
DexType outBaseType =
outTypeLatticeElement
.asArrayTypeLatticeElement()
- .getArrayType()
+ .getArrayType(appInfo.dexItemFactory)
.toBaseType(appInfo.dexItemFactory);
assert graphLense.lookupType(outBaseType) == outBaseType;
} else if (outTypeLatticeElement.isClassType()) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
index cfd3b1d..2f28110 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMultiNewArray.java
@@ -67,7 +67,7 @@
@Override
public TypeLatticeElement evaluate(AppInfo appInfo) {
- return TypeLatticeElement.newArray(type, false);
+ return TypeLatticeElement.fromDexType(type, false, appInfo);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
index df74e17..c49650a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
@@ -97,7 +97,7 @@
@Override
public TypeLatticeElement evaluate(AppInfo appInfo) {
- return TypeLatticeElement.newArray(type, false);
+ return TypeLatticeElement.fromDexType(type, false, appInfo);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java b/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
index 95a9225..09ea5af 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewArrayEmpty.java
@@ -107,6 +107,6 @@
@Override
public TypeLatticeElement evaluate(AppInfo appInfo) {
- return TypeLatticeElement.newArray(type, false);
+ return TypeLatticeElement.fromDexType(type, false, appInfo);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/ValueTypeConstraint.java b/src/main/java/com/android/tools/r8/ir/code/ValueTypeConstraint.java
index 8371375..9c376fb 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ValueTypeConstraint.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ValueTypeConstraint.java
@@ -134,7 +134,7 @@
if (typeLatticeElement.isReference()) {
return OBJECT;
}
- if (typeLatticeElement.isInt()) {
+ if (typeLatticeElement.isFineGrainedType() || typeLatticeElement.isInt()) {
return INT;
}
if (typeLatticeElement.isFloat()) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/TypeConstraintResolver.java b/src/main/java/com/android/tools/r8/ir/conversion/TypeConstraintResolver.java
index f2fe507..1ed85c4 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/TypeConstraintResolver.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/TypeConstraintResolver.java
@@ -180,8 +180,7 @@
if (array.getTypeLattice().isArrayType()) {
// If the array type is known it uniquely defines the actual member type.
ArrayTypeLatticeElement arrayType = array.getTypeLattice().asArrayTypeLatticeElement();
- constraint =
- ValueTypeConstraint.fromDexType(arrayType.getArrayElementType(builder.getFactory()));
+ constraint = ValueTypeConstraint.fromTypeLattice(arrayType.getArrayMemberTypeAsValueType());
} else {
// If not, e.g., the array input is null, the canonical value determines the final type.
constraint = getCanonicalTypeConstraint(canonical, true);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 98ee72c..785041c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -1979,7 +1979,7 @@
}
DexType type = inType.isClassType()
? inType.asClassTypeLatticeElement().getClassType()
- : inType.asArrayTypeLatticeElement().getArrayType();
+ : inType.asArrayTypeLatticeElement().getArrayType(appInfo.dexItemFactory);
DexType baseType = type.toBaseType(appInfo.dexItemFactory);
// Make sure base type is a class type.
if (!baseType.isClassType()) {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
index ac73d7d..8e38855 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
@@ -5,15 +5,18 @@
package com.android.tools.r8.ir.analysis.type;
import static com.android.tools.r8.ir.analysis.type.TypeLatticeElement.FLOAT;
+import static com.android.tools.r8.ir.analysis.type.TypeLatticeElement.INT;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.ir.code.ArrayGet;
import com.android.tools.r8.ir.code.ArrayPut;
+import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.ConstNumber;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.Phi;
import com.android.tools.r8.ir.code.Value;
import java.util.function.Consumer;
import org.junit.Test;
@@ -34,6 +37,13 @@
buildAndCheckIR("nestedArrayTest", nestedArrayTestInspector(appInfo));
}
+ @Test
+ public void testJoinOfArraysForPrimitivesSmallerThanInt() throws Exception {
+ buildAndCheckIR(
+ "joinOfArraysForPrimitivesSmallerThanInt",
+ joinOfArraysForPrimitivesSmallerThanInt(appInfo));
+ }
+
private static Consumer<IRCode> arrayTestInspector(AppInfo appInfo) {
return code -> {
Iterable<Instruction> instructions = code::instructionIterator;
@@ -53,9 +63,7 @@
assertTrue(array.getTypeLattice().isArrayType());
ArrayTypeLatticeElement arrayType = array.getTypeLattice().asArrayTypeLatticeElement();
- TypeLatticeElement elementType =
- TypeLatticeElement.fromDexType(
- arrayType.getArrayElementType(appInfo.dexItemFactory), true, appInfo);
+ TypeLatticeElement elementType = arrayType.getArrayMemberTypeAsMemberType();
assertEquals(FLOAT, elementType);
assertEquals(FLOAT, value.getTypeLattice());
@@ -75,9 +83,7 @@
assertTrue(array.getTypeLattice().isArrayType());
ArrayTypeLatticeElement arrayType = array.getTypeLattice().asArrayTypeLatticeElement();
- TypeLatticeElement elementType =
- TypeLatticeElement.fromDexType(
- arrayType.getArrayElementType(appInfo.dexItemFactory), true, appInfo);
+ TypeLatticeElement elementType = arrayType.getArrayMemberTypeAsMemberType();
assertEquals(FLOAT, elementType);
assertEquals(FLOAT, value.getTypeLattice());
@@ -94,6 +100,19 @@
};
}
+ private static Consumer<IRCode> joinOfArraysForPrimitivesSmallerThanInt(AppInfo appInfo) {
+ return code -> {
+ int phiCount = 0;
+ for (BasicBlock block : code.blocks) {
+ for (Phi phi : block.getPhis()) {
+ phiCount++;
+ assertEquals(INT, phi.getTypeLattice());
+ }
+ }
+ assertEquals(2, phiCount);
+ };
+ }
+
static class TestClass {
public static void arrayTest() {
@@ -119,5 +138,14 @@
float x = 1f;
array[0][0] = x;
}
+
+ public static void joinOfArraysForPrimitivesSmallerThanInt(
+ boolean predicate, byte[] bs, char[] cs) {
+ char s = (char) (predicate ? bs[0] : cs[0]);
+ byte b = (predicate ? bs[0] : bs[0]);
+ if (s == b) {
+ System.out.println("Meh, just to use variables.");
+ }
+ }
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
index dfe22c7..adf80ae 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
@@ -159,9 +159,12 @@
forEachOutValue(irCode, (v, l) -> {
if (l.isArrayType()) {
ArrayTypeLatticeElement lattice = l.asArrayTypeLatticeElement();
+ assertEquals(1, lattice.getNesting());
+ TypeLatticeElement elementTypeLattice = lattice.getArrayMemberTypeAsMemberType();
+ assertTrue(elementTypeLattice.isClassType());
assertEquals(
appInfo.dexItemFactory.stringType,
- lattice.getArrayElementType(appInfo.dexItemFactory));
+ elementTypeLattice.asClassTypeLatticeElement().getClassType());
assertEquals(v.definition.isArgument(), l.isNullable());
} else if (l.isClassType()) {
verifyClassTypeLattice(expectedLattices, mainClass, v, l);
@@ -185,9 +188,12 @@
forEachOutValue(irCode, (v, l) -> {
if (l.isArrayType()) {
ArrayTypeLatticeElement lattice = l.asArrayTypeLatticeElement();
+ assertEquals(1, lattice.getNesting());
+ TypeLatticeElement elementTypeLattice = lattice.getArrayMemberTypeAsMemberType();
+ assertTrue(elementTypeLattice.isClassType());
assertEquals(
appInfo.dexItemFactory.stringType,
- lattice.getArrayElementType(appInfo.dexItemFactory));
+ elementTypeLattice.asClassTypeLatticeElement().getClassType());
assertEquals(v.definition.isArgument(), l.isNullable());
} else if (l.isClassType()) {
verifyClassTypeLattice(expectedLattices, mainClass, v, l);
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTest.java
index e0d7f71..09f6a01 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTest.java
@@ -189,7 +189,7 @@
if (v == finalArray) {
assertTrue(l.isArrayType());
ArrayTypeLatticeElement lattice = l.asArrayTypeLatticeElement();
- assertTrue(lattice.getArrayType().isPrimitiveArrayType());
+ assertTrue(lattice.getArrayMemberTypeAsMemberType().isPrimitive());
assertEquals(1, lattice.getNesting());
assertFalse(lattice.isNullable());
}
@@ -222,7 +222,7 @@
if (v == finalArray) {
assertTrue(l.isArrayType());
ArrayTypeLatticeElement lattice = l.asArrayTypeLatticeElement();
- assertTrue(lattice.getArrayType().isPrimitiveArrayType());
+ assertTrue(lattice.getArrayMemberTypeAsMemberType().isPrimitive());
assertEquals(1, lattice.getNesting());
assertFalse(lattice.isNullable());
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTestBase.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTestBase.java
index e444e93..5cd64b9 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeAnalysisTestBase.java
@@ -22,7 +22,7 @@
import java.util.function.Predicate;
import org.junit.Before;
-public class TypeAnalysisTestBase extends TestBase {
+public abstract class TypeAnalysisTestBase extends TestBase {
private final AndroidApp app;
private final String className;
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
index d1b3f9e..fbfc09b 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeLatticeTest.java
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.analysis.type;
-import static com.android.tools.r8.ir.analysis.type.TypeLatticeElement.computeLeastUpperBoundOfInterfaces;
+import static com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement.computeLeastUpperBoundOfInterfaces;
import static com.android.tools.r8.ir.analysis.type.TypeLatticeElement.fromDexType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -293,9 +293,41 @@
@Test
public void joinInterfaceArrayAndImplementerArray() {
+ DexType queue = factory.createType("Ljava/util/Queue;");
+ DexType arrayDeque = factory.createType("Ljava/util/ArrayDeque;");
assertEquals(
- // TODO(b/119181813): This should be array(1, charSequence)
- array(1, factory.objectType),
+ array(1, queue),
+ join(
+ array(1, queue),
+ array(1, arrayDeque)));
+ assertEquals(
+ array(2, queue),
+ join(
+ array(2, arrayDeque),
+ array(2, queue)));
+
+ DexType type = factory.createType("Ljava/lang/reflect/Type;");
+ DexType wType = factory.createType("Ljava/lang/reflect/WildcardType;");
+ DexType pType = factory.createType("Ljava/lang/reflect/ParameterizedType;");
+ assertEquals(
+ array(1, type),
+ join(
+ array(1, wType),
+ array(1, pType)));
+ assertEquals(
+ array(2, type),
+ join(
+ array(2, wType),
+ array(2, factory.classType)));
+ assertEquals(
+ array(1, type),
+ join(
+ array(1, wType),
+ array(1, pType),
+ array(1, factory.classType)));
+
+ assertEquals(
+ array(1, factory.charSequenceType),
join(
array(1, factory.charSequenceType),
array(1, factory.stringType)));
@@ -347,6 +379,18 @@
join(
array(1, factory.longType),
array(1, factory.intType)));
+
+ // Test primitive types smaller than int.
+ assertEquals(
+ element(factory.objectType),
+ join(
+ array(1, factory.intType),
+ array(1, factory.byteType)));
+ assertEquals(
+ element(factory.objectType),
+ join(
+ array(1, factory.charType),
+ array(1, factory.shortType)));
}
@Test
@@ -397,10 +441,10 @@
@Test
public void joinDistinctTypesClassArrays() {
assertEquals(
- array(3, factory.objectType),
+ array(3, factory.serializableType),
join(
array(3, factory.stringType),
- array(3, factory.stringBuilderType)));
+ array(3, factory.classType)));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java b/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
index 128b2ac..f8d8e7c 100644
--- a/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
@@ -12,8 +12,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.VmTestRunner;
import com.android.tools.r8.jasmin.JasminBuilder;
@@ -203,24 +201,25 @@
assertEquals(0, javaResult.exitCode);
assertThat(javaResult.stdout, containsString(impl2.name));
- AndroidApp processedApp = compileWithR8(jasminBuilder.build(), proguardConfig,
- // Disable inlining to avoid the (short) tested method from being inlined and then removed.
- internalOptions -> internalOptions.enableInlining = false);
+ AndroidApp processedApp = compileWithR8(
+ jasminBuilder.build(),
+ proguardConfig,
+ internalOptions -> {
+ // Disable inlining to avoid the (short) tested method from being inlined and then
+ // removed.
+ internalOptions.enableInlining = false;
+ internalOptions.testing.allowTypeErrors = true;
+ });
// Run processed (output) program on ART
ProcessResult artResult = runOnArtRaw(processedApp, mainClassName);
assertNotEquals(0, artResult.exitCode);
- assertEquals(-1, artResult.stderr.indexOf("DoFieldPut"));
- DexVm.Version currentVersion = ToolHelper.getDexVm().getVersion();
- String errorMessage =
- currentVersion.isNewerThan(Version.V4_4_4)
- ? "type Precise Reference: Impl1[] but expected Reference: Itf1[]"
- : "storing type '[LImpl1;' into field type '[LItf1;'";
- assertThat(artResult.stderr, containsString(errorMessage));
+ assertThat(artResult.stderr, containsString("java.lang.NullPointerException"));
+ assertThat(artResult.stderr, not(containsString("DoFieldPut")));
CodeInspector inspector = new CodeInspector(processedApp);
ClassSubject itf1Subject = inspector.clazz(itf1.name);
- assertThat(itf1Subject, isPresent());
+ assertThat(itf1Subject, not(isPresent()));
}
}