Merge commit '190440afd5c304438851011526ebe11bcde62cce' into 1.7.x-dev
Change-Id: I74db49506e6b2beb6eb94ec95a5a704d0a29f728
diff --git a/.gitignore b/.gitignore
index b74632a..bc99d6a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
buildSrc/out/
.idea/
.gradle/
+.gradle_user_home
android-data*/
tests/2016-12-19/art.tar.gz
tests/2016-12-19/art
diff --git a/src/main/java/com/android/tools/r8/ArchiveClassFileProvider.java b/src/main/java/com/android/tools/r8/ArchiveClassFileProvider.java
index a6389da..31e0dbd 100644
--- a/src/main/java/com/android/tools/r8/ArchiveClassFileProvider.java
+++ b/src/main/java/com/android/tools/r8/ArchiveClassFileProvider.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.ZipUtils;
import com.google.common.io.ByteStreams;
import java.io.Closeable;
@@ -60,7 +61,7 @@
assert isArchive(archive);
origin = new PathOrigin(archive);
try {
- zipFile = new ZipFile(archive.toFile(), StandardCharsets.UTF_8);
+ zipFile = FileUtils.createZipFile(archive.toFile(), StandardCharsets.UTF_8);
} catch (IOException e) {
if (!Files.exists(archive)) {
throw new NoSuchFileException(archive.toString());
diff --git a/src/main/java/com/android/tools/r8/ArchiveProgramResourceProvider.java b/src/main/java/com/android/tools/r8/ArchiveProgramResourceProvider.java
index c5065f2..d5dd240 100644
--- a/src/main/java/com/android/tools/r8/ArchiveProgramResourceProvider.java
+++ b/src/main/java/com/android/tools/r8/ArchiveProgramResourceProvider.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.ZipUtils;
import com.google.common.io.ByteStreams;
import java.io.IOException;
@@ -62,7 +63,7 @@
Path archive, Predicate<String> include) {
return fromSupplier(
new PathOrigin(archive),
- () -> new ZipFile(archive.toFile(), StandardCharsets.UTF_8),
+ () -> FileUtils.createZipFile(archive.toFile(), StandardCharsets.UTF_8),
include);
}
diff --git a/src/main/java/com/android/tools/r8/BaseCommand.java b/src/main/java/com/android/tools/r8/BaseCommand.java
index 318305d..50e5be1 100644
--- a/src/main/java/com/android/tools/r8/BaseCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCommand.java
@@ -166,15 +166,14 @@
public B addProgramFiles(Collection<Path> files) {
guard(
() -> {
- files.forEach(
- path -> {
- try {
- app.addProgramFile(path);
- programFiles.add(path);
- } catch (CompilationError e) {
- error(new ProgramInputOrigin(path), e);
- }
- });
+ for (Path path : files) {
+ try {
+ app.addProgramFile(path);
+ programFiles.add(path);
+ } catch (CompilationError e) {
+ error(new ProgramInputOrigin(path), e);
+ }
+ }
});
return self();
}
@@ -201,14 +200,13 @@
public B addLibraryFiles(Collection<Path> files) {
guard(
() -> {
- files.forEach(
- path -> {
- try {
- app.addLibraryFile(path);
- } catch (CompilationError e) {
- error(new LibraryInputOrigin(path), e);
- }
- });
+ for (Path path : files) {
+ try {
+ app.addLibraryFile(path);
+ } catch (CompilationError e) {
+ error(new LibraryInputOrigin(path), e);
+ }
+ }
});
return self();
}
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index f17bab9..7834adb 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -113,10 +113,6 @@
options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options.itemFactory);
app = new L8TreePruner(options).prune(app, rewritePrefix);
- if (app.classes().size() == 0) {
- // TODO(b/134732760): report error instead of fatalError.
- throw options.reporter.fatalError("Empty desugared library.");
- }
AppInfo appInfo = new AppInfo(app);
AppView<?> appView = AppView.createForL8(appInfo, options, rewritePrefix);
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 a48bbd1..e77cba3 100644
--- a/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
+++ b/src/main/java/com/android/tools/r8/cf/TypeVerificationHelper.java
@@ -20,9 +20,9 @@
import com.android.tools.r8.ir.code.StackValue;
import com.android.tools.r8.ir.code.Value;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
@@ -223,7 +223,7 @@
computingVerificationTypes = true;
types = new HashMap<>();
List<ConstNumber> nullsUsedInPhis = new ArrayList<>();
- Set<Value> worklist = new HashSet<>();
+ Set<Value> worklist = Sets.newIdentityHashSet();
{
InstructionIterator it = code.instructionIterator();
Instruction instruction = null;
diff --git a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
index 7321b53..68e9e69 100644
--- a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
+++ b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
@@ -569,7 +569,7 @@
// For each input archive file, add all class files within.
for (Path input : inputs) {
if (FileUtils.isArchive(input)) {
- try (ZipFile zipFile = new ZipFile(input.toFile(), StandardCharsets.UTF_8)) {
+ try (ZipFile zipFile = FileUtils.createZipFile(input.toFile(), StandardCharsets.UTF_8)) {
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
index 460885c..3425946 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.SetUtils;
@@ -131,7 +132,7 @@
public AppInfoWithSubtyping(DexApplication application) {
super(application);
- typeInfo = Collections.synchronizedMap(new IdentityHashMap<>());
+ typeInfo = new ConcurrentHashMap<>();
// Recompute subtype map if we have modified the graph.
populateSubtypeMap(application.asDirect(), application.dexItemFactory);
}
@@ -140,7 +141,7 @@
super(previous);
missingClasses.addAll(previous.missingClasses);
subtypeMap.putAll(previous.subtypeMap);
- typeInfo = Collections.synchronizedMap(new IdentityHashMap<>(previous.typeInfo));
+ typeInfo = new ConcurrentHashMap<>(previous.typeInfo);
assert app() instanceof DirectMappedDexApplication;
}
@@ -211,6 +212,7 @@
}
private TypeInfo getTypeInfo(DexType type) {
+ assert type != null;
return typeInfo.computeIfAbsent(type, TypeInfo::new);
}
@@ -274,11 +276,11 @@
}
assert !seenTypes.contains(next);
seenTypes.add(next);
- TypeInfo superInfo = getTypeInfo(superType);
TypeInfo nextInfo = getTypeInfo(next);
if (superType == null) {
assert nextInfo.hierarchyLevel == ROOT_LEVEL;
} else {
+ TypeInfo superInfo = getTypeInfo(superType);
assert superInfo.hierarchyLevel == nextInfo.hierarchyLevel - 1
|| (superInfo.hierarchyLevel == ROOT_LEVEL
&& nextInfo.hierarchyLevel == INTERFACE_LEVEL);
@@ -714,8 +716,17 @@
return !isSubtype(type1, type2) && !isSubtype(type2, type1);
}
- public boolean mayHaveFinalizeMethodDirectlyOrIndirectly(DexType type) {
- return computeMayHaveFinalizeMethodDirectlyOrIndirectlyIfAbsent(type, true);
+ public boolean mayHaveFinalizeMethodDirectlyOrIndirectly(ClassTypeLatticeElement type) {
+ Set<DexType> interfaces = type.getInterfaces();
+ if (!interfaces.isEmpty()) {
+ for (DexType interfaceType : interfaces) {
+ if (computeMayHaveFinalizeMethodDirectlyOrIndirectlyIfAbsent(interfaceType, false)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ return computeMayHaveFinalizeMethodDirectlyOrIndirectlyIfAbsent(type.getClassType(), true);
}
private boolean computeMayHaveFinalizeMethodDirectlyOrIndirectlyIfAbsent(
@@ -727,8 +738,10 @@
}
DexClass clazz = definitionFor(type);
if (clazz == null) {
- mayHaveFinalizeMethodDirectlyOrIndirectlyCache.put(type, true);
- return true;
+ // This is strictly not conservative but is needed to avoid that we treat Object as having
+ // a subtype that has a non-default finalize() implementation.
+ mayHaveFinalizeMethodDirectlyOrIndirectlyCache.put(type, false);
+ return false;
}
if (clazz.isProgramClass()) {
if (lookUpwards) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 6f5df28..7ce2685 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -924,4 +924,13 @@
assert verifyNoDuplicateMethods();
return true;
}
+
+ public boolean hasStaticSynchronizedMethods() {
+ for (DexEncodedMethod encodedMethod : directMethods()) {
+ if (encodedMethod.accessFlags.isStatic() && encodedMethod.accessFlags.isSynchronized()) {
+ return true;
+ }
+ }
+ return false;
+ }
}
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 0cc264a..f60e877 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -62,12 +62,12 @@
public static final String throwableDescriptorString = "Ljava/lang/Throwable;";
- private final ConcurrentHashMap<DexString, DexString> strings = new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexString, DexType> types = new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexField, DexField> fields = new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexProto, DexProto> protos = new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexMethod, DexMethod> methods = new ConcurrentHashMap<>();
- private final ConcurrentHashMap<DexMethodHandle, DexMethodHandle> methodHandles =
+ private final Map<DexString, DexString> strings = new ConcurrentHashMap<>();
+ private final Map<DexString, DexType> types = new ConcurrentHashMap<>();
+ private final Map<DexField, DexField> fields = new ConcurrentHashMap<>();
+ private final Map<DexProto, DexProto> protos = new ConcurrentHashMap<>();
+ private final Map<DexMethod, DexMethod> methods = new ConcurrentHashMap<>();
+ private final Map<DexMethodHandle, DexMethodHandle> methodHandles =
new ConcurrentHashMap<>();
// DexDebugEvent Canonicalization.
@@ -730,10 +730,13 @@
public class EnumMethods {
- public DexMethod valueOf;
- public DexMethod ordinal;
- public DexMethod name;
- public DexMethod toString;
+ public final DexMethod valueOf;
+ public final DexMethod ordinal;
+ public final DexMethod name;
+ public final DexMethod toString;
+
+ public final DexMethod finalize =
+ createMethod(enumType, createProto(voidType), finalizeMethodName);
private EnumMethods() {
valueOf =
@@ -1152,7 +1155,7 @@
}
}
- private static <T extends DexItem> T canonicalize(ConcurrentHashMap<T, T> map, T item) {
+ private static <T extends DexItem> T canonicalize(Map<T, T> map, T item) {
assert item != null;
assert !DexItemFactory.isInternalSentinel(item);
T previous = map.putIfAbsent(item, item);
diff --git a/src/main/java/com/android/tools/r8/graph/DexValue.java b/src/main/java/com/android/tools/r8/graph/DexValue.java
index aa6b651..af70929 100644
--- a/src/main/java/com/android/tools/r8/graph/DexValue.java
+++ b/src/main/java/com/android/tools/r8/graph/DexValue.java
@@ -56,6 +56,22 @@
return null;
}
+ public DexValueType asDexValueType() {
+ return null;
+ }
+
+ public DexValueArray asDexValueArray() {
+ return null;
+ }
+
+ public boolean isDexValueType() {
+ return false;
+ }
+
+ public boolean isDexValueArray() {
+ return false;
+ }
+
public static DexValue fromAsmBootstrapArgument(
Object value, JarApplicationReader application, DexType clazz) {
if (value instanceof Integer) {
@@ -835,6 +851,16 @@
DexMethod method, int instructionOffset) {
value.collectIndexedItems(indexedItems, method, instructionOffset);
}
+
+ @Override
+ public DexValueType asDexValueType() {
+ return this;
+ }
+
+ @Override
+ public boolean isDexValueType() {
+ return true;
+ }
}
static public class DexValueField extends NestedDexValue<DexField> {
@@ -979,6 +1005,16 @@
public String toString() {
return "Array " + Arrays.toString(values);
}
+
+ @Override
+ public boolean isDexValueArray() {
+ return true;
+ }
+
+ @Override
+ public DexValueArray asDexValueArray() {
+ return this;
+ }
}
static public class DexValueAnnotation extends DexValue {
diff --git a/src/main/java/com/android/tools/r8/graph/ParameterAnnotationsList.java b/src/main/java/com/android/tools/r8/graph/ParameterAnnotationsList.java
index 68c7da1..6ff5c75 100644
--- a/src/main/java/com/android/tools/r8/graph/ParameterAnnotationsList.java
+++ b/src/main/java/com/android/tools/r8/graph/ParameterAnnotationsList.java
@@ -5,8 +5,10 @@
import com.android.tools.r8.dex.IndexedItemCollection;
import com.android.tools.r8.dex.MixedSectionCollection;
+import com.android.tools.r8.utils.ArrayUtils;
import java.util.Arrays;
import java.util.function.Consumer;
+import java.util.function.Function;
import java.util.function.Predicate;
/**
@@ -193,4 +195,12 @@
}
return new ParameterAnnotationsList(filtered, missingParameterAnnotations);
}
+
+ public ParameterAnnotationsList rewrite(Function<DexAnnotationSet, DexAnnotationSet> mapper) {
+ DexAnnotationSet[] rewritten = ArrayUtils.map(DexAnnotationSet[].class, values, mapper);
+ if (rewritten != values) {
+ return new ParameterAnnotationsList(rewritten, missingParameterAnnotations);
+ }
+ return this;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
new file mode 100644
index 0000000..d654c87
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
@@ -0,0 +1,261 @@
+// Copyright (c) 2019, 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;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.ArrayPut;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.InvokeNewArray;
+import com.android.tools.r8.ir.code.NewArrayEmpty;
+import com.android.tools.r8.ir.code.NewArrayFilledData;
+import com.android.tools.r8.ir.code.StaticPut;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.utils.LongInterval;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.Set;
+
+public class ValueMayDependOnEnvironmentAnalysis {
+
+ private final AppView<?> appView;
+ private final IRCode code;
+ private final DexType context;
+
+ public ValueMayDependOnEnvironmentAnalysis(AppView<?> appView, IRCode code) {
+ this.appView = appView;
+ this.code = code;
+ this.context = code.method.method.holder;
+ }
+
+ public boolean valueMayDependOnEnvironment(Value value) {
+ Value root = value.getAliasedValue();
+ if (root.isConstant()) {
+ return false;
+ }
+ if (isConstantArrayThroughoutMethod(root)) {
+ return false;
+ }
+ if (isNewInstanceWithoutEnvironmentDependentFields(root)) {
+ return false;
+ }
+ return true;
+ }
+
+ public boolean isConstantArrayThroughoutMethod(Value value) {
+ Value root = value.getAliasedValue();
+ if (root.isPhi()) {
+ // Would need to track the aliases, just give up.
+ return false;
+ }
+
+ Instruction definition = root.definition;
+
+ // Check that it is a constant array with a known size at this point in the IR.
+ long size;
+ if (definition.isInvokeNewArray()) {
+ InvokeNewArray invokeNewArray = definition.asInvokeNewArray();
+ for (Value argument : invokeNewArray.arguments()) {
+ if (!argument.isConstant()) {
+ return false;
+ }
+ }
+ size = invokeNewArray.arguments().size();
+ } else if (definition.isNewArrayEmpty()) {
+ NewArrayEmpty newArrayEmpty = definition.asNewArrayEmpty();
+ Value sizeValue = newArrayEmpty.size().getAliasedValue();
+ if (!sizeValue.hasValueRange()) {
+ return false;
+ }
+ LongInterval sizeRange = sizeValue.getValueRange();
+ if (!sizeRange.isSingleValue()) {
+ return false;
+ }
+ size = sizeRange.getSingleValue();
+ } else {
+ // Some other array creation.
+ return false;
+ }
+
+ if (size < 0) {
+ // Check for NegativeArraySizeException.
+ return false;
+ }
+
+ if (size == 0) {
+ // Empty arrays are always constant.
+ return true;
+ }
+
+ // Allow array-put and new-array-filled-data instructions that immediately follow the array
+ // creation.
+ Set<Instruction> consumedInstructions = Sets.newIdentityHashSet();
+
+ for (Instruction instruction : definition.getBlock().instructionsAfter(definition)) {
+ if (instruction.isArrayPut()) {
+ ArrayPut arrayPut = instruction.asArrayPut();
+ Value array = arrayPut.array().getAliasedValue();
+ if (array != root) {
+ // This ends the chain of array-put instructions that are allowed immediately after the
+ // array creation.
+ break;
+ }
+
+ LongInterval indexRange = arrayPut.index().getValueRange();
+ if (!indexRange.isSingleValue()) {
+ return false;
+ }
+
+ long index = indexRange.getSingleValue();
+ if (index < 0 || index >= size) {
+ return false;
+ }
+
+ if (!arrayPut.value().isConstant()) {
+ return false;
+ }
+
+ consumedInstructions.add(arrayPut);
+ continue;
+ }
+
+ if (instruction.isNewArrayFilledData()) {
+ NewArrayFilledData newArrayFilledData = instruction.asNewArrayFilledData();
+ Value array = newArrayFilledData.src();
+ if (array != root) {
+ break;
+ }
+
+ consumedInstructions.add(newArrayFilledData);
+ continue;
+ }
+
+ if (instruction.instructionMayHaveSideEffects(appView, context)) {
+ // This ends the chain of array-put instructions that are allowed immediately after the
+ // array creation.
+ break;
+ }
+ }
+
+ // Check that the array is not mutated before the end of this method.
+ //
+ // Currently, we only allow the array to flow into static-put instructions that are not
+ // followed by an instruction that may have side effects. Instructions that do not have any
+ // side effects are ignored because they cannot mutate the array.
+ return !valueMayBeMutatedBeforeMethodExit(root, consumedInstructions);
+ }
+
+ private boolean isNewInstanceWithoutEnvironmentDependentFields(Value value) {
+ assert !value.hasAliasedValue();
+
+ if (value.isPhi() || !value.definition.isNewInstance()) {
+ return false;
+ }
+
+ // Find the single constructor invocation.
+ InvokeMethod constructorInvoke = null;
+ for (Instruction instruction : value.uniqueUsers()) {
+ if (!instruction.isInvokeDirect()) {
+ continue;
+ }
+
+ InvokeDirect invoke = instruction.asInvokeDirect();
+ if (!appView.dexItemFactory().isConstructor(invoke.getInvokedMethod())) {
+ continue;
+ }
+
+ if (invoke.getReceiver().getAliasedValue() != value) {
+ continue;
+ }
+
+ if (constructorInvoke == null) {
+ constructorInvoke = invoke;
+ } else {
+ // Not a single constructor invocation, give up.
+ return false;
+ }
+ }
+
+ if (constructorInvoke == null) {
+ // Didn't find a constructor invocation, give up.
+ return false;
+ }
+
+ // Check that it is a trivial initializer (otherwise, the constructor could do anything).
+ DexEncodedMethod constructor = appView.definitionFor(constructorInvoke.getInvokedMethod());
+ if (constructor == null) {
+ return false;
+ }
+
+ TrivialInitializer initializerInfo =
+ constructor.getOptimizationInfo().getTrivialInitializerInfo();
+ if (initializerInfo == null || !initializerInfo.isTrivialInstanceInitializer()) {
+ return false;
+ }
+
+ // Check that none of the arguments to the constructor depend on the environment.
+ for (int i = 1; i < constructorInvoke.arguments().size(); i++) {
+ Value argument = constructorInvoke.arguments().get(i);
+ if (valueMayDependOnEnvironment(argument)) {
+ return false;
+ }
+ }
+
+ // Finally, check that the object does not escape.
+ return !valueMayBeMutatedBeforeMethodExit(value, ImmutableSet.of(constructorInvoke));
+ }
+
+ private boolean valueMayBeMutatedBeforeMethodExit(Value value, Set<Instruction> whitelist) {
+ assert !value.hasAliasedValue();
+
+ if (value.numberOfPhiUsers() > 0) {
+ // Could be mutated indirectly.
+ return true;
+ }
+
+ Set<Instruction> visited = Sets.newIdentityHashSet();
+ for (Instruction user : value.uniqueUsers()) {
+ if (whitelist.contains(user)) {
+ continue;
+ }
+
+ if (user.isStaticPut()) {
+ StaticPut staticPut = user.asStaticPut();
+ if (visited.contains(staticPut)) {
+ // Already visited previously.
+ continue;
+ }
+ for (Instruction instruction : code.getInstructionsReachableFrom(staticPut)) {
+ if (!visited.add(instruction)) {
+ // Already visited previously.
+ continue;
+ }
+ if (instruction.isStaticPut()) {
+ StaticPut otherStaticPut = instruction.asStaticPut();
+ if (otherStaticPut.getField().holder == staticPut.getField().holder
+ && instruction.instructionInstanceCanThrow(appView, context).cannotThrow()) {
+ continue;
+ }
+ return true;
+ }
+ if (instruction.instructionMayTriggerMethodInvocation(appView, context)) {
+ return true;
+ }
+ }
+ continue;
+ }
+
+ // Other user than static-put, just give up.
+ return false;
+ }
+
+ return false;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
index 2d67908..1ef58fb 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.code.BasicBlock;
@@ -245,9 +246,14 @@
private void updateFieldOptimizationInfo(DexEncodedField field, Value value) {
TypeLatticeElement fieldType =
TypeLatticeElement.fromDexType(field.field.type, Nullability.maybeNull(), appView);
- TypeLatticeElement valueType = value.getTypeLattice();
- if (valueType.strictlyLessThan(fieldType, appView)) {
- feedback.markFieldHasDynamicType(field, valueType);
+ TypeLatticeElement dynamicUpperBoundType = value.getDynamicUpperBoundType(appView);
+ if (dynamicUpperBoundType.strictlyLessThan(fieldType, appView)) {
+ feedback.markFieldHasDynamicUpperBoundType(field, dynamicUpperBoundType);
+ }
+ ClassTypeLatticeElement dynamicLowerBoundType = value.getDynamicLowerBoundType(appView);
+ if (dynamicLowerBoundType != null) {
+ assert dynamicLowerBoundType.lessThanOrEqual(dynamicUpperBoundType, appView);
+ feedback.markFieldHasDynamicLowerBoundType(field, dynamicLowerBoundType);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/sideeffect/ClassInitializerSideEffectAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/sideeffect/ClassInitializerSideEffectAnalysis.java
index 4071c99..35c483b 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/sideeffect/ClassInitializerSideEffectAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/sideeffect/ClassInitializerSideEffectAnalysis.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ValueMayDependOnEnvironmentAnalysis;
import com.android.tools.r8.ir.code.ArrayPut;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -42,6 +43,8 @@
OptionalBool controlFlowMayDependOnEnvironment = OptionalBool.unknown();
boolean mayHaveSideEffects = false;
+ ValueMayDependOnEnvironmentAnalysis environmentAnalysis =
+ new ValueMayDependOnEnvironmentAnalysis(appView, code);
for (Instruction instruction : code.instructions()) {
// Array stores to a newly created array are only observable if they may throw, or if the
// array content may depend on the environment.
@@ -50,14 +53,14 @@
Value array = arrayPut.array().getAliasedValue();
if (array.isPhi()
|| !array.definition.isCreatingArray()
- || arrayPut.index().mayDependOnEnvironment(appView, code)
- || arrayPut.value().mayDependOnEnvironment(appView, code)
+ || environmentAnalysis.valueMayDependOnEnvironment(arrayPut.index())
+ || environmentAnalysis.valueMayDependOnEnvironment(arrayPut.value())
|| arrayPut.instructionInstanceCanThrow(appView, context).isThrowing()) {
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
}
if (controlFlowMayDependOnEnvironment.isUnknown()) {
controlFlowMayDependOnEnvironment =
- OptionalBool.of(code.controlFlowMayDependOnEnvironment(appView));
+ OptionalBool.of(code.controlFlowMayDependOnEnvironment(environmentAnalysis));
}
if (controlFlowMayDependOnEnvironment.isTrue()) {
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
@@ -76,7 +79,7 @@
}
if (controlFlowMayDependOnEnvironment.isUnknown()) {
controlFlowMayDependOnEnvironment =
- OptionalBool.of(code.controlFlowMayDependOnEnvironment(appView));
+ OptionalBool.of(code.controlFlowMayDependOnEnvironment(environmentAnalysis));
}
if (controlFlowMayDependOnEnvironment.isTrue()) {
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
@@ -92,7 +95,7 @@
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
}
for (Value argument : invokeNewArray.arguments()) {
- if (argument.mayDependOnEnvironment(appView, code)) {
+ if (environmentAnalysis.valueMayDependOnEnvironment(argument)) {
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
}
}
@@ -111,7 +114,7 @@
DexEncodedField field = appView.appInfo().resolveField(staticPut.getField());
if (field == null
|| field.field.holder != context
- || staticPut.value().mayDependOnEnvironment(appView, code)
+ || environmentAnalysis.valueMayDependOnEnvironment(staticPut.value())
|| instruction.instructionInstanceCanThrow(appView, context).isThrowing()) {
return ClassInitializerSideEffect.SIDE_EFFECTS_THAT_CANNOT_BE_POSTPONED;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Assume.java b/src/main/java/com/android/tools/r8/ir/code/Assume.java
index 9ba29fd..37de422 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Assume.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Assume.java
@@ -16,6 +16,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.InliningConstraints;
+import java.util.Objects;
import java.util.Set;
public class Assume<An extends Assumption> extends Instruction {
@@ -46,14 +47,18 @@
}
public static Assume<DynamicTypeAssumption> createAssumeDynamicTypeInstruction(
- TypeLatticeElement type,
- ClassTypeLatticeElement lowerBoundType,
+ TypeLatticeElement dynamicUpperBoundType,
+ ClassTypeLatticeElement dynamicLowerBoundType,
Value dest,
Value src,
Instruction origin,
AppView<?> appView) {
return new Assume<>(
- new DynamicTypeAssumption(type, lowerBoundType), dest, src, origin, appView);
+ new DynamicTypeAssumption(dynamicUpperBoundType, dynamicLowerBoundType),
+ dest,
+ src,
+ origin,
+ appView);
}
@Override
@@ -170,7 +175,7 @@
return true;
}
if (assumption.isAssumeDynamicType()) {
- outType = asAssumeDynamicType().assumption.getType();
+ outType = asAssumeDynamicType().assumption.getDynamicUpperBoundType();
}
if (appView.appInfo().hasSubtyping()) {
if (outType.isClassType()
@@ -288,19 +293,24 @@
@Override
public String toString() {
- // During branch simplification, the origin `if` could be simplified.
- // It means the assumption became "truth."
- assert origin.hasBlock() || isAssumeNonNull();
+ // `origin` could become obsolete:
+ // 1) during branch simplification, the origin `if` could be simplified, which means the
+ // assumption became "truth."
+ // 2) invoke-interface could be devirtualized, while its dynamic type and/or non-null receiver
+ // are still valid.
String originString =
- origin.hasBlock() ? " (origin: `" + origin.toString() + "`)" : " (origin simplified)";
+ origin.hasBlock() ? " (origin: `" + origin.toString() + "`)" : " (obsolete origin)";
if (isAssumeNone() || isAssumeNonNull()) {
return super.toString() + originString;
}
if (isAssumeDynamicType()) {
DynamicTypeAssumption assumption = asAssumeDynamicType().getAssumption();
return super.toString()
- + "; upper bound: " + assumption.type
- + (assumption.lowerBoundType != null ? "; lower bound: " + assumption.lowerBoundType : "")
+ + "; upper bound: "
+ + assumption.dynamicUpperBoundType
+ + (assumption.dynamicLowerBoundType != null
+ ? "; lower bound: " + assumption.dynamicLowerBoundType
+ : "")
+ originString;
}
return super.toString();
@@ -348,20 +358,21 @@
public static class DynamicTypeAssumption extends Assumption {
- private final TypeLatticeElement type;
- private final ClassTypeLatticeElement lowerBoundType;
+ private final TypeLatticeElement dynamicUpperBoundType;
+ private final ClassTypeLatticeElement dynamicLowerBoundType;
- private DynamicTypeAssumption(TypeLatticeElement type, ClassTypeLatticeElement lowerBoundType) {
- this.type = type;
- this.lowerBoundType = lowerBoundType;
+ private DynamicTypeAssumption(
+ TypeLatticeElement dynamicUpperBoundType, ClassTypeLatticeElement dynamicLowerBoundType) {
+ this.dynamicUpperBoundType = dynamicUpperBoundType;
+ this.dynamicLowerBoundType = dynamicLowerBoundType;
}
- public TypeLatticeElement getType() {
- return type;
+ public TypeLatticeElement getDynamicUpperBoundType() {
+ return dynamicUpperBoundType;
}
- public ClassTypeLatticeElement getLowerBoundType() {
- return lowerBoundType;
+ public ClassTypeLatticeElement getDynamicLowerBoundType() {
+ return dynamicLowerBoundType;
}
@Override
@@ -371,7 +382,7 @@
@Override
public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
- assert type.lessThanOrEqualUpToNullability(src.getTypeLattice(), appView);
+ assert dynamicUpperBoundType.lessThanOrEqualUpToNullability(src.getTypeLattice(), appView);
return true;
}
@@ -384,12 +395,13 @@
return false;
}
DynamicTypeAssumption assumption = (DynamicTypeAssumption) other;
- return type == assumption.type;
+ return dynamicUpperBoundType == assumption.dynamicUpperBoundType
+ && dynamicLowerBoundType == assumption.dynamicLowerBoundType;
}
@Override
public int hashCode() {
- return type.hashCode();
+ return Objects.hash(dynamicUpperBoundType, dynamicLowerBoundType);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
index 78018f9..a4c8d4b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
@@ -26,6 +26,7 @@
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
@@ -35,7 +36,6 @@
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
@@ -854,7 +854,7 @@
}
public Set<Value> cleanForRemoval() {
- Set<Value> affectedValues = new HashSet<>();
+ Set<Value> affectedValues = Sets.newIdentityHashSet();
for (BasicBlock block : successors) {
affectedValues.addAll(block.getPhis());
block.removePredecessor(this, affectedValues);
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index 63f6636..708e947 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -20,7 +20,6 @@
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
import java.util.ArrayList;
-import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
@@ -617,7 +616,7 @@
if (normalExits.isEmpty()) {
assert inlineeCanThrow;
DominatorTree dominatorTree = new DominatorTree(code, MAY_HAVE_UNREACHABLE_BLOCKS);
- Set<Value> affectedValues = new HashSet<>();
+ Set<Value> affectedValues = Sets.newIdentityHashSet();
blocksToRemove.addAll(invokePredecessor.unlink(invokeBlock, dominatorTree, affectedValues));
new TypeAnalysis(appView).narrowing(affectedValues);
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
index b95376e..72e4c9d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
@@ -8,13 +8,16 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.analysis.AbstractError;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.ConcreteMutableFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.EmptyFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.UnknownFieldSet;
+import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.Collections;
import java.util.List;
@@ -163,4 +166,39 @@
assert isFieldPut();
return EmptyFieldSet.getInstance();
}
+
+ /**
+ * Returns {@code true} if this instruction may store an instance of a class that has a non-
+ * default finalize() method in a field. In that case, it is not safe to remove this instruction,
+ * since that could change the lifetime of the value.
+ */
+ boolean isStoringObjectWithFinalizer(AppInfoWithLiveness appInfo) {
+ assert isFieldPut();
+ TypeLatticeElement type = value().getTypeLattice();
+ TypeLatticeElement baseType =
+ type.isArrayType() ? type.asArrayTypeLatticeElement().getArrayBaseTypeLattice() : type;
+ if (baseType.isClassType()) {
+ Value root = value().getAliasedValue();
+ if (!root.isPhi() && root.definition.isNewInstance()) {
+ DexClass clazz = appInfo.definitionFor(root.definition.asNewInstance().clazz);
+ if (clazz == null) {
+ return true;
+ }
+ if (clazz.superType == null) {
+ return false;
+ }
+ DexItemFactory dexItemFactory = appInfo.dexItemFactory();
+ DexEncodedMethod resolutionResult =
+ appInfo
+ .resolveMethod(clazz.type, dexItemFactory.objectMethods.finalize)
+ .asSingleTarget();
+ return resolutionResult != null && resolutionResult.isProgramMethod(appInfo);
+ }
+
+ return appInfo.mayHaveFinalizeMethodDirectlyOrIndirectly(
+ baseType.asClassTypeLatticeElement());
+ }
+
+ return false;
+ }
}
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 99a4956..955182b 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
@@ -10,6 +10,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.analysis.TypeChecker;
+import com.android.tools.r8.ir.analysis.ValueMayDependOnEnvironmentAnalysis;
import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
@@ -35,6 +36,7 @@
import java.util.Deque;
import java.util.HashSet;
import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
@@ -152,8 +154,9 @@
worklist.addAll(sorted.reverse());
while (!worklist.isEmpty()) {
BasicBlock block = worklist.poll();
- Set<Value> live = new HashSet<>();
- Set<Value> liveLocals = new HashSet<>();
+ // Note that the iteration order of live values matters when inserting spill/restore moves.
+ Set<Value> live = new LinkedHashSet<>();
+ Set<Value> liveLocals = Sets.newIdentityHashSet();
Deque<Value> liveStack = new ArrayDeque<>();
Set<BasicBlock> exceptionalSuccessors = block.getCatchHandlers().getUniqueTargets();
for (BasicBlock succ : block.getSuccessors()) {
@@ -259,7 +262,8 @@
return liveAtEntrySets;
}
- public boolean controlFlowMayDependOnEnvironment(AppView<?> appView) {
+ public boolean controlFlowMayDependOnEnvironment(
+ ValueMayDependOnEnvironmentAnalysis environmentAnalysis) {
for (BasicBlock block : blocks) {
if (block.hasCatchHandlers()) {
// Whether an instruction throws may generally depend on the environment.
@@ -267,16 +271,16 @@
}
if (block.exit().isIf()) {
If ifInstruction = block.exit().asIf();
- if (ifInstruction.lhs().mayDependOnEnvironment(appView, this)) {
+ if (environmentAnalysis.valueMayDependOnEnvironment(ifInstruction.lhs())) {
return true;
}
if (!ifInstruction.isZeroTest()
- && ifInstruction.rhs().mayDependOnEnvironment(appView, this)) {
+ && environmentAnalysis.valueMayDependOnEnvironment(ifInstruction.rhs())) {
return true;
}
} else if (block.exit().isSwitch()) {
Switch switchInstruction = block.exit().asSwitch();
- if (switchInstruction.value().mayDependOnEnvironment(appView, this)) {
+ if (environmentAnalysis.valueMayDependOnEnvironment(switchInstruction.value())) {
return true;
}
}
@@ -631,7 +635,7 @@
}
private boolean consistentDefUseChains() {
- Set<Value> values = new HashSet<>();
+ Set<Value> values = Sets.newIdentityHashSet();
for (BasicBlock block : blocks) {
int predecessorCount = block.getPredecessors().size();
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
index 4dcb749..32484c3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
@@ -110,7 +110,8 @@
DexEncodedField encodedField = appInfoWithLiveness.resolveField(getField());
assert encodedField != null : "NoSuchFieldError (resolution failure) should be caught.";
- return appInfoWithLiveness.isFieldRead(encodedField);
+ return appInfoWithLiveness.isFieldRead(encodedField)
+ || isStoringObjectWithFinalizer(appInfoWithLiveness);
}
// In D8, we always have to assume that the field can be read, and thus have side effects.
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 5bddf13..1129616 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
@@ -34,8 +34,8 @@
import com.android.tools.r8.utils.StringUtils.BraceType;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
-import java.util.HashSet;
import java.util.Iterator;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
@@ -46,7 +46,7 @@
protected final List<Value> inValues = new ArrayList<>();
private BasicBlock block = null;
private int number = -1;
- private Set<Value> debugValues = null;
+ private LinkedHashSet<Value> debugValues = null;
private Position position = null;
protected Instruction(Value outValue) {
@@ -141,7 +141,7 @@
public void addDebugValue(Value value) {
assert value.hasLocalInfo();
if (debugValues == null) {
- debugValues = new HashSet<>();
+ debugValues = new LinkedHashSet<>();
}
if (debugValues.add(value)) {
value.addDebugUser(this);
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
index 48baef4..ab51239 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
@@ -25,6 +25,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.ArrayList;
import java.util.Collection;
@@ -218,14 +219,21 @@
assert false : "Expected to be able to find the enclosing class of a method definition";
return true;
}
- boolean targetMayHaveSideEffects;
+
if (appViewWithLiveness.appInfo().noSideEffects.containsKey(target.method)) {
- targetMayHaveSideEffects = false;
- } else {
- targetMayHaveSideEffects = target.getOptimizationInfo().mayHaveSideEffects();
+ return false;
}
- return targetMayHaveSideEffects;
+ MethodOptimizationInfo optimizationInfo = target.getOptimizationInfo();
+ if (target.isInstanceInitializer()) {
+ TrivialInitializer trivialInitializerInfo = optimizationInfo.getTrivialInitializerInfo();
+ if (trivialInitializerInfo != null
+ && trivialInitializerInfo.isTrivialInstanceInitializer()) {
+ return false;
+ }
+ }
+
+ return target.getOptimizationInfo().mayHaveSideEffects();
}
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/Move.java b/src/main/java/com/android/tools/r8/ir/code/Move.java
index 84da0d1..9054d07 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Move.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Move.java
@@ -122,4 +122,11 @@
public boolean instructionMayTriggerMethodInvocation(AppView<?> appView, DexType context) {
return false;
}
+
+ @Override
+ public boolean verifyTypes(AppView<?> appView) {
+ super.verifyTypes(appView);
+ assert src().getTypeLattice().equals(outValue().getTypeLattice());
+ return true;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
index 7e6fffe..7a38882 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
@@ -11,7 +11,10 @@
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
@@ -168,6 +171,18 @@
return true;
}
+ // Verify that the object does not have a finalizer.
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ ResolutionResult finalizeResolutionResult =
+ appView.appInfo().resolveMethod(clazz, dexItemFactory.objectMethods.finalize);
+ if (finalizeResolutionResult.hasSingleTarget()) {
+ DexMethod finalizeMethod = finalizeResolutionResult.asSingleTarget().method;
+ if (finalizeMethod != dexItemFactory.enumMethods.finalize
+ && finalizeMethod != dexItemFactory.objectMethods.finalize) {
+ return true;
+ }
+ }
+
return false;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Phi.java b/src/main/java/com/android/tools/r8/ir/code/Phi.java
index 95dac01..ae145b3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Phi.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Phi.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
@@ -342,7 +343,7 @@
@Override
public boolean isValueOnStack() {
- assert verifyIsStackPhi(new HashSet<>());
+ assert verifyIsStackPhi(Sets.newIdentityHashSet());
return isStackPhi;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
index 5d8fb67..63e5c10 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
@@ -15,16 +15,12 @@
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
-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;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -132,40 +128,6 @@
return true;
}
- /**
- * Returns {@code true} if this instruction may store a value that has a non-default finalize()
- * method in a static field. In that case, it is not safe to remove this instruction, since that
- * could change the lifetime of the value.
- */
- private boolean isStoringObjectWithFinalizer(AppInfoWithLiveness appInfo) {
- TypeLatticeElement type = value().getTypeLattice();
- TypeLatticeElement baseType =
- type.isArrayType() ? type.asArrayTypeLatticeElement().getArrayBaseTypeLattice() : type;
- if (baseType.isClassType()) {
- Value root = value().getAliasedValue();
- if (!root.isPhi() && root.definition.isNewInstance()) {
- DexClass clazz = appInfo.definitionFor(root.definition.asNewInstance().clazz);
- if (clazz == null) {
- return true;
- }
- if (clazz.superType == null) {
- return false;
- }
- DexItemFactory dexItemFactory = appInfo.dexItemFactory();
- DexEncodedMethod resolutionResult =
- appInfo
- .resolveMethod(clazz.type, dexItemFactory.objectMethods.finalize)
- .asSingleTarget();
- return resolutionResult != null && resolutionResult.isProgramMethod(appInfo);
- }
-
- return appInfo.mayHaveFinalizeMethodDirectlyOrIndirectly(
- baseType.asClassTypeLatticeElement().getClassType());
- }
-
- return false;
- }
-
@Override
public boolean canBeDeadCode(AppView<?> appView, IRCode code) {
// static-put can be dead as long as it cannot have any of the following:
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index 33b06c5..74add42 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -9,6 +9,8 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
@@ -28,7 +30,6 @@
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
@@ -37,7 +38,7 @@
import java.util.Set;
import java.util.function.Predicate;
-public class Value {
+public class Value implements Comparable<Value> {
public void constrainType(
ValueTypeConstraint constraint, DexMethod method, Origin origin, Reporter reporter) {
@@ -431,16 +432,20 @@
public Set<Instruction> aliasedUsers() {
Set<Instruction> users = SetUtils.newIdentityHashSet(uniqueUsers());
- collectAliasedUsersViaAssume(uniqueUsers(), users);
+ Set<Instruction> visited = Sets.newIdentityHashSet();
+ collectAliasedUsersViaAssume(visited, uniqueUsers(), users);
return users;
}
private static void collectAliasedUsersViaAssume(
- Set<Instruction> usersToTest, Set<Instruction> collectedUsers) {
+ Set<Instruction> visited, Set<Instruction> usersToTest, Set<Instruction> collectedUsers) {
for (Instruction user : usersToTest) {
+ if (!visited.add(user)) {
+ continue;
+ }
if (user.isAssume()) {
collectedUsers.addAll(user.outValue().uniqueUsers());
- collectAliasedUsersViaAssume(user.outValue().uniqueUsers(), collectedUsers);
+ collectAliasedUsersViaAssume(visited, user.outValue().uniqueUsers(), collectedUsers);
}
}
}
@@ -510,17 +515,6 @@
return false;
}
- public boolean mayDependOnEnvironment(AppView<?> appView, IRCode code) {
- Value root = getAliasedValue();
- if (root.isConstant()) {
- return false;
- }
- if (root.isConstantArrayThroughoutMethod(appView, code)) {
- return false;
- }
- return true;
- }
-
public boolean usedInMonitorOperation() {
for (Instruction instruction : uniqueUsers()) {
if (instruction.isMonitor()) {
@@ -760,6 +754,11 @@
}
@Override
+ public int compareTo(Value value) {
+ return Integer.compare(this.number, value.number);
+ }
+
+ @Override
public int hashCode() {
return number;
}
@@ -831,149 +830,33 @@
return definition.isOutConstant() && !hasLocalInfo();
}
- public boolean isConstantArrayThroughoutMethod(AppView<?> appView, IRCode code) {
+ public DexEncodedField getEnumField(AppView<?> appView) {
+ if (!appView.enableWholeProgramOptimizations()) {
+ return null;
+ }
+
Value root = getAliasedValue();
- if (root.isPhi()) {
- // Would need to track the aliases, just give up.
- return false;
+ if (root.isPhi() || !root.definition.isStaticGet()) {
+ return null;
}
- DexType context = code.method.method.holder;
- Instruction definition = root.definition;
-
- // Check that it is a constant array with a known size at this point in the IR.
- long size;
- if (definition.isInvokeNewArray()) {
- InvokeNewArray invokeNewArray = definition.asInvokeNewArray();
- for (Value argument : invokeNewArray.arguments()) {
- if (!argument.isConstant()) {
- return false;
- }
- }
- size = invokeNewArray.arguments().size();
- } else if (definition.isNewArrayEmpty()) {
- NewArrayEmpty newArrayEmpty = definition.asNewArrayEmpty();
- Value sizeValue = newArrayEmpty.size().getAliasedValue();
- if (!sizeValue.hasValueRange()) {
- return false;
- }
- LongInterval sizeRange = sizeValue.getValueRange();
- if (!sizeRange.isSingleValue()) {
- return false;
- }
- size = sizeRange.getSingleValue();
- } else {
- // Some other array creation.
- return false;
+ StaticGet staticGet = root.definition.asStaticGet();
+ DexField field = staticGet.getField();
+ if (field.type != field.holder) {
+ return null;
}
- if (size < 0) {
- // Check for NegativeArraySizeException.
- return false;
+ DexEncodedField encodedField = appView.definitionFor(field);
+ if (encodedField == null) {
+ return null;
}
- if (size == 0) {
- // Empty arrays are always constant.
- return true;
+ DexClass clazz = appView.definitionFor(encodedField.field.holder);
+ if (clazz == null || !clazz.isEnum()) {
+ return null;
}
- // Allow array-put and new-array-filled-data instructions that immediately follow the array
- // creation.
- Set<Instruction> consumedInstructions = Sets.newIdentityHashSet();
-
- for (Instruction instruction : definition.getBlock().instructionsAfter(definition)) {
- if (instruction.isArrayPut()) {
- ArrayPut arrayPut = instruction.asArrayPut();
- Value array = arrayPut.array().getAliasedValue();
- if (array != root) {
- // This ends the chain of array-put instructions that are allowed immediately after the
- // array creation.
- break;
- }
-
- LongInterval indexRange = arrayPut.index().getValueRange();
- if (!indexRange.isSingleValue()) {
- return false;
- }
-
- long index = indexRange.getSingleValue();
- if (index < 0 || index >= size) {
- return false;
- }
-
- if (!arrayPut.value().isConstant()) {
- return false;
- }
-
- consumedInstructions.add(arrayPut);
- continue;
- }
-
- if (instruction.isNewArrayFilledData()) {
- NewArrayFilledData newArrayFilledData = instruction.asNewArrayFilledData();
- Value array = newArrayFilledData.src();
- if (array != root) {
- break;
- }
-
- consumedInstructions.add(newArrayFilledData);
- continue;
- }
-
- if (instruction.instructionMayHaveSideEffects(appView, context)) {
- // This ends the chain of array-put instructions that are allowed immediately after the
- // array creation.
- break;
- }
- }
-
- // Check that the array is not mutated before the end of this method.
- //
- // Currently, we only allow the array to flow into static-put instructions that are not
- // followed by an instruction that may have side effects. Instructions that do not have any
- // side effects are ignored because they cannot mutate the array.
- Set<Instruction> visitedFromStaticPut = Sets.newIdentityHashSet();
- for (Instruction user : root.uniqueUsers()) {
- if (consumedInstructions.contains(user)) {
- continue;
- }
-
- if (user.isStaticPut()) {
- StaticPut staticPut = user.asStaticPut();
- if (visitedFromStaticPut.contains(staticPut)) {
- // Already visited previously.
- continue;
- }
- for (Instruction instruction : code.getInstructionsReachableFrom(staticPut)) {
- if (!visitedFromStaticPut.add(instruction)) {
- // Already visited previously.
- continue;
- }
- if (instruction.isStaticPut()) {
- StaticPut otherStaticPut = instruction.asStaticPut();
- if (otherStaticPut.getField().holder == staticPut.getField().holder
- && instruction.instructionInstanceCanThrow(appView, context).cannotThrow()) {
- continue;
- }
- return false;
- }
- if (instruction.instructionMayTriggerMethodInvocation(appView, context)) {
- return false;
- }
- }
- continue;
- }
-
- // Other user than static-put, just give up.
- return false;
- }
-
- if (root.numberOfPhiUsers() > 0) {
- // Could be mutated indirectly.
- return false;
- }
-
- return true;
+ return encodedField;
}
public boolean isPhi() {
@@ -1030,7 +913,7 @@
if (isPhi()) {
Phi self = this.asPhi();
if (seen == null) {
- seen = new HashSet<>();
+ seen = Sets.newIdentityHashSet();
}
if (seen.contains(self)) {
return true;
@@ -1101,7 +984,7 @@
public boolean isDead(AppView<?> appView, IRCode code, Predicate<Instruction> ignoreUser) {
// Totally unused values are trivially dead.
- return !isUsed() || isDead(appView, code, ignoreUser, new HashSet<>());
+ return !isUsed() || isDead(appView, code, ignoreUser, Sets.newIdentityHashSet());
}
/**
@@ -1209,7 +1092,8 @@
if (aliasedValue != null) {
// If there is an alias of the receiver, which is defined by an Assume<DynamicTypeAssumption>
// instruction, then use the dynamic type as the refined receiver type.
- lattice = aliasedValue.definition.asAssumeDynamicType().getAssumption().getType();
+ lattice =
+ aliasedValue.definition.asAssumeDynamicType().getAssumption().getDynamicUpperBoundType();
// For precision, verify that the dynamic type is at least as precise as the static type.
assert lattice.lessThanOrEqualUpToNullability(typeLattice, appView)
@@ -1250,7 +1134,7 @@
Value aliasedValue = getSpecificAliasedValue(value -> value.definition.isAssumeDynamicType());
if (aliasedValue != null) {
ClassTypeLatticeElement lattice =
- aliasedValue.definition.asAssumeDynamicType().getAssumption().getLowerBoundType();
+ aliasedValue.definition.asAssumeDynamicType().getAssumption().getDynamicLowerBoundType();
return lattice != null && typeLattice.isDefinitelyNotNull() && lattice.isNullable()
? lattice.asMeetWithNotNull().asClassTypeLatticeElement()
: lattice;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
index 307215a..b9f72f7 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
@@ -6,8 +6,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.ir.conversion.CallGraphBuilder.CycleEliminator;
-import com.android.tools.r8.ir.conversion.CallGraphBuilder.CycleEliminator.CycleEliminationResult;
+import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator.CycleEliminationResult;
import com.android.tools.r8.ir.conversion.CallSiteInformation.CallGraphBasedCallSiteInformation;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.Timing;
@@ -76,7 +75,14 @@
caller.callees.remove(this);
}
- public void cleanForRemoval() {
+ public void cleanCalleesForRemoval() {
+ assert callers.isEmpty();
+ for (Node callee : callees) {
+ callee.callers.remove(this);
+ }
+ }
+
+ public void cleanCallersForRemoval() {
assert callees.isEmpty();
for (Node caller : callers) {
caller.callees.remove(this);
@@ -103,6 +109,10 @@
return callers.contains(method);
}
+ public boolean isRoot() {
+ return callers.isEmpty();
+ }
+
public boolean isLeaf() {
return callees.isEmpty();
}
@@ -123,21 +133,24 @@
builder.append(callers.size());
builder.append(" callers");
builder.append(", invoke count ").append(numberOfCallSites);
- builder.append(").\n");
+ builder.append(").");
+ builder.append(System.lineSeparator());
if (callees.size() > 0) {
- builder.append("Callees:\n");
+ builder.append("Callees:");
+ builder.append(System.lineSeparator());
for (Node call : callees) {
builder.append(" ");
builder.append(call.method.toSourceString());
- builder.append("\n");
+ builder.append(System.lineSeparator());
}
}
if (callers.size() > 0) {
- builder.append("Callers:\n");
+ builder.append("Callers:");
+ builder.append(System.lineSeparator());
for (Node caller : callers) {
builder.append(" ");
builder.append(caller.method.toSourceString());
- builder.append("\n");
+ builder.append(System.lineSeparator());
}
}
return builder.toString();
@@ -156,14 +169,6 @@
return new CallGraphBuilder(appView);
}
- /**
- * Extract the next set of leaves (nodes with an call (outgoing) degree of 0) if any.
- *
- * <p>All nodes in the graph are extracted if called repeatedly until null is returned. Please
- * note that there are no cycles in this graph (see {@link CycleEliminator#breakCycles}).
- *
- * <p>
- */
static MethodProcessor createMethodProcessor(
AppView<AppInfoWithLiveness> appView, ExecutorService executorService, Timing timing)
throws ExecutionException {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilder.java
index 8078fe0..546c021 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilder.java
@@ -4,59 +4,26 @@
package com.android.tools.r8.ir.conversion;
-import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexCallSite;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLense.GraphLenseLookupResult;
-import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.conversion.CallGraph.Node;
-import com.android.tools.r8.ir.conversion.CallGraphBuilder.CycleEliminator.CycleEliminationResult;
-import com.android.tools.r8.logging.Log;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.ThreadUtils;
-import com.android.tools.r8.utils.Timing;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import java.util.ArrayDeque;
+import com.google.common.base.Predicates;
import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Deque;
-import java.util.IdentityHashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-import java.util.function.Consumer;
-public class CallGraphBuilder {
-
- private final AppView<AppInfoWithLiveness> appView;
- private final Map<DexMethod, Node> nodes = new IdentityHashMap<>();
- private final Map<DexMethod, Set<DexEncodedMethod>> possibleTargetsCache =
- new ConcurrentHashMap<>();
+public class CallGraphBuilder extends CallGraphBuilderBase {
CallGraphBuilder(AppView<AppInfoWithLiveness> appView) {
- this.appView = appView;
+ super(appView);
}
- public CallGraph build(ExecutorService executorService, Timing timing) throws ExecutionException {
+ @Override
+ void process(ExecutorService executorService) throws ExecutionException {
List<Future<?>> futures = new ArrayList<>();
for (DexProgramClass clazz : appView.appInfo().classes()) {
if (clazz.hasMethods()) {
@@ -69,19 +36,6 @@
}
}
ThreadUtils.awaitFutures(futures);
-
- assert verifyAllMethodsWithCodeExists();
-
- timing.begin("Cycle elimination");
- // Sort the nodes for deterministic cycle elimination.
- Set<Node> nodesWithDeterministicOrder = Sets.newTreeSet(nodes.values());
- CycleEliminator cycleEliminator =
- new CycleEliminator(nodesWithDeterministicOrder, appView.options());
- CycleEliminationResult cycleEliminationResult = cycleEliminator.breakCycles();
- timing.end();
- assert cycleEliminator.breakCycles().numberOfRemovedEdges() == 0; // The cycles should be gone.
-
- return new CallGraph(nodesWithDeterministicOrder, cycleEliminationResult);
}
private void processClass(DexProgramClass clazz) {
@@ -90,17 +44,13 @@
private void processMethod(DexEncodedMethod method) {
if (method.hasCode()) {
- method.registerCodeReferences(new InvokeExtractor(getOrCreateNode(method)));
+ method.registerCodeReferences(
+ new InvokeExtractor(getOrCreateNode(method), Predicates.alwaysTrue()));
}
}
- private Node getOrCreateNode(DexEncodedMethod method) {
- synchronized (nodes) {
- return nodes.computeIfAbsent(method.method, ignore -> new Node(method));
- }
- }
-
- private boolean verifyAllMethodsWithCodeExists() {
+ @Override
+ boolean verifyAllMethodsWithCodeExists() {
for (DexProgramClass clazz : appView.appInfo().classes()) {
for (DexEncodedMethod method : clazz.methods()) {
assert !method.hasCode() || nodes.get(method.method) != null;
@@ -108,454 +58,4 @@
}
return true;
}
-
- private class InvokeExtractor extends UseRegistry {
-
- private final Node caller;
-
- InvokeExtractor(Node caller) {
- super(appView.dexItemFactory());
- this.caller = caller;
- }
-
- private void addClassInitializerTarget(DexClass clazz) {
- assert clazz != null;
- if (clazz.isProgramClass() && clazz.hasClassInitializer()) {
- addTarget(clazz.getClassInitializer(), false);
- }
- }
-
- private void addClassInitializerTarget(DexType type) {
- assert type.isClassType();
- DexClass clazz = appView.definitionFor(type);
- if (clazz != null) {
- addClassInitializerTarget(clazz);
- }
- }
-
- private void addTarget(DexEncodedMethod callee, boolean likelySpuriousCallEdge) {
- if (callee.accessFlags.isAbstract()) {
- // Not a valid target.
- return;
- }
- if (appView.appInfo().isPinned(callee.method)) {
- // Since the callee is kept, we cannot inline it into the caller, and we also cannot collect
- // any optimization info for the method. Therefore, we drop the call edge to reduce the
- // total number of call graph edges, which should lead to fewer call graph cycles.
- return;
- }
- assert callee.isProgramMethod(appView);
- getOrCreateNode(callee).addCallerConcurrently(caller, likelySpuriousCallEdge);
- }
-
- private void processInvoke(Type originalType, DexMethod originalMethod) {
- DexEncodedMethod source = caller.method;
- DexMethod context = source.method;
- GraphLenseLookupResult result =
- appView.graphLense().lookupMethod(originalMethod, context, originalType);
- DexMethod method = result.getMethod();
- Type type = result.getType();
- if (type == Type.INTERFACE || type == Type.VIRTUAL) {
- // For virtual and interface calls add all potential targets that could be called.
- ResolutionResult resolutionResult = appView.appInfo().resolveMethod(method.holder, method);
- resolutionResult.forEachTarget(target -> processInvokeWithDynamicDispatch(type, target));
- } else {
- DexEncodedMethod singleTarget =
- appView.appInfo().lookupSingleTarget(type, method, context.holder);
- if (singleTarget != null) {
- assert !source.accessFlags.isBridge() || singleTarget != caller.method;
- DexClass clazz = appView.definitionFor(singleTarget.method.holder);
- assert clazz != null;
- if (clazz.isProgramClass()) {
- // For static invokes, the class could be initialized.
- if (type == Type.STATIC) {
- addClassInitializerTarget(clazz);
- }
- addTarget(singleTarget, false);
- }
- }
- }
- }
-
- private void processInvokeWithDynamicDispatch(Type type, DexEncodedMethod encodedTarget) {
- DexMethod target = encodedTarget.method;
- DexClass clazz = appView.definitionFor(target.holder);
- if (clazz == null) {
- assert false : "Unable to lookup holder of `" + target.toSourceString() + "`";
- return;
- }
-
- if (!appView.options().testing.addCallEdgesForLibraryInvokes) {
- if (clazz.isLibraryClass()) {
- // Likely to have many possible targets.
- return;
- }
- }
-
- boolean isInterface = type == Type.INTERFACE;
- Set<DexEncodedMethod> possibleTargets =
- possibleTargetsCache.computeIfAbsent(
- target,
- method -> {
- ResolutionResult resolution =
- appView.appInfo().resolveMethod(method.holder, method, isInterface);
- if (resolution.isValidVirtualTarget(appView.options())) {
- return resolution.lookupVirtualDispatchTargets(isInterface, appView.appInfo());
- }
- return null;
- });
- if (possibleTargets != null) {
- boolean likelySpuriousCallEdge =
- possibleTargets.size() >= appView.options().callGraphLikelySpuriousCallEdgeThreshold;
- for (DexEncodedMethod possibleTarget : possibleTargets) {
- if (possibleTarget.isProgramMethod(appView)) {
- addTarget(possibleTarget, likelySpuriousCallEdge);
- }
- }
- }
- }
-
- private void processFieldAccess(DexField field) {
- // Any field access implicitly calls the class initializer.
- if (field.holder.isClassType()) {
- DexEncodedField encodedField = appView.appInfo().resolveField(field);
- if (encodedField != null && encodedField.isStatic()) {
- addClassInitializerTarget(field.holder);
- }
- }
- }
-
- @Override
- public boolean registerInvokeVirtual(DexMethod method) {
- processInvoke(Type.VIRTUAL, method);
- return false;
- }
-
- @Override
- public boolean registerInvokeDirect(DexMethod method) {
- processInvoke(Type.DIRECT, method);
- return false;
- }
-
- @Override
- public boolean registerInvokeStatic(DexMethod method) {
- processInvoke(Type.STATIC, method);
- return false;
- }
-
- @Override
- public boolean registerInvokeInterface(DexMethod method) {
- processInvoke(Type.INTERFACE, method);
- return false;
- }
-
- @Override
- public boolean registerInvokeSuper(DexMethod method) {
- processInvoke(Type.SUPER, method);
- return false;
- }
-
- @Override
- public boolean registerInstanceFieldWrite(DexField field) {
- processFieldAccess(field);
- return false;
- }
-
- @Override
- public boolean registerInstanceFieldRead(DexField field) {
- processFieldAccess(field);
- return false;
- }
-
- @Override
- public boolean registerNewInstance(DexType type) {
- if (type.isClassType()) {
- addClassInitializerTarget(type);
- }
- return false;
- }
-
- @Override
- public boolean registerStaticFieldRead(DexField field) {
- processFieldAccess(field);
- return false;
- }
-
- @Override
- public boolean registerStaticFieldWrite(DexField field) {
- processFieldAccess(field);
- return false;
- }
-
- @Override
- public boolean registerTypeReference(DexType type) {
- return false;
- }
-
- @Override
- public void registerCallSite(DexCallSite callSite) {
- registerMethodHandle(
- callSite.bootstrapMethod, MethodHandleUse.NOT_ARGUMENT_TO_LAMBDA_METAFACTORY);
- }
- }
-
- public static class CycleEliminator {
-
- public static final String CYCLIC_FORCE_INLINING_MESSAGE =
- "Unable to satisfy force inlining constraints due to cyclic force inlining";
-
- private static class CallEdge {
-
- private final Node caller;
- private final Node callee;
-
- public CallEdge(Node caller, Node callee) {
- this.caller = caller;
- this.callee = callee;
- }
-
- public void remove() {
- callee.removeCaller(caller);
- }
- }
-
- public static class CycleEliminationResult {
-
- private Map<Node, Set<Node>> removedEdges;
-
- CycleEliminationResult(Map<Node, Set<Node>> removedEdges) {
- this.removedEdges = removedEdges;
- }
-
- void forEachRemovedCaller(Node callee, Consumer<Node> fn) {
- removedEdges.getOrDefault(callee, ImmutableSet.of()).forEach(fn);
- }
-
- public int numberOfRemovedEdges() {
- int numberOfRemovedEdges = 0;
- for (Set<Node> nodes : removedEdges.values()) {
- numberOfRemovedEdges += nodes.size();
- }
- return numberOfRemovedEdges;
- }
- }
-
- private final Collection<Node> nodes;
- private final InternalOptions options;
-
- // DFS stack.
- private Deque<Node> stack = new ArrayDeque<>();
-
- // Set of nodes on the DFS stack.
- private Set<Node> stackSet = Sets.newIdentityHashSet();
-
- // Set of nodes that have been visited entirely.
- private Set<Node> marked = Sets.newIdentityHashSet();
-
- // Mapping from callee to the set of callers that were removed from the callee.
- private Map<Node, Set<Node>> removedEdges = new IdentityHashMap<>();
-
- private int currentDepth = 0;
- private int maxDepth = 0;
-
- public CycleEliminator(Collection<Node> nodes, InternalOptions options) {
- this.options = options;
-
- // Call to reorderNodes must happen after assigning options.
- this.nodes =
- options.testing.nondeterministicCycleElimination
- ? reorderNodes(new ArrayList<>(nodes))
- : nodes;
- }
-
- public CycleEliminationResult breakCycles() {
- // Break cycles in this call graph by removing edges causing cycles.
- for (Node node : nodes) {
- assert currentDepth == 0;
- traverse(node);
- }
- CycleEliminationResult result = new CycleEliminationResult(removedEdges);
- if (Log.ENABLED) {
- Log.info(getClass(), "# call graph cycles broken: %s", result.numberOfRemovedEdges());
- Log.info(getClass(), "# max call graph depth: %s", maxDepth);
- }
- reset();
- return result;
- }
-
- private void reset() {
- assert currentDepth == 0;
- assert stack.isEmpty();
- assert stackSet.isEmpty();
- marked.clear();
- maxDepth = 0;
- removedEdges = new IdentityHashMap<>();
- }
-
- private void traverse(Node node) {
- if (Log.ENABLED) {
- if (currentDepth > maxDepth) {
- maxDepth = currentDepth;
- }
- }
-
- if (marked.contains(node)) {
- // Already visited all nodes that can be reached from this node.
- return;
- }
-
- push(node);
-
- // The callees must be sorted before calling traverse recursively. This ensures that cycles
- // are broken the same way across multiple compilations.
- Collection<Node> callees = node.getCalleesWithDeterministicOrder();
-
- if (options.testing.nondeterministicCycleElimination) {
- callees = reorderNodes(new ArrayList<>(callees));
- }
-
- Iterator<Node> calleeIterator = callees.iterator();
- while (calleeIterator.hasNext()) {
- Node callee = calleeIterator.next();
-
- // If we've exceeded the depth threshold, then treat it as if we have found a cycle. This
- // ensures that we won't run into stack overflows when the call graph contains large call
- // chains. This should have a negligible impact on code size as long as the threshold is
- // large enough.
- boolean foundCycle = stackSet.contains(callee);
- boolean thresholdExceeded =
- currentDepth >= options.callGraphCycleEliminatorMaxDepthThreshold
- && edgeRemovalIsSafe(node, callee);
- if (foundCycle || thresholdExceeded) {
- // Found a cycle that needs to be eliminated.
- if (edgeRemovalIsSafe(node, callee)) {
- // Break the cycle by removing the edge node->callee.
- if (options.testing.nondeterministicCycleElimination) {
- callee.removeCaller(node);
- } else {
- // Need to remove `callee` from `node.callees` using the iterator to prevent a
- // ConcurrentModificationException. This is not needed when nondeterministic cycle
- // elimination is enabled, because we iterate a copy of `node.callees` in that case.
- calleeIterator.remove();
- callee.getCallersWithDeterministicOrder().remove(node);
- }
- recordEdgeRemoval(node, callee);
-
- if (Log.ENABLED) {
- Log.info(
- CallGraph.class,
- "Removed call edge from method '%s' to '%s'",
- node.method.toSourceString(),
- callee.method.toSourceString());
- }
- } else {
- assert foundCycle;
-
- // The cycle has a method that is marked as force inline.
- LinkedList<Node> cycle = extractCycle(callee);
-
- if (Log.ENABLED) {
- Log.info(
- CallGraph.class, "Extracted cycle to find an edge that can safely be removed");
- }
-
- // Break the cycle by finding an edge that can be removed without breaking force
- // inlining. If that is not possible, this call fails with a compilation error.
- CallEdge edge = findCallEdgeForRemoval(cycle);
-
- // The edge will be null if this cycle has already been eliminated as a result of
- // another cycle elimination.
- if (edge != null) {
- assert edgeRemovalIsSafe(edge.caller, edge.callee);
-
- // Break the cycle by removing the edge caller->callee.
- edge.remove();
- recordEdgeRemoval(edge.caller, edge.callee);
-
- if (Log.ENABLED) {
- Log.info(
- CallGraph.class,
- "Removed call edge from force inlined method '%s' to '%s' to ensure that "
- + "force inlining will succeed",
- node.method.toSourceString(),
- callee.method.toSourceString());
- }
- }
-
- // Recover the stack.
- recoverStack(cycle);
- }
- } else {
- currentDepth++;
- traverse(callee);
- currentDepth--;
- }
- }
- pop(node);
- marked.add(node);
- }
-
- private void push(Node node) {
- stack.push(node);
- boolean changed = stackSet.add(node);
- assert changed;
- }
-
- private void pop(Node node) {
- Node popped = stack.pop();
- assert popped == node;
- boolean changed = stackSet.remove(node);
- assert changed;
- }
-
- private LinkedList<Node> extractCycle(Node entry) {
- LinkedList<Node> cycle = new LinkedList<>();
- do {
- assert !stack.isEmpty();
- cycle.add(stack.pop());
- } while (cycle.getLast() != entry);
- return cycle;
- }
-
- private CallEdge findCallEdgeForRemoval(LinkedList<Node> extractedCycle) {
- Node callee = extractedCycle.getLast();
- for (Node caller : extractedCycle) {
- if (!caller.hasCallee(callee)) {
- // No need to break any edges since this cycle has already been broken previously.
- assert !callee.hasCaller(caller);
- return null;
- }
- if (edgeRemovalIsSafe(caller, callee)) {
- return new CallEdge(caller, callee);
- }
- callee = caller;
- }
- throw new CompilationError(CYCLIC_FORCE_INLINING_MESSAGE);
- }
-
- private static boolean edgeRemovalIsSafe(Node caller, Node callee) {
- // All call edges where the callee is a method that should be force inlined must be kept,
- // to guarantee that the IR converter will process the callee before the caller.
- return !callee.method.getOptimizationInfo().forceInline();
- }
-
- private void recordEdgeRemoval(Node caller, Node callee) {
- removedEdges.computeIfAbsent(callee, ignore -> SetUtils.newIdentityHashSet(2)).add(caller);
- }
-
- private void recoverStack(LinkedList<Node> extractedCycle) {
- Iterator<Node> descendingIt = extractedCycle.descendingIterator();
- while (descendingIt.hasNext()) {
- stack.push(descendingIt.next());
- }
- }
-
- private Collection<Node> reorderNodes(List<Node> nodes) {
- assert options.testing.nondeterministicCycleElimination;
- if (!InternalOptions.DETERMINISTIC_DEBUGGING) {
- Collections.shuffle(nodes);
- }
- return nodes;
- }
- }
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java
new file mode 100644
index 0000000..1e0a60d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java
@@ -0,0 +1,536 @@
+// Copyright (c) 2019, 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.conversion;
+
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexCallSite;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLense.GraphLenseLookupResult;
+import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.ir.code.Invoke;
+import com.android.tools.r8.ir.conversion.CallGraph.Node;
+import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator.CycleEliminationResult;
+import com.android.tools.r8.logging.Log;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+abstract class CallGraphBuilderBase {
+ final AppView<AppInfoWithLiveness> appView;
+ final Map<DexMethod, Node> nodes = new IdentityHashMap<>();
+ private final Map<DexMethod, Set<DexEncodedMethod>> possibleTargetsCache =
+ new ConcurrentHashMap<>();
+
+ CallGraphBuilderBase(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
+
+ public CallGraph build(ExecutorService executorService, Timing timing) throws ExecutionException {
+ process(executorService);
+ assert verifyAllMethodsWithCodeExists();
+
+ timing.begin("Cycle elimination");
+ // Sort the nodes for deterministic cycle elimination.
+ Set<Node> nodesWithDeterministicOrder = Sets.newTreeSet(nodes.values());
+ CycleEliminator cycleEliminator =
+ new CycleEliminator(nodesWithDeterministicOrder, appView.options());
+ CycleEliminationResult cycleEliminationResult = cycleEliminator.breakCycles();
+ timing.end();
+ assert cycleEliminator.breakCycles().numberOfRemovedEdges() == 0; // The cycles should be gone.
+
+ return new CallGraph(nodesWithDeterministicOrder, cycleEliminationResult);
+ }
+
+ abstract void process(ExecutorService executorService) throws ExecutionException;
+
+ Node getOrCreateNode(DexEncodedMethod method) {
+ synchronized (nodes) {
+ return nodes.computeIfAbsent(method.method, ignore -> new Node(method));
+ }
+ }
+
+ abstract boolean verifyAllMethodsWithCodeExists();
+
+ class InvokeExtractor extends UseRegistry {
+
+ private final Node caller;
+ private final Predicate<DexEncodedMethod> targetTester;
+
+ InvokeExtractor(Node caller, Predicate<DexEncodedMethod> targetTester) {
+ super(appView.dexItemFactory());
+ this.caller = caller;
+ this.targetTester = targetTester;
+ }
+
+ private void addClassInitializerTarget(DexClass clazz) {
+ assert clazz != null;
+ if (clazz.isProgramClass() && clazz.hasClassInitializer()) {
+ addTarget(clazz.getClassInitializer(), false);
+ }
+ }
+
+ private void addClassInitializerTarget(DexType type) {
+ assert type.isClassType();
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz != null) {
+ addClassInitializerTarget(clazz);
+ }
+ }
+
+ private void addTarget(DexEncodedMethod callee, boolean likelySpuriousCallEdge) {
+ if (!targetTester.test(callee)) {
+ return;
+ }
+ if (callee.accessFlags.isAbstract()) {
+ // Not a valid target.
+ return;
+ }
+ if (appView.appInfo().isPinned(callee.method)) {
+ // Since the callee is kept, we cannot inline it into the caller, and we also cannot collect
+ // any optimization info for the method. Therefore, we drop the call edge to reduce the
+ // total number of call graph edges, which should lead to fewer call graph cycles.
+ return;
+ }
+ assert callee.isProgramMethod(appView);
+ getOrCreateNode(callee).addCallerConcurrently(caller, likelySpuriousCallEdge);
+ }
+
+ private void processInvoke(Invoke.Type originalType, DexMethod originalMethod) {
+ DexEncodedMethod source = caller.method;
+ DexMethod context = source.method;
+ GraphLenseLookupResult result =
+ appView.graphLense().lookupMethod(originalMethod, context, originalType);
+ DexMethod method = result.getMethod();
+ Invoke.Type type = result.getType();
+ if (type == Invoke.Type.INTERFACE || type == Invoke.Type.VIRTUAL) {
+ // For virtual and interface calls add all potential targets that could be called.
+ ResolutionResult resolutionResult = appView.appInfo().resolveMethod(method.holder, method);
+ resolutionResult.forEachTarget(target -> processInvokeWithDynamicDispatch(type, target));
+ } else {
+ DexEncodedMethod singleTarget =
+ appView.appInfo().lookupSingleTarget(type, method, context.holder);
+ if (singleTarget != null) {
+ assert !source.accessFlags.isBridge() || singleTarget != caller.method;
+ DexClass clazz = appView.definitionFor(singleTarget.method.holder);
+ assert clazz != null;
+ if (clazz.isProgramClass()) {
+ // For static invokes, the class could be initialized.
+ if (type == Invoke.Type.STATIC) {
+ addClassInitializerTarget(clazz);
+ }
+ addTarget(singleTarget, false);
+ }
+ }
+ }
+ }
+
+ private void processInvokeWithDynamicDispatch(
+ Invoke.Type type, DexEncodedMethod encodedTarget) {
+ DexMethod target = encodedTarget.method;
+ DexClass clazz = appView.definitionFor(target.holder);
+ if (clazz == null) {
+ assert false : "Unable to lookup holder of `" + target.toSourceString() + "`";
+ return;
+ }
+
+ if (!appView.options().testing.addCallEdgesForLibraryInvokes) {
+ if (clazz.isLibraryClass()) {
+ // Likely to have many possible targets.
+ return;
+ }
+ }
+
+ boolean isInterface = type == Invoke.Type.INTERFACE;
+ Set<DexEncodedMethod> possibleTargets =
+ possibleTargetsCache.computeIfAbsent(
+ target,
+ method -> {
+ ResolutionResult resolution =
+ appView.appInfo().resolveMethod(method.holder, method, isInterface);
+ if (resolution.isValidVirtualTarget(appView.options())) {
+ return resolution.lookupVirtualDispatchTargets(isInterface, appView.appInfo());
+ }
+ return null;
+ });
+ if (possibleTargets != null) {
+ boolean likelySpuriousCallEdge =
+ possibleTargets.size() >= appView.options().callGraphLikelySpuriousCallEdgeThreshold;
+ for (DexEncodedMethod possibleTarget : possibleTargets) {
+ if (possibleTarget.isProgramMethod(appView)) {
+ addTarget(possibleTarget, likelySpuriousCallEdge);
+ }
+ }
+ }
+ }
+
+ private void processFieldAccess(DexField field) {
+ // Any field access implicitly calls the class initializer.
+ if (field.holder.isClassType()) {
+ DexEncodedField encodedField = appView.appInfo().resolveField(field);
+ if (encodedField != null && encodedField.isStatic()) {
+ addClassInitializerTarget(field.holder);
+ }
+ }
+ }
+
+ @Override
+ public boolean registerInvokeVirtual(DexMethod method) {
+ processInvoke(Invoke.Type.VIRTUAL, method);
+ return false;
+ }
+
+ @Override
+ public boolean registerInvokeDirect(DexMethod method) {
+ processInvoke(Invoke.Type.DIRECT, method);
+ return false;
+ }
+
+ @Override
+ public boolean registerInvokeStatic(DexMethod method) {
+ processInvoke(Invoke.Type.STATIC, method);
+ return false;
+ }
+
+ @Override
+ public boolean registerInvokeInterface(DexMethod method) {
+ processInvoke(Invoke.Type.INTERFACE, method);
+ return false;
+ }
+
+ @Override
+ public boolean registerInvokeSuper(DexMethod method) {
+ processInvoke(Invoke.Type.SUPER, method);
+ return false;
+ }
+
+ @Override
+ public boolean registerInstanceFieldWrite(DexField field) {
+ processFieldAccess(field);
+ return false;
+ }
+
+ @Override
+ public boolean registerInstanceFieldRead(DexField field) {
+ processFieldAccess(field);
+ return false;
+ }
+
+ @Override
+ public boolean registerNewInstance(DexType type) {
+ if (type.isClassType()) {
+ addClassInitializerTarget(type);
+ }
+ return false;
+ }
+
+ @Override
+ public boolean registerStaticFieldRead(DexField field) {
+ processFieldAccess(field);
+ return false;
+ }
+
+ @Override
+ public boolean registerStaticFieldWrite(DexField field) {
+ processFieldAccess(field);
+ return false;
+ }
+
+ @Override
+ public boolean registerTypeReference(DexType type) {
+ return false;
+ }
+
+ @Override
+ public void registerCallSite(DexCallSite callSite) {
+ registerMethodHandle(
+ callSite.bootstrapMethod, MethodHandleUse.NOT_ARGUMENT_TO_LAMBDA_METAFACTORY);
+ }
+ }
+
+ static class CycleEliminator {
+
+ static final String CYCLIC_FORCE_INLINING_MESSAGE =
+ "Unable to satisfy force inlining constraints due to cyclic force inlining";
+
+ private static class CallEdge {
+
+ private final Node caller;
+ private final Node callee;
+
+ CallEdge(Node caller, Node callee) {
+ this.caller = caller;
+ this.callee = callee;
+ }
+
+ public void remove() {
+ callee.removeCaller(caller);
+ }
+ }
+
+ static class CycleEliminationResult {
+
+ private Map<Node, Set<Node>> removedEdges;
+
+ CycleEliminationResult(Map<Node, Set<Node>> removedEdges) {
+ this.removedEdges = removedEdges;
+ }
+
+ void forEachRemovedCaller(Node callee, Consumer<Node> fn) {
+ removedEdges.getOrDefault(callee, ImmutableSet.of()).forEach(fn);
+ }
+
+ int numberOfRemovedEdges() {
+ int numberOfRemovedEdges = 0;
+ for (Set<Node> nodes : removedEdges.values()) {
+ numberOfRemovedEdges += nodes.size();
+ }
+ return numberOfRemovedEdges;
+ }
+ }
+
+ private final Collection<Node> nodes;
+ private final InternalOptions options;
+
+ // DFS stack.
+ private Deque<Node> stack = new ArrayDeque<>();
+
+ // Set of nodes on the DFS stack.
+ private Set<Node> stackSet = Sets.newIdentityHashSet();
+
+ // Set of nodes that have been visited entirely.
+ private Set<Node> marked = Sets.newIdentityHashSet();
+
+ // Mapping from callee to the set of callers that were removed from the callee.
+ private Map<Node, Set<Node>> removedEdges = new IdentityHashMap<>();
+
+ private int currentDepth = 0;
+ private int maxDepth = 0;
+
+ CycleEliminator(Collection<Node> nodes, InternalOptions options) {
+ this.options = options;
+
+ // Call to reorderNodes must happen after assigning options.
+ this.nodes =
+ options.testing.nondeterministicCycleElimination
+ ? reorderNodes(new ArrayList<>(nodes))
+ : nodes;
+ }
+
+ CycleEliminationResult breakCycles() {
+ // Break cycles in this call graph by removing edges causing cycles.
+ for (Node node : nodes) {
+ assert currentDepth == 0;
+ traverse(node);
+ }
+ CycleEliminationResult result = new CycleEliminationResult(removedEdges);
+ if (Log.ENABLED) {
+ Log.info(getClass(), "# call graph cycles broken: %s", result.numberOfRemovedEdges());
+ Log.info(getClass(), "# max call graph depth: %s", maxDepth);
+ }
+ reset();
+ return result;
+ }
+
+ private void reset() {
+ assert currentDepth == 0;
+ assert stack.isEmpty();
+ assert stackSet.isEmpty();
+ marked.clear();
+ maxDepth = 0;
+ removedEdges = new IdentityHashMap<>();
+ }
+
+ private void traverse(Node node) {
+ if (Log.ENABLED) {
+ if (currentDepth > maxDepth) {
+ maxDepth = currentDepth;
+ }
+ }
+
+ if (marked.contains(node)) {
+ // Already visited all nodes that can be reached from this node.
+ return;
+ }
+
+ push(node);
+
+ // The callees must be sorted before calling traverse recursively. This ensures that cycles
+ // are broken the same way across multiple compilations.
+ Collection<Node> callees = node.getCalleesWithDeterministicOrder();
+
+ if (options.testing.nondeterministicCycleElimination) {
+ callees = reorderNodes(new ArrayList<>(callees));
+ }
+
+ Iterator<Node> calleeIterator = callees.iterator();
+ while (calleeIterator.hasNext()) {
+ Node callee = calleeIterator.next();
+
+ // If we've exceeded the depth threshold, then treat it as if we have found a cycle. This
+ // ensures that we won't run into stack overflows when the call graph contains large call
+ // chains. This should have a negligible impact on code size as long as the threshold is
+ // large enough.
+ boolean foundCycle = stackSet.contains(callee);
+ boolean thresholdExceeded =
+ currentDepth >= options.callGraphCycleEliminatorMaxDepthThreshold
+ && edgeRemovalIsSafe(node, callee);
+ if (foundCycle || thresholdExceeded) {
+ // Found a cycle that needs to be eliminated.
+ if (edgeRemovalIsSafe(node, callee)) {
+ // Break the cycle by removing the edge node->callee.
+ if (options.testing.nondeterministicCycleElimination) {
+ callee.removeCaller(node);
+ } else {
+ // Need to remove `callee` from `node.callees` using the iterator to prevent a
+ // ConcurrentModificationException. This is not needed when nondeterministic cycle
+ // elimination is enabled, because we iterate a copy of `node.callees` in that case.
+ calleeIterator.remove();
+ callee.getCallersWithDeterministicOrder().remove(node);
+ }
+ recordEdgeRemoval(node, callee);
+
+ if (Log.ENABLED) {
+ Log.info(
+ CallGraph.class,
+ "Removed call edge from method '%s' to '%s'",
+ node.method.toSourceString(),
+ callee.method.toSourceString());
+ }
+ } else {
+ assert foundCycle;
+
+ // The cycle has a method that is marked as force inline.
+ LinkedList<Node> cycle = extractCycle(callee);
+
+ if (Log.ENABLED) {
+ Log.info(
+ CallGraph.class, "Extracted cycle to find an edge that can safely be removed");
+ }
+
+ // Break the cycle by finding an edge that can be removed without breaking force
+ // inlining. If that is not possible, this call fails with a compilation error.
+ CallEdge edge = findCallEdgeForRemoval(cycle);
+
+ // The edge will be null if this cycle has already been eliminated as a result of
+ // another cycle elimination.
+ if (edge != null) {
+ assert edgeRemovalIsSafe(edge.caller, edge.callee);
+
+ // Break the cycle by removing the edge caller->callee.
+ edge.remove();
+ recordEdgeRemoval(edge.caller, edge.callee);
+
+ if (Log.ENABLED) {
+ Log.info(
+ CallGraph.class,
+ "Removed call edge from force inlined method '%s' to '%s' to ensure that "
+ + "force inlining will succeed",
+ node.method.toSourceString(),
+ callee.method.toSourceString());
+ }
+ }
+
+ // Recover the stack.
+ recoverStack(cycle);
+ }
+ } else {
+ currentDepth++;
+ traverse(callee);
+ currentDepth--;
+ }
+ }
+ pop(node);
+ marked.add(node);
+ }
+
+ private void push(Node node) {
+ stack.push(node);
+ boolean changed = stackSet.add(node);
+ assert changed;
+ }
+
+ private void pop(Node node) {
+ Node popped = stack.pop();
+ assert popped == node;
+ boolean changed = stackSet.remove(node);
+ assert changed;
+ }
+
+ private LinkedList<Node> extractCycle(Node entry) {
+ LinkedList<Node> cycle = new LinkedList<>();
+ do {
+ assert !stack.isEmpty();
+ cycle.add(stack.pop());
+ } while (cycle.getLast() != entry);
+ return cycle;
+ }
+
+ private CallEdge findCallEdgeForRemoval(LinkedList<Node> extractedCycle) {
+ Node callee = extractedCycle.getLast();
+ for (Node caller : extractedCycle) {
+ if (!caller.hasCallee(callee)) {
+ // No need to break any edges since this cycle has already been broken previously.
+ assert !callee.hasCaller(caller);
+ return null;
+ }
+ if (edgeRemovalIsSafe(caller, callee)) {
+ return new CallEdge(caller, callee);
+ }
+ callee = caller;
+ }
+ throw new CompilationError(CYCLIC_FORCE_INLINING_MESSAGE);
+ }
+
+ private static boolean edgeRemovalIsSafe(Node caller, Node callee) {
+ // All call edges where the callee is a method that should be force inlined must be kept,
+ // to guarantee that the IR converter will process the callee before the caller.
+ return !callee.method.getOptimizationInfo().forceInline();
+ }
+
+ private void recordEdgeRemoval(Node caller, Node callee) {
+ removedEdges.computeIfAbsent(callee, ignore -> SetUtils.newIdentityHashSet(2)).add(caller);
+ }
+
+ private void recoverStack(LinkedList<Node> extractedCycle) {
+ Iterator<Node> descendingIt = extractedCycle.descendingIterator();
+ while (descendingIt.hasNext()) {
+ stack.push(descendingIt.next());
+ }
+ }
+
+ private Collection<Node> reorderNodes(List<Node> nodes) {
+ assert options.testing.nondeterministicCycleElimination;
+ if (!InternalOptions.DETERMINISTIC_DEBUGGING) {
+ Collections.shuffle(nodes);
+ }
+ return nodes;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
index 50fde0e..46a0cc4 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.conversion;
import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
public interface FieldOptimizationFeedback {
@@ -13,7 +14,9 @@
void markFieldAsPropagated(DexEncodedField field);
- void markFieldHasDynamicType(DexEncodedField field, TypeLatticeElement type);
+ void markFieldHasDynamicLowerBoundType(DexEncodedField field, ClassTypeLatticeElement type);
+
+ void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeLatticeElement type);
void markFieldBitsRead(DexEncodedField field, int bitsRead);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 995a583..7ef6cd5 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -620,8 +620,12 @@
}
// Update the IR code if collected call site optimization info has something useful.
+ // While aggregation of parameter information at call sites would be more precise than static
+ // types, those could be still less precise at one single call site, where specific arguments
+ // will be passed during (double) inlining. Instead of adding assumptions and removing invalid
+ // ones, it's better not to insert assumptions for inlinee in the beginning.
CallSiteOptimizationInfo callSiteOptimizationInfo = method.getCallSiteOptimizationInfo();
- if (appView.callSiteOptimizationInfoPropagator() != null) {
+ if (method == context && appView.callSiteOptimizationInfoPropagator() != null) {
appView.callSiteOptimizationInfoPropagator()
.applyCallSiteOptimizationInfo(ir, callSiteOptimizationInfo);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index dd3416f..7e15e72 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -205,7 +205,6 @@
.map(prefix -> "L" + DescriptorUtils.getPackageBinaryNameFromJavaType(prefix))
.map(options.itemFactory::createString)
.collect(Collectors.toList());
- this.methodOptimizationInfoCollector = new MethodOptimizationInfoCollector(appView);
if (options.isDesugaredLibraryCompilation()) {
// Specific L8 Settings.
// BackportedMethodRewriter is needed for retarget core library members and backports.
@@ -241,6 +240,7 @@
this.stringSwitchRemover = null;
this.desugaredLibraryAPIConverter = null;
this.serviceLoaderRewriter = null;
+ this.methodOptimizationInfoCollector = null;
return;
}
this.lambdaRewriter = options.enableDesugaring ? new LambdaRewriter(appView, this) : null;
@@ -287,13 +287,16 @@
options.enableTreeShakingOfLibraryMethodOverrides
? new LibraryMethodOverrideAnalysis(appViewWithLiveness)
: null;
- this.lensCodeRewriter = new LensCodeRewriter(appViewWithLiveness, lambdaRewriter);
- this.inliner = new Inliner(appViewWithLiveness, mainDexClasses, lensCodeRewriter);
this.lambdaMerger =
options.enableLambdaMerging ? new LambdaMerger(appViewWithLiveness) : null;
+ this.lensCodeRewriter = new LensCodeRewriter(appViewWithLiveness, lambdaRewriter);
+ this.inliner =
+ new Inliner(appViewWithLiveness, mainDexClasses, lambdaMerger, lensCodeRewriter);
this.outliner = new Outliner(appViewWithLiveness, this);
this.memberValuePropagation =
options.enableValuePropagation ? new MemberValuePropagation(appViewWithLiveness) : null;
+ this.methodOptimizationInfoCollector =
+ new MethodOptimizationInfoCollector(appViewWithLiveness);
if (options.isMinifying()) {
this.identifierNameStringMarker = new IdentifierNameStringMarker(appViewWithLiveness);
} else {
@@ -329,6 +332,7 @@
this.d8NestBasedAccessDesugaring =
options.shouldDesugarNests() ? new D8NestBasedAccessDesugaring(appView) : null;
this.serviceLoaderRewriter = null;
+ this.methodOptimizationInfoCollector = null;
}
this.stringSwitchRemover =
options.isStringSwitchConversionEnabled()
@@ -429,7 +433,7 @@
private void synthesizeJava8UtilityClass(
Builder<?> builder, ExecutorService executorService) throws ExecutionException {
if (backportedMethodRewriter != null) {
- backportedMethodRewriter.synthesizeUtilityClass(builder, executorService, options);
+ backportedMethodRewriter.synthesizeUtilityClasses(builder, executorService);
}
}
@@ -685,6 +689,7 @@
CallSiteInformation.empty(),
Outliner::noProcessing),
executorService);
+ feedback.updateVisibleOptimizationInfo();
timing.end();
}
@@ -852,6 +857,7 @@
// unused out-values.
codeRewriter.rewriteMoveResult(code);
deadCodeRemover.run(code);
+ codeRewriter.removeAssumeInstructions(code);
consumer.accept(code, method);
return null;
}));
@@ -879,7 +885,7 @@
private void collectLambdaMergingCandidates(DexApplication application) {
if (lambdaMerger != null) {
- lambdaMerger.collectGroupCandidates(application, appView.withLiveness());
+ lambdaMerger.collectGroupCandidates(application);
}
}
@@ -1116,6 +1122,11 @@
}
}
+ if (lambdaMerger != null) {
+ lambdaMerger.rewriteCode(method, code);
+ assert code.isConsistentSSA();
+ }
+
if (typeChecker != null && !typeChecker.check(code)) {
assert appView.enableWholeProgramOptimizations();
assert options.testing.allowTypeErrors;
@@ -1242,9 +1253,10 @@
if (stringSwitchRemover != null) {
stringSwitchRemover.run(method, code);
}
- codeRewriter.rewriteSwitch(code);
codeRewriter.processMethodsNeverReturningNormally(code);
- codeRewriter.simplifyIf(code);
+ if (codeRewriter.simplifyControlFlow(code)) {
+ codeRewriter.removeTrivialCheckCastAndInstanceOfInstructions(code);
+ }
if (options.enableRedundantConstNumberOptimization) {
codeRewriter.redundantConstNumberRemoval(code);
}
@@ -1351,7 +1363,7 @@
previous = printMethod(code, "IR after twr close resource rewriter (SSA)", previous);
if (lambdaMerger != null) {
- lambdaMerger.processMethodCode(method, code);
+ lambdaMerger.analyzeCode(method, code);
assert code.isConsistentSSA();
}
@@ -1389,24 +1401,6 @@
classStaticizer.examineMethodCode(method, code);
}
- if (nonNullTracker != null) {
- // TODO(b/139246447): Once we extend this optimization to, e.g., constants of primitive args,
- // this may not be the right place to collect call site optimization info.
- // Collecting call-site optimization info depends on the existence of non-null IRs.
- // Arguments can be changed during the debug mode.
- if (!isDebugMode && appView.callSiteOptimizationInfoPropagator() != null) {
- appView.callSiteOptimizationInfoPropagator().collectCallSiteOptimizationInfo(code);
- }
- // Computation of non-null parameters on normal exits rely on the existence of non-null IRs.
- methodOptimizationInfoCollector.computeNonNullParamOnNormalExits(feedback, code);
- }
- if (aliasIntroducer != null || nonNullTracker != null || dynamicTypeOptimization != null) {
- codeRewriter.removeAssumeInstructions(code);
- assert code.isConsistentSSA();
- }
- // Assert that we do not have unremoved non-sense code in the output, e.g., v <- non-null NULL.
- assert code.verifyNoNullabilityBottomTypes();
-
assert code.verifyTypes(appView);
if (appView.enableWholeProgramOptimizations()) {
@@ -1418,31 +1412,30 @@
fieldBitAccessAnalysis.recordFieldAccesses(code, feedback);
}
+ // Arguments can be changed during the debug mode.
+ if (!isDebugMode && appView.callSiteOptimizationInfoPropagator() != null) {
+ appView.callSiteOptimizationInfoPropagator().collectCallSiteOptimizationInfo(code);
+ }
+
// Compute optimization info summary for the current method unless it is pinned
// (in that case we should not be making any assumptions about the behavior of the method).
if (!appView.appInfo().withLiveness().isPinned(method.method)) {
- methodOptimizationInfoCollector.identifyClassInlinerEligibility(method, code, feedback);
- methodOptimizationInfoCollector.identifyParameterUsages(method, code, feedback);
- methodOptimizationInfoCollector.identifyReturnsArgument(method, code, feedback);
- methodOptimizationInfoCollector.identifyTrivialInitializer(method, code, feedback);
-
- if (options.enableInlining && inliner != null) {
- methodOptimizationInfoCollector
- .identifyInvokeSemanticsForInlining(method, code, appView, feedback);
- }
-
methodOptimizationInfoCollector
- .computeDynamicReturnType(dynamicTypeOptimization, feedback, method, code);
+ .collectMethodOptimizationInfo(method, code, feedback, dynamicTypeOptimization);
FieldValueAnalysis.run(appView, code, feedback, method);
- methodOptimizationInfoCollector
- .computeInitializedClassesOnNormalExit(feedback, method, code);
- methodOptimizationInfoCollector.computeMayHaveSideEffects(feedback, method, code);
- methodOptimizationInfoCollector
- .computeReturnValueOnlyDependsOnArguments(feedback, method, code);
- methodOptimizationInfoCollector.computeNonNullParamOrThrow(feedback, method, code);
}
}
+ if (aliasIntroducer != null || nonNullTracker != null || dynamicTypeOptimization != null) {
+ codeRewriter.removeAssumeInstructions(code);
+ assert code.isConsistentSSA();
+ }
+
+ // Assert that we do not have unremoved non-sense code in the output, e.g., v <- non-null NULL.
+ assert code.verifyNoNullabilityBottomTypes();
+
+ assert code.verifyTypes(appView);
+
previous =
printMethod(code, "IR after computation of optimization info summary (SSA)", previous);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
index 9a55240..a7933d2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.ir.conversion.CallGraph.Node;
+import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.Action;
import com.android.tools.r8.utils.IROrdering;
@@ -70,7 +71,13 @@
return waves;
}
- private static void extractLeaves(Set<Node> nodes, Consumer<Node> fn) {
+ /**
+ * Extract the next set of leaves (nodes with an outgoing call degree of 0) if any.
+ *
+ * <p>All nodes in the graph are extracted if called repeatedly until null is returned. Please
+ * note that there are no cycles in this graph (see {@link CycleEliminator#breakCycles}).
+ */
+ static void extractLeaves(Set<Node> nodes, Consumer<Node> fn) {
Set<Node> removed = Sets.newIdentityHashSet();
Iterator<Node> nodeIterator = nodes.iterator();
while (nodeIterator.hasNext()) {
@@ -81,7 +88,7 @@
removed.add(node);
}
}
- removed.forEach(Node::cleanForRemoval);
+ removed.forEach(Node::cleanCallersForRemoval);
}
/**
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PartialCallGraphBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/PartialCallGraphBuilder.java
new file mode 100644
index 0000000..ae2c5c5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PartialCallGraphBuilder.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2019, 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.conversion;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.ThreadUtils;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+public class PartialCallGraphBuilder extends CallGraphBuilderBase {
+ private final Set<DexEncodedMethod> seeds;
+
+ PartialCallGraphBuilder(AppView<AppInfoWithLiveness> appView, Set<DexEncodedMethod> seeds) {
+ super(appView);
+ assert seeds != null && !seeds.isEmpty();
+ this.seeds = seeds;
+ }
+
+ @Override
+ void process(ExecutorService executorService) throws ExecutionException {
+ List<Future<?>> futures = new ArrayList<>();
+ for (DexEncodedMethod method : seeds) {
+ futures.add(
+ executorService.submit(
+ () -> {
+ processMethod(method);
+ return null; // we want a Callable not a Runnable to be able to throw
+ }));
+ }
+ ThreadUtils.awaitFutures(futures);
+ }
+
+ private void processMethod(DexEncodedMethod method) {
+ if (method.hasCode()) {
+ method.registerCodeReferences(
+ new InvokeExtractor(getOrCreateNode(method), seeds::contains));
+ }
+ }
+
+ @Override
+ boolean verifyAllMethodsWithCodeExists() {
+ for (DexEncodedMethod method : seeds) {
+ assert !method.hasCode() || nodes.get(method.method) != null;
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
new file mode 100644
index 0000000..13566359
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2019, 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.conversion;
+
+import com.android.tools.r8.ir.conversion.CallGraph.Node;
+import com.google.common.collect.Sets;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class PostMethodProcessor {
+
+ /**
+ * Extract the next set of roots (nodes with an incoming call degree of 0) if any.
+ *
+ * <p>All nodes in the graph are extracted if called repeatedly until null is returned.
+ */
+ static void extractRoots(Set<Node> nodes, Consumer<Node> fn) {
+ Set<Node> removed = Sets.newIdentityHashSet();
+ Iterator<Node> nodeIterator = nodes.iterator();
+ while (nodeIterator.hasNext()) {
+ Node node = nodeIterator.next();
+ if (node.isRoot()) {
+ fn.accept(node);
+ nodeIterator.remove();
+ removed.add(node);
+ }
+ }
+ removed.forEach(Node::cleanCalleesForRemoval);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index be6ffb2..bf82f85 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -100,7 +100,34 @@
InvokeMethod invoke = instruction.asInvokeMethod();
MethodProvider provider = getMethodProviderOrNull(invoke.getInvokedMethod());
if (provider == null) {
- continue;
+ if (!rewritableMethods.matchesVirtualRewrite(invoke.getInvokedMethod())) {
+ continue;
+ }
+ // We need to force resolution, even on d8, to know if the invoke has to be rewritten.
+ DexEncodedMethod dexEncodedMethod =
+ quickLookUp(invoke.getInvokedMethod());
+ if (dexEncodedMethod == null) {
+ continue;
+ }
+ provider = getMethodProviderOrNull(dexEncodedMethod.method);
+ if (provider == null) {
+ continue;
+ }
+
+ // Since we are rewriting a virtual method into a static invoke in this case, the look-up
+ // logic gets confused. Final methods rewritten in such a way are always or invokes from a
+ // library class are rewritten into the static invoke, which is correct. However,
+ // overrides of the programmer are currently disabled. We still rewrite everything to make
+ // basic cases work.
+ // TODO(b/142846107): Support overrides of retarget virtual methods by uncommenting the
+ // following and implementing doSomethingSmart().
+
+ // DexClass receiverType = appView.definitionFor(invoke.getInvokedMethod().holder);
+ // if (!(dexEncodedMethod.isFinal()
+ // || (receiverType != null && receiverType.isLibraryClass()))) {
+ // doSomethingSmart();
+ // continue;
+ // }
}
provider.rewriteInvoke(invoke, iterator, code, appView);
@@ -113,6 +140,31 @@
}
}
+ private DexEncodedMethod quickLookUp(DexMethod method) {
+ // Since retargeting cannot be on interface, we do a quick look-up excluding interfaces.
+ // On R8 resolution is immediate, on d8 it may look-up.
+ DexClass current = appView.definitionFor(method.holder);
+ if (current == null) {
+ return null;
+ }
+ DexEncodedMethod dexEncodedMethod = current.lookupVirtualMethod(method);
+ if (dexEncodedMethod != null) {
+ return dexEncodedMethod;
+ }
+ while (current.superType != factory.objectType) {
+ DexType superType = current.superType;
+ current = appView.definitionFor(superType);
+ if (current == null) {
+ return null;
+ }
+ dexEncodedMethod = current.lookupVirtualMethod(method);
+ if (dexEncodedMethod != null) {
+ return dexEncodedMethod;
+ }
+ }
+ return null;
+ }
+
private Collection<DexProgramClass> findSynthesizedFrom(Builder<?> builder, DexType holder) {
for (DexProgramClass synthesizedClass : builder.getSynthesizedClasses()) {
if (holder == synthesizedClass.getType()) {
@@ -126,8 +178,7 @@
return clazz.descriptor.toString().startsWith(UTILITY_CLASS_DESCRIPTOR_PREFIX);
}
- public void synthesizeUtilityClass(
- Builder<?> builder, ExecutorService executorService, InternalOptions options)
+ public void synthesizeUtilityClasses(Builder<?> builder, ExecutorService executorService)
throws ExecutionException {
if (holders.isEmpty()) {
return;
@@ -161,7 +212,7 @@
if (appView.definitionFor(method.holder) != null) {
continue;
}
- Code code = provider.generateTemplateMethod(options, method);
+ Code code = provider.generateTemplateMethod(appView.options(), method);
DexEncodedMethod dexEncodedMethod =
new DexEncodedMethod(
method, flags, DexAnnotationSet.empty(), ParameterAnnotationsList.empty(), code);
@@ -181,7 +232,7 @@
DexAnnotationSet.empty(),
DexEncodedField.EMPTY_ARRAY,
DexEncodedField.EMPTY_ARRAY,
- new DexEncodedMethod[] {dexEncodedMethod},
+ new DexEncodedMethod[]{dexEncodedMethod},
DexEncodedMethod.EMPTY_ARRAY,
factory.getSkipNameValidationForTesting(),
referencingClasses);
@@ -221,6 +272,10 @@
// Map backported method to a provider for creating the actual target method (with code).
private final Map<DexMethod, MethodProvider> rewritable = new IdentityHashMap<>();
+ // Map virtualRewrites hold a methodName->method mapping for virtual methods which are
+ // rewritten while the holder is non final but no superclass implement the method. In this case
+ // d8 needs to force resolution of given methods to see if the invoke needs to be rewritten.
+ private final Map<DexString, List<DexMethod>> virtualRewrites = new IdentityHashMap<>();
RewritableMethods(InternalOptions options, AppView<?> appView) {
DexItemFactory factory = options.itemFactory;
@@ -253,6 +308,19 @@
}
}
+ boolean matchesVirtualRewrite(DexMethod method) {
+ List<DexMethod> dexMethods = virtualRewrites.get(method.name);
+ if (dexMethods == null) {
+ return false;
+ }
+ for (DexMethod dexMethod : dexMethods) {
+ if (method.match(dexMethod)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
boolean isEmpty() {
return rewritable.isEmpty();
}
@@ -1007,7 +1075,8 @@
: new MethodGenerator(
method,
(options, methodArg) ->
- CollectionMethodGenerators.generateListOf(options, methodArg, formalCount)));
+ CollectionMethodGenerators.generateListOf(
+ options, methodArg, formalCount)));
}
proto = factory.createProto(type, factory.objectArrayType);
method = factory.createMethod(type, proto, name);
@@ -1099,25 +1168,25 @@
// Optional{void,Int,Long,Double}.ifPresentOrElse(consumer,runnable)
DexType[] optionalTypes =
- new DexType[] {
- optionalType,
- factory.createType(factory.createString("Ljava/util/OptionalDouble;")),
- factory.createType(factory.createString("Ljava/util/OptionalLong;")),
- factory.createType(factory.createString("Ljava/util/OptionalInt;"))
+ new DexType[]{
+ optionalType,
+ factory.createType(factory.createString("Ljava/util/OptionalDouble;")),
+ factory.createType(factory.createString("Ljava/util/OptionalLong;")),
+ factory.createType(factory.createString("Ljava/util/OptionalInt;"))
};
DexType[] consumerTypes =
- new DexType[] {
- factory.consumerType,
- factory.createType("Ljava/util/function/DoubleConsumer;"),
- factory.createType("Ljava/util/function/LongConsumer;"),
- factory.createType("Ljava/util/function/IntConsumer;")
+ new DexType[]{
+ factory.consumerType,
+ factory.createType("Ljava/util/function/DoubleConsumer;"),
+ factory.createType("Ljava/util/function/LongConsumer;"),
+ factory.createType("Ljava/util/function/IntConsumer;")
};
TemplateMethodFactory[] methodFactories =
- new TemplateMethodFactory[] {
- BackportedMethods::OptionalMethods_ifPresentOrElse,
- BackportedMethods::OptionalMethods_ifPresentOrElseDouble,
- BackportedMethods::OptionalMethods_ifPresentOrElseLong,
- BackportedMethods::OptionalMethods_ifPresentOrElseInt
+ new TemplateMethodFactory[]{
+ BackportedMethods::OptionalMethods_ifPresentOrElse,
+ BackportedMethods::OptionalMethods_ifPresentOrElseDouble,
+ BackportedMethods::OptionalMethods_ifPresentOrElseLong,
+ BackportedMethods::OptionalMethods_ifPresentOrElseInt
};
for (int i = 0; i < optionalTypes.length; i++) {
DexType optional = optionalTypes[i];
@@ -1151,6 +1220,10 @@
DexType newHolder = retargetCoreLibMember.get(methodName).get(inType);
List<DexEncodedMethod> found = findDexEncodedMethodsWithName(methodName, typeClass);
for (DexEncodedMethod encodedMethod : found) {
+ if (!encodedMethod.isStatic()) {
+ virtualRewrites.putIfAbsent(encodedMethod.method.name, new ArrayList<>());
+ virtualRewrites.get(encodedMethod.method.name).add(encodedMethod.method);
+ }
DexProto proto = encodedMethod.method.proto;
DexMethod method = appView.dexItemFactory().createMethod(inType, proto, methodName);
addProvider(
@@ -1185,6 +1258,7 @@
}
public abstract static class MethodProvider {
+
final DexMethod method;
public MethodProvider(DexMethod method) {
@@ -1244,6 +1318,7 @@
}
private static final class InvokeRewriter extends MethodProvider {
+
private final MethodInvokeRewriter rewriter;
InvokeRewriter(DexMethod method, MethodInvokeRewriter rewriter) {
@@ -1251,8 +1326,9 @@
this.rewriter = rewriter;
}
- @Override public void rewriteInvoke(InvokeMethod invoke, InstructionListIterator iterator,
- IRCode code, AppView<?> appView) {
+ @Override
+ public void rewriteInvoke(
+ InvokeMethod invoke, InstructionListIterator iterator, IRCode code, AppView<?> appView) {
rewriter.rewrite(invoke, iterator, appView.dexItemFactory());
assert code.isConsistentSSA();
}
@@ -1365,6 +1441,7 @@
}
private interface MethodInvokeRewriter {
+
void rewrite(InvokeMethod invoke, InstructionListIterator iterator, DexItemFactory factory);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
index d81f3fe..688e751 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.ir.code.Invoke;
@@ -114,7 +115,12 @@
DexClass target = appView.definitionFor(method.holder);
// NOTE: Never add a forwarding method to methods of classes unknown or coming from android.jar
// even if this results in invalid code, these classes are never desugared.
- assert target != null && !rewriter.isNonDesugaredLibraryClass(target);
+ assert target != null;
+ // In desugared library, emulated interface methods can be overridden by retarget lib members.
+ DexMethod forwardMethod =
+ target.isInterface()
+ ? rewriter.defaultAsMethodOfCompanionClass(method)
+ : retargetMethod(method);
// New method will have the same name, proto, and also all the flags of the
// default method, including bridge flag.
DexMethod newMethod = dexItemFactory.createMethod(clazz.type, method.proto, method.name);
@@ -125,7 +131,7 @@
ForwardMethodSourceCode.builder(newMethod);
forwardSourceCodeBuilder
.setReceiver(clazz.type)
- .setTarget(rewriter.defaultAsMethodOfCompanionClass(method))
+ .setTarget(forwardMethod)
.setInvokeType(Invoke.Type.STATIC)
.setIsInterface(false); // Holder is companion class, not an interface.
return new DexEncodedMethod(
@@ -136,6 +142,18 @@
new SynthesizedCode(forwardSourceCodeBuilder::build));
}
+ private DexMethod retargetMethod(DexMethod method) {
+ Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
+ appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
+ Map<DexType, DexType> typeMap = retargetCoreLibMember.get(method.name);
+ assert typeMap != null;
+ assert typeMap.get(method.holder) != null;
+ return dexItemFactory.createMethod(
+ typeMap.get(method.holder),
+ dexItemFactory.prependTypeToProto(method.holder, method.proto),
+ method.name);
+ }
+
// For a given class `clazz` inspects all interfaces it implements directly or
// indirectly and collect a set of all default methods to be implemented
// in this class.
@@ -215,17 +233,29 @@
// Remove from candidates methods defined in class or any of its superclasses.
List<DexEncodedMethod> toBeImplemented = new ArrayList<>(candidates.size());
current = clazz;
+ Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
+ appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
while (true) {
// In desugared library look-up, methods from library classes cannot hide methods from
// emulated interfaces (the method being desugared implied the implementation is not
- // present in the library class).
+ // present in the library class), except through retarget core lib member.
if (desugaredLibraryLookup && current.isLibraryClass()) {
Iterator<DexEncodedMethod> iterator = candidates.iterator();
while (iterator.hasNext()) {
DexEncodedMethod candidate = iterator.next();
- if (rewriter.isEmulatedInterface(candidate.method.holder)) {
- toBeImplemented.add(candidate);
- iterator.remove();
+ if (rewriter.isEmulatedInterface(candidate.method.holder)
+ && current.lookupVirtualMethod(candidate.method) != null) {
+ // A library class overrides an emulated interface method. This override is valid
+ // only if it goes through retarget core lib member, else it needs to be implemented.
+ Map<DexType, DexType> typeMap = retargetCoreLibMember.get(candidate.method.name);
+ if (typeMap != null && typeMap.containsKey(current.type)) {
+ // A rewrite needs to be performed, but instead of rewriting to the companion class,
+ // D8/R8 needs to rewrite to the retarget member.
+ toBeImplemented.add(current.lookupVirtualMethod(candidate.method));
+ } else {
+ toBeImplemented.add(candidate);
+ iterator.remove();
+ }
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
index d60ac1f..cbdef95 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
@@ -28,6 +28,7 @@
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -64,11 +65,20 @@
private final DexItemFactory factory;
private final DesugaredLibraryWrapperSynthesizer wrapperSynthesizor;
private final Map<DexClass, Set<DexEncodedMethod>> callBackMethods = new HashMap<>();
+ private final Set<DexMethod> trackedCallBackAPIs;
+ private final Set<DexMethod> trackedAPIs;
public DesugaredLibraryAPIConverter(AppView<?> appView) {
this.appView = appView;
this.factory = appView.dexItemFactory();
this.wrapperSynthesizor = new DesugaredLibraryWrapperSynthesizer(appView, this);
+ if (appView.options().testing.trackDesugaredAPIConversions) {
+ trackedCallBackAPIs = Sets.newConcurrentHashSet();
+ trackedAPIs = Sets.newConcurrentHashSet();
+ } else {
+ trackedCallBackAPIs = null;
+ trackedAPIs = null;
+ }
}
public void desugar(IRCode code) {
@@ -170,6 +180,9 @@
}
private synchronized void generateCallBack(DexClass dexClass, DexEncodedMethod originalMethod) {
+ if (trackedCallBackAPIs != null) {
+ trackedCallBackAPIs.add(originalMethod.method);
+ }
DexMethod methodToInstall =
methodWithVivifiedTypeInSignature(originalMethod.method, dexClass.type, appView);
if (dexClass.isInterface()
@@ -219,6 +232,10 @@
public void generateWrappers(
DexApplication.Builder<?> builder, IRConverter irConverter, ExecutorService executorService)
throws ExecutionException {
+ if (appView.options().testing.trackDesugaredAPIConversions) {
+ generateTrackDesugaredAPIWarnings(trackedAPIs, "");
+ generateTrackDesugaredAPIWarnings(trackedCallBackAPIs, "callback ");
+ }
wrapperSynthesizor.finalizeWrappers(builder, irConverter, executorService);
for (DexClass dexClass : callBackMethods.keySet()) {
Set<DexEncodedMethod> dexEncodedMethods = callBackMethods.get(dexClass);
@@ -227,6 +244,16 @@
}
}
+ private void generateTrackDesugaredAPIWarnings(Set<DexMethod> tracked, String inner) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("Tracked ").append(inner).append("desugared API conversions: ");
+ for (DexMethod method : tracked) {
+ sb.append("\n");
+ sb.append(method);
+ }
+ appView.options().reporter.warning(new StringDiagnostic(sb.toString()));
+ }
+
private void warnInvalidInvoke(DexType type, DexMethod invokedMethod, String debugString) {
DexType desugaredType = appView.rewritePrefix.rewrittenType(type);
appView
@@ -260,6 +287,9 @@
InstructionListIterator iterator,
ListIterator<BasicBlock> blockIterator) {
DexMethod invokedMethod = invokeMethod.getInvokedMethod();
+ if (trackedAPIs != null) {
+ trackedAPIs.add(invokedMethod);
+ }
// Create return conversion if required.
Instruction returnConversion = null;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/AssumeDynamicTypeRemover.java b/src/main/java/com/android/tools/r8/ir/optimize/AssumeDynamicTypeRemover.java
index 257d002..73214ba 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/AssumeDynamicTypeRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssumeDynamicTypeRemover.java
@@ -53,7 +53,7 @@
}
public void markUsersForRemoval(Value value) {
- for (Instruction user : value.uniqueUsers()) {
+ for (Instruction user : value.aliasedUsers()) {
if (user.isAssumeDynamicType()) {
assert value.numberOfAllUsers() == 1
: "Expected value flowing into Assume<DynamicTypeAssumption> instruction to have a "
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index 31add54..f93d6c5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -47,11 +47,8 @@
private enum Mode {
COLLECT, // Set until the end of the 1st round of IR processing. CallSiteOptimizationInfo will
// be updated in this mode only.
- REVISIT, // Set once the all methods are processed. IRBuilder will add other instructions that
+ REVISIT // Set once the all methods are processed. IRBuilder will add other instructions that
// reflect collected CallSiteOptimizationInfo.
- FINISH; // Set once the 2nd round of IR processing is done. Other optimizations that need post
- // IR processing, e.g., outliner, are still using IRBuilder, and this will isolate the
- // impact of IR manipulation due to this optimization.
}
private final AppView<AppInfoWithLiveness> appView;
@@ -256,14 +253,13 @@
}
}
}
+ mode = Mode.REVISIT;
if (targetsToRevisit.isEmpty()) {
- mode = Mode.FINISH;
return;
}
if (revisitedMethods != null) {
revisitedMethods.addAll(targetsToRevisit);
}
- mode = Mode.REVISIT;
List<Future<?>> futures = new ArrayList<>();
for (DexEncodedMethod method : targetsToRevisit) {
futures.add(
@@ -274,6 +270,5 @@
}));
}
ThreadUtils.awaitFutures(futures);
- mode = Mode.FINISH;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
index 6c2110b..fb75832 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
@@ -29,6 +29,7 @@
import com.android.tools.r8.graph.DexValue.DexValueNull;
import com.android.tools.r8.graph.DexValue.DexValueShort;
import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.ir.analysis.ValueMayDependOnEnvironmentAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.code.ArrayPut;
import com.android.tools.r8.ir.code.BasicBlock;
@@ -327,6 +328,8 @@
private Collection<StaticPut> findFinalFieldPutsWhileCollectingUnnecessaryStaticPuts(
IRCode code, DexClass clazz, Set<StaticPut> unnecessaryStaticPuts) {
+ ValueMayDependOnEnvironmentAnalysis environmentAnalysis =
+ new ValueMayDependOnEnvironmentAnalysis(appView, code);
Map<DexField, StaticPut> finalFieldPuts = Maps.newIdentityHashMap();
Map<DexField, Set<StaticPut>> isWrittenBefore = Maps.newIdentityHashMap();
Set<DexField> isReadBefore = Sets.newIdentityHashSet();
@@ -436,7 +439,7 @@
Value outValue = instruction.outValue();
if (outValue.numberOfAllUsers() > 0) {
if (instruction.isInvokeNewArray()
- && outValue.isConstantArrayThroughoutMethod(appView, code)) {
+ && environmentAnalysis.isConstantArrayThroughoutMethod(outValue)) {
// OK, this value is technically a constant.
continue;
}
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 932c817..a47ba2c 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
@@ -14,6 +14,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
@@ -82,12 +83,14 @@
import com.android.tools.r8.utils.InternalOptions.AssertionProcessing;
import com.android.tools.r8.utils.InternalOutputMode;
import com.android.tools.r8.utils.LongInterval;
+import com.android.tools.r8.utils.SetUtils;
import com.google.common.base.Equivalence;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Sets;
@@ -839,9 +842,9 @@
return outliersAsIfSize;
}
- public void rewriteSwitch(IRCode code) {
+ private boolean rewriteSwitch(IRCode code) {
if (!code.metadata().mayHaveIntSwitch()) {
- return;
+ return false;
}
boolean needToRemoveUnreachableBlocks = false;
@@ -985,15 +988,18 @@
}
}
- if (needToRemoveUnreachableBlocks) {
- code.removeUnreachableBlocks();
- }
-
// Rewriting of switches introduces new branching structure. It relies on critical edges
// being split on the way in but does not maintain this property. We therefore split
// critical edges at exit.
code.splitCriticalEdges();
+
+ Set<Value> affectedValues =
+ needToRemoveUnreachableBlocks ? code.removeUnreachableBlocks() : ImmutableSet.of();
+ if (!affectedValues.isEmpty()) {
+ new TypeAnalysis(appView).narrowing(affectedValues);
+ }
assert code.isConsistentSSA();
+ return !affectedValues.isEmpty();
}
private SwitchCaseEliminator removeUnnecessarySwitchCases(
@@ -1247,10 +1253,10 @@
assumeDynamicTypeRemover.finish();
if (!blocksToBeRemoved.isEmpty()) {
code.removeBlocks(blocksToBeRemoved);
- code.removeAllTrivialPhis();
+ code.removeAllTrivialPhis(affectedValues);
assert code.getUnreachableBlocks().isEmpty();
} else if (mayHaveRemovedTrivialPhi || assumeDynamicTypeRemover.mayHaveIntroducedTrivialPhi()) {
- code.removeAllTrivialPhis();
+ code.removeAllTrivialPhis(affectedValues);
}
if (!affectedValues.isEmpty()) {
new TypeAnalysis(appView).narrowing(affectedValues);
@@ -1407,7 +1413,10 @@
// Removing check-cast may result in a trivial phi:
// v3 <- phi(v1, v1)
if (needToRemoveTrivialPhis) {
- code.removeAllTrivialPhis();
+ code.removeAllTrivialPhis(affectedValues);
+ if (!affectedValues.isEmpty()) {
+ typeAnalysis.narrowing(affectedValues);
+ }
}
assert code.isConsistentSSA();
}
@@ -1524,7 +1533,11 @@
value -> !value.isPhi() && value.definition.isAssumeDynamicType());
if (aliasedValue != null) {
TypeLatticeElement dynamicType =
- aliasedValue.definition.asAssumeDynamicType().getAssumption().getType();
+ aliasedValue
+ .definition
+ .asAssumeDynamicType()
+ .getAssumption()
+ .getDynamicUpperBoundType();
if (dynamicType.isDefinitelyNull()) {
result = InstanceOfResult.FALSE;
} else if (dynamicType.lessThanOrEqual(instanceOfType, appView)
@@ -2378,7 +2391,13 @@
assert code.isConsistentSSA();
}
- public void simplifyIf(IRCode code) {
+ public boolean simplifyControlFlow(IRCode code) {
+ boolean anyAffectedValues = rewriteSwitch(code);
+ anyAffectedValues |= simplifyIf(code);
+ return anyAffectedValues;
+ }
+
+ private boolean simplifyIf(IRCode code) {
for (BasicBlock block : code.blocks) {
// Skip removed (= unreachable) blocks.
if (block.getNumber() != 0 && block.getPredecessors().isEmpty()) {
@@ -2394,27 +2413,26 @@
// Simplify if conditions when possible.
If theIf = block.exit().asIf();
- List<Value> inValues = theIf.inValues();
+ Value lhs = theIf.lhs();
+ Value rhs = theIf.isZeroTest() ? null : theIf.rhs();
- if (inValues.get(0).isConstNumber()
- && (theIf.isZeroTest() || inValues.get(1).isConstNumber())) {
+ if (lhs.isConstNumber() && (theIf.isZeroTest() || rhs.isConstNumber())) {
// Zero test with a constant of comparison between between two constants.
if (theIf.isZeroTest()) {
- ConstNumber cond = inValues.get(0).getConstInstruction().asConstNumber();
+ ConstNumber cond = lhs.getConstInstruction().asConstNumber();
BasicBlock target = theIf.targetFromCondition(cond);
simplifyIfWithKnownCondition(code, block, theIf, target);
} else {
- ConstNumber left = inValues.get(0).getConstInstruction().asConstNumber();
- ConstNumber right = inValues.get(1).getConstInstruction().asConstNumber();
+ ConstNumber left = lhs.getConstInstruction().asConstNumber();
+ ConstNumber right = rhs.getConstInstruction().asConstNumber();
BasicBlock target = theIf.targetFromCondition(left, right);
simplifyIfWithKnownCondition(code, block, theIf, target);
}
- } else if (inValues.get(0).hasValueRange()
- && (theIf.isZeroTest() || inValues.get(1).hasValueRange())) {
+ } else if (lhs.hasValueRange() && (theIf.isZeroTest() || rhs.hasValueRange())) {
// Zero test with a value range, or comparison between between two values,
// each with a value ranges.
if (theIf.isZeroTest()) {
- LongInterval interval = inValues.get(0).getValueRange();
+ LongInterval interval = lhs.getValueRange();
if (!interval.containsValue(0)) {
// Interval doesn't contain zero at all.
int sign = Long.signum(interval.getMin());
@@ -2448,8 +2466,8 @@
}
}
} else {
- LongInterval leftRange = inValues.get(0).getValueRange();
- LongInterval rightRange = inValues.get(1).getValueRange();
+ LongInterval leftRange = lhs.getValueRange();
+ LongInterval rightRange = rhs.getValueRange();
// Two overlapping ranges. Check for single point overlap.
if (!leftRange.overlapsWith(rightRange)) {
// No overlap.
@@ -2483,14 +2501,27 @@
}
}
}
- } else if (theIf.isZeroTest() && !inValues.get(0).isConstNumber()
- && (theIf.getType() == Type.EQ || theIf.getType() == Type.NE)) {
- TypeLatticeElement l = inValues.get(0).getTypeLattice();
- if (l.isReference() && inValues.get(0).isNeverNull()) {
- simplifyIfWithKnownCondition(code, block, theIf, 1);
+ } else if (theIf.getType() == Type.EQ || theIf.getType() == Type.NE) {
+ if (theIf.isZeroTest()) {
+ if (!lhs.isConstNumber()) {
+ TypeLatticeElement l = lhs.getTypeLattice();
+ if (l.isReference() && lhs.isNeverNull()) {
+ simplifyIfWithKnownCondition(code, block, theIf, 1);
+ } else {
+ if (!l.isPrimitive() && !l.isNullable()) {
+ simplifyIfWithKnownCondition(code, block, theIf, 1);
+ }
+ }
+ }
} else {
- if (!l.isPrimitive() && !l.isNullable()) {
- simplifyIfWithKnownCondition(code, block, theIf, 1);
+ DexEncodedField enumField = lhs.getEnumField(appView);
+ if (enumField != null) {
+ DexEncodedField otherEnumField = rhs.getEnumField(appView);
+ if (enumField == otherEnumField) {
+ simplifyIfWithKnownCondition(code, block, theIf, 0);
+ } else if (otherEnumField != null) {
+ simplifyIfWithKnownCondition(code, block, theIf, 1);
+ }
}
}
}
@@ -2501,6 +2532,7 @@
new TypeAnalysis(appView).narrowing(affectedValues);
}
assert code.isConsistentSSA();
+ return !affectedValues.isEmpty();
}
private void simplifyIfWithKnownCondition(
@@ -3500,8 +3532,8 @@
}
private static NewInstance findNewInstance(Phi phi) {
- Set<Phi> seen = new HashSet<>();
- Set<Value> values = new HashSet<>();
+ Set<Phi> seen = Sets.newIdentityHashSet();
+ Set<Value> values = Sets.newIdentityHashSet();
recursiveAddOperands(phi, seen, values);
if (values.size() != 1) {
throw new CompilationError("Failed to identify unique new-instance for <init>");
@@ -3539,7 +3571,7 @@
if (component.size() == 1 && component.iterator().next() == newInstanceValue) {
continue;
}
- Set<Phi> trivialPhis = new HashSet<>();
+ Set<Phi> trivialPhis = Sets.newIdentityHashSet();
for (Value value : component) {
boolean isTrivial = true;
Phi p = value.asPhi();
@@ -3569,7 +3601,7 @@
private int currentTime = 0;
private final Reference2IntMap<Value> discoverTime = new Reference2IntOpenHashMap<>();
- private final Set<Value> unassignedSet = new HashSet<>();
+ private final Set<Value> unassignedSet = Sets.newIdentityHashSet();
private final Deque<Value> unassignedStack = new ArrayDeque<>();
private final Deque<Value> preorderStack = new ArrayDeque<>();
private final List<Set<Value>> components = new ArrayList<>();
@@ -3603,7 +3635,7 @@
// If the current element is the top of the preorder stack, then we are at entry to a
// strongly-connected component consisting of this element and every element above this
// element on the stack.
- Set<Value> component = new HashSet<>(unassignedStack.size());
+ Set<Value> component = SetUtils.newIdentityHashSet(unassignedStack.size());
while (true) {
Value member = unassignedStack.pop();
unassignedSet.remove(member);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index e0d77fb..2649e62 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -428,9 +428,28 @@
}
@Override
- public boolean canInlineInstanceInitializer(
- IRCode inlinee,
+ public boolean allowInliningOfInvokeInInlinee(
+ InlineAction action,
+ int inliningDepth,
WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
+ assert inliningDepth > 0;
+
+ if (action.reason.mustBeInlined()) {
+ return true;
+ }
+
+ int threshold = appView.options().applyInliningToInlineeMaxDepth;
+ if (inliningDepth <= threshold) {
+ return true;
+ }
+
+ whyAreYouNotInliningReporter.reportWillExceedMaxInliningDepth(inliningDepth, threshold);
+ return false;
+ }
+
+ @Override
+ public boolean canInlineInstanceInitializer(
+ IRCode inlinee, WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
// In the Java VM Specification section "4.10.2.4. Instance Initialization Methods and
// Newly Created Objects" it says:
//
@@ -685,13 +704,12 @@
@Override
public void updateTypeInformationIfNeeded(
IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block) {
- if (appView.options().enableNonNullTracking) {
+ boolean assumersEnabled =
+ appView.options().enableNonNullTracking
+ || appView.options().enableDynamicTypeOptimization
+ || appView.options().testing.forceAssumeNoneInsertion;
+ if (assumersEnabled) {
BasicBlock state = IteratorUtils.peekNext(blockIterator);
- // Move the cursor back to where the first inlinee block was added.
- while (blockIterator.hasPrevious() && blockIterator.previous() != block) {
- // Do nothing.
- }
- assert IteratorUtils.peekNext(blockIterator) == block;
Set<BasicBlock> inlineeBlocks = Sets.newIdentityHashSet();
inlineeBlocks.addAll(inlinee.blocks);
@@ -699,18 +717,28 @@
// Introduce aliases only to the inlinee blocks.
if (appView.options().testing.forceAssumeNoneInsertion) {
insertAssumeInstructionsToInlinee(
- new AliasIntroducer(appView), code, state, blockIterator, inlineeBlocks);
+ new AliasIntroducer(appView), code, block, blockIterator, inlineeBlocks);
}
// Add non-null IRs only to the inlinee blocks.
- Consumer<BasicBlock> splitBlockConsumer = inlineeBlocks::add;
- Assumer nonNullTracker = new NonNullTracker(appView, splitBlockConsumer);
- insertAssumeInstructionsToInlinee(
- nonNullTracker, code, state, blockIterator, inlineeBlocks);
+ if (appView.options().enableNonNullTracking) {
+ Consumer<BasicBlock> splitBlockConsumer = inlineeBlocks::add;
+ Assumer nonNullTracker = new NonNullTracker(appView, splitBlockConsumer);
+ insertAssumeInstructionsToInlinee(
+ nonNullTracker, code, block, blockIterator, inlineeBlocks);
+ }
// Add dynamic type assumptions only to the inlinee blocks.
- insertAssumeInstructionsToInlinee(
- new DynamicTypeOptimization(appView), code, state, blockIterator, inlineeBlocks);
+ if (appView.options().enableDynamicTypeOptimization) {
+ insertAssumeInstructionsToInlinee(
+ new DynamicTypeOptimization(appView), code, block, blockIterator, inlineeBlocks);
+ }
+
+ // Restore the old state of the iterator.
+ while (blockIterator.hasPrevious() && blockIterator.previous() != state) {
+ // Do nothing.
+ }
+ assert IteratorUtils.peekNext(blockIterator) == state;
}
// TODO(b/72693244): need a test where refined env in inlinee affects the caller.
}
@@ -718,17 +746,17 @@
private void insertAssumeInstructionsToInlinee(
Assumer assumer,
IRCode code,
- BasicBlock state,
+ BasicBlock block,
ListIterator<BasicBlock> blockIterator,
Set<BasicBlock> inlineeBlocks) {
- assumer.insertAssumeInstructionsInBlocks(code, blockIterator, inlineeBlocks::contains);
- assert !blockIterator.hasNext();
-
- // Restore the old state of the iterator.
- while (blockIterator.hasPrevious() && blockIterator.previous() != state) {
+ // Move the cursor back to where the first inlinee block was added.
+ while (blockIterator.hasPrevious() && blockIterator.previous() != block) {
// Do nothing.
}
- assert IteratorUtils.peekNext(blockIterator) == state;
+ assert IteratorUtils.peekNext(blockIterator) == block;
+
+ assumer.insertAssumeInstructionsInBlocks(code, blockIterator, inlineeBlocks::contains);
+ assert !blockIterator.hasNext();
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
index 26f383b..e5c53b3 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DynamicTypeOptimization.java
@@ -58,7 +58,7 @@
continue;
}
- TypeLatticeElement dynamicType;
+ TypeLatticeElement dynamicUpperBoundType;
ClassTypeLatticeElement dynamicLowerBoundType;
if (current.isInvokeMethod()) {
InvokeMethod invoke = current.asInvokeMethod();
@@ -80,7 +80,7 @@
continue;
}
- dynamicType = optimizationInfo.getDynamicReturnType();
+ dynamicUpperBoundType = optimizationInfo.getDynamicReturnType();
dynamicLowerBoundType = optimizationInfo.getDynamicLowerBoundType();
} else if (current.isStaticGet()) {
StaticGet staticGet = current.asStaticGet();
@@ -89,23 +89,23 @@
continue;
}
- dynamicType = encodedField.getOptimizationInfo().getDynamicType();
- // TODO(b/140234782): Extend to field values.
- dynamicLowerBoundType = null;
+ dynamicUpperBoundType = encodedField.getOptimizationInfo().getDynamicUpperBoundType();
+ dynamicLowerBoundType = encodedField.getOptimizationInfo().getDynamicLowerBoundType();
} else {
continue;
}
Value outValue = current.outValue();
boolean isTrivial =
- (dynamicType == null || !dynamicType.strictlyLessThan(outValue.getTypeLattice(), appView))
+ (dynamicUpperBoundType == null
+ || !dynamicUpperBoundType.strictlyLessThan(outValue.getTypeLattice(), appView))
&& dynamicLowerBoundType == null;
if (isTrivial) {
continue;
}
- if (dynamicType == null) {
- dynamicType = outValue.getTypeLattice();
+ if (dynamicUpperBoundType == null) {
+ dynamicUpperBoundType = outValue.getTypeLattice();
}
// Split block if needed (only debug instructions are allowed after the throwing
@@ -121,7 +121,12 @@
// Insert AssumeDynamicType instruction.
Assume<DynamicTypeAssumption> assumeInstruction =
Assume.createAssumeDynamicTypeInstruction(
- dynamicType, dynamicLowerBoundType, specializedOutValue, outValue, current, appView);
+ dynamicUpperBoundType,
+ dynamicLowerBoundType,
+ specializedOutValue,
+ outValue,
+ current,
+ appView);
assumeInstruction.setPosition(
appView.options().debug ? current.getPosition() : Position.none());
if (insertionBlock == block) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
index fb1ef58..f52658f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
@@ -84,6 +84,15 @@
IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block) {}
@Override
+ public boolean allowInliningOfInvokeInInlinee(
+ InlineAction action,
+ int inliningDepth,
+ WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
+ // The purpose of force inlining is generally to inline a given invoke-instruction in the IR.
+ return false;
+ }
+
+ @Override
public boolean canInlineInstanceInitializer(
IRCode code, WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index fef9538..40d01c0 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -46,16 +46,20 @@
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
+import com.android.tools.r8.ir.optimize.lambda.LambdaMerger;
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.MainDexClasses;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.ThreadUtils;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
+import java.util.ArrayDeque;
import java.util.ArrayList;
+import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
@@ -70,6 +74,7 @@
protected final AppView<AppInfoWithLiveness> appView;
private final Set<DexMethod> blacklist;
+ private final LambdaMerger lambdaMerger;
private final LensCodeRewriter lensCodeRewriter;
final MainDexClasses mainDexClasses;
@@ -82,10 +87,12 @@
public Inliner(
AppView<AppInfoWithLiveness> appView,
MainDexClasses mainDexClasses,
+ LambdaMerger lambdaMerger,
LensCodeRewriter lensCodeRewriter) {
Kotlin.Intrinsics intrinsics = appView.dexItemFactory().kotlin.intrinsics;
this.appView = appView;
this.blacklist = ImmutableSet.of(intrinsics.throwNpe, intrinsics.throwParameterIsNullException);
+ this.lambdaMerger = lambdaMerger;
this.lensCodeRewriter = lensCodeRewriter;
this.mainDexClasses = mainDexClasses;
}
@@ -585,6 +592,7 @@
ValueNumberGenerator generator,
AppView<? extends AppInfoWithSubtyping> appView,
Position callerPosition,
+ LambdaMerger lambdaMerger,
LensCodeRewriter lensCodeRewriter) {
DexItemFactory dexItemFactory = appView.dexItemFactory();
InternalOptions options = appView.options();
@@ -752,6 +760,9 @@
if (!target.isProcessed()) {
lensCodeRewriter.rewrite(code, target);
}
+ if (lambdaMerger != null) {
+ lambdaMerger.rewriteCodeForInlining(target, code, context);
+ }
assert code.isConsistentSSA();
return new InlineeWithReason(code, reason);
}
@@ -870,8 +881,13 @@
ListIterator<BasicBlock> blockIterator = code.listIterator();
ClassInitializationAnalysis classInitializationAnalysis =
new ClassInitializationAnalysis(appView, code);
+ Deque<BasicBlock> inlineeStack = new ArrayDeque<>();
+ InternalOptions options = appView.options();
while (blockIterator.hasNext()) {
BasicBlock block = blockIterator.next();
+ if (!inlineeStack.isEmpty() && inlineeStack.peekFirst() == block) {
+ inlineeStack.pop();
+ }
if (blocksToRemove.contains(block)) {
continue;
}
@@ -895,12 +911,19 @@
oracle.computeInlining(
invoke, singleTarget, classInitializationAnalysis, whyAreYouNotInliningReporter);
if (action == null) {
- assert whyAreYouNotInliningReporter.verifyReasonHasBeenReported();
+ assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
+ continue;
+ }
+
+ if (!inlineeStack.isEmpty()
+ && !strategy.allowInliningOfInvokeInInlinee(
+ action, inlineeStack.size(), whyAreYouNotInliningReporter)) {
+ assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
continue;
}
if (!strategy.stillHasBudget(action, whyAreYouNotInliningReporter)) {
- assert whyAreYouNotInliningReporter.verifyReasonHasBeenReported();
+ assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
continue;
}
@@ -910,10 +933,11 @@
code.valueNumberGenerator,
appView,
getPositionForInlining(invoke, context),
+ lambdaMerger,
lensCodeRewriter);
if (strategy.willExceedBudget(
code, invoke, inlinee, block, whyAreYouNotInliningReporter)) {
- assert whyAreYouNotInliningReporter.verifyReasonHasBeenReported();
+ assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
continue;
}
@@ -926,7 +950,7 @@
if (singleTarget.isInstanceInitializer()
&& !strategy.canInlineInstanceInitializer(
inlinee.code, whyAreYouNotInliningReporter)) {
- assert whyAreYouNotInliningReporter.verifyReasonHasBeenReported();
+ assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
continue;
}
@@ -936,6 +960,8 @@
assumeDynamicTypeRemover.markUsersForRemoval(outValue);
}
+ boolean inlineeMayHaveInvokeMethod = inlinee.code.metadata().mayHaveInvokeMethod();
+
// Inline the inlinee code in place of the invoke instruction
// Back up before the invoke instruction.
iterator.previous();
@@ -962,11 +988,26 @@
}
context.copyMetadata(singleTarget);
+
+ if (inlineeMayHaveInvokeMethod && options.applyInliningToInlinee) {
+ if (inlineeStack.size() + 1 > options.applyInliningToInlineeMaxDepth
+ && appView.appInfo().alwaysInline.isEmpty()
+ && appView.appInfo().forceInline.isEmpty()) {
+ continue;
+ }
+ // Record that we will be inside the inlinee until the next block.
+ BasicBlock inlineeEnd = IteratorUtils.peekNext(blockIterator);
+ inlineeStack.push(inlineeEnd);
+ // Move the cursor back to where the first inlinee block was added.
+ IteratorUtils.previousUntil(blockIterator, previous -> previous == block);
+ blockIterator.next();
+ }
} else if (current.isAssumeDynamicType()) {
assumeDynamicTypeRemover.removeIfMarked(current.asAssumeDynamicType(), iterator);
}
}
}
+ assert inlineeStack.isEmpty();
assumeDynamicTypeRemover.removeMarkedInstructions(blocksToRemove);
assumeDynamicTypeRemover.finish();
classInitializationAnalysis.finish();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
index 5f9bb2a..e0b0a2c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
@@ -17,6 +17,11 @@
interface InliningStrategy {
+ boolean allowInliningOfInvokeInInlinee(
+ InlineAction action,
+ int inliningDepth,
+ WhyAreYouNotInliningReporter whyAreYouNotInliningReporter);
+
boolean canInlineInstanceInitializer(
IRCode code, WhyAreYouNotInliningReporter whyAreYouNotInliningReporter);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
index 62d5bd8..cea6258 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
@@ -3,6 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize;
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
+import static com.android.tools.r8.ir.analysis.type.TypeLatticeElement.stringClassType;
+
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexDefinition;
@@ -193,7 +196,8 @@
appView.dexItemFactory().stringType,
typeLattice.asClassTypeLatticeElement().getClassType())
.isTrue();
- Value returnedValue = code.createValue(typeLattice, debugLocalInfo);
+ Value returnedValue =
+ code.createValue(stringClassType(appView, definitelyNotNull()), debugLocalInfo);
ConstString instruction =
new ConstString(
returnedValue, constant, ThrowingInfo.defaultForConstString(appView.options()));
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
index cea57a8..9752859 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
@@ -134,8 +134,8 @@
DexEncodedField encodedField = appView.appInfo().resolveField(field);
if (encodedField != null) {
FieldOptimizationInfo optimizationInfo = encodedField.getOptimizationInfo();
- if (optimizationInfo.getDynamicType() != null
- && optimizationInfo.getDynamicType().isDefinitelyNotNull()) {
+ if (optimizationInfo.getDynamicUpperBoundType() != null
+ && optimizationInfo.getDynamicUpperBoundType().isDefinitelyNotNull()) {
knownToBeNonNullValues.add(outValue);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
index fdfa3ee..5088d99 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
@@ -373,7 +373,7 @@
public void rewrite(IRCode code) {
Set<BasicBlock> blocksToBeRemoved = Sets.newIdentityHashSet();
ListIterator<BasicBlock> blockIterator = code.listIterator();
- Set<Value> valuesToNarrow = new HashSet<>();
+ Set<Value> valuesToNarrow = Sets.newIdentityHashSet();
while (blockIterator.hasNext()) {
BasicBlock block = blockIterator.next();
if (blocksToBeRemoved.contains(block)) {
@@ -422,12 +422,12 @@
}
}
}
+ code.removeBlocks(blocksToBeRemoved);
+ code.removeAllTrivialPhis(valuesToNarrow);
+ code.removeUnreachableBlocks();
if (!valuesToNarrow.isEmpty()) {
new TypeAnalysis(appView).narrowing(valuesToNarrow);
}
- code.removeBlocks(blocksToBeRemoved);
- code.removeAllTrivialPhis();
- code.removeUnreachableBlocks();
assert code.isConsistentSSA();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
index 95f29b9..a938ff2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
@@ -226,6 +226,13 @@
List<DexEncodedMethod> directMethods = clazz.directMethods();
for (int i = 0; i < directMethods.size(); i++) {
DexEncodedMethod method = directMethods.get(i);
+
+ // If this is a private or static method that is targeted by an invoke-super instruction, then
+ // don't remove any unused arguments.
+ if (appView.appInfo().brokenSuperInvokes.contains(method.method)) {
+ continue;
+ }
+
RemovedArgumentsInfo unused = collectUnusedArguments(method);
if (unused != null && unused.hasRemovedArguments()) {
DexProto newProto = createProtoWithRemovedArguments(method, unused);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index f550309..d576a22 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -246,7 +246,7 @@
// particularly important for bridge methods.
codeRewriter.removeTrivialCheckCastAndInstanceOfInstructions(code);
// If a method was inlined we may be able to prune additional branches.
- codeRewriter.simplifyIf(code);
+ codeRewriter.simplifyControlFlow(code);
// If a method was inlined we may see more trivial computation/conversion of String.
boolean isDebugMode =
appView.options().debug || method.getOptimizationInfo().isReachabilitySensitive();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
index 30721f5..e82afb7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultFieldOptimizationInfo.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.info;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
public class DefaultFieldOptimizationInfo extends FieldOptimizationInfo {
@@ -32,7 +33,12 @@
}
@Override
- public TypeLatticeElement getDynamicType() {
+ public ClassTypeLatticeElement getDynamicLowerBoundType() {
+ return null;
+ }
+
+ @Override
+ public TypeLatticeElement getDynamicUpperBoundType() {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
index 58432ba..cc89f84 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/FieldOptimizationInfo.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.info;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
public abstract class FieldOptimizationInfo {
@@ -18,7 +19,9 @@
*/
public abstract int getReadBits();
- public abstract TypeLatticeElement getDynamicType();
+ public abstract ClassTypeLatticeElement getDynamicLowerBoundType();
+
+ public abstract TypeLatticeElement getDynamicUpperBoundType();
public abstract boolean valueHasBeenPropagated();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index 78369e3..8cbc644 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -46,6 +46,7 @@
import com.android.tools.r8.kotlin.Kotlin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.Sets;
@@ -60,17 +61,16 @@
import java.util.function.Function;
public class MethodOptimizationInfoCollector {
- private final AppView<?> appView;
+ private final AppView<AppInfoWithLiveness> appView;
private final InternalOptions options;
private final DexItemFactory dexItemFactory;
- public MethodOptimizationInfoCollector(AppView<?> appView) {
+ public MethodOptimizationInfoCollector(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
this.options = appView.options();
this.dexItemFactory = appView.dexItemFactory();
}
- // TODO(b/141656615): Use this and then make all utils in this collector `private`.
public void collectMethodOptimizationInfo(
DexEncodedMethod method,
IRCode code,
@@ -91,7 +91,7 @@
computeNonNullParamOnNormalExits(feedback, code);
}
- public void identifyClassInlinerEligibility(
+ private void identifyClassInlinerEligibility(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
// Method eligibility is calculated in similar way for regular method
// and for the constructor. To be eligible method should only be using its
@@ -126,7 +126,11 @@
boolean receiverUsedAsReturnValue = false;
boolean seenSuperInitCall = false;
- for (Instruction insn : receiver.uniqueUsers()) {
+ for (Instruction insn : receiver.aliasedUsers()) {
+ if (insn.isAssume()) {
+ continue;
+ }
+
if (insn.isMonitor()) {
continue;
}
@@ -140,11 +144,11 @@
if (insn.isInstancePut()) {
InstancePut instancePutInstruction = insn.asInstancePut();
// Only allow field writes to the receiver.
- if (instancePutInstruction.object() != receiver) {
+ if (instancePutInstruction.object().getAliasedValue() != receiver) {
return;
}
// Do not allow the receiver to escape via a field write.
- if (instancePutInstruction.value() == receiver) {
+ if (instancePutInstruction.value().getAliasedValue() == receiver) {
return;
}
}
@@ -162,7 +166,8 @@
DexMethod invokedMethod = invokedDirect.getInvokedMethod();
if (dexItemFactory.isConstructor(invokedMethod)
&& invokedMethod.holder == clazz.superType
- && invokedDirect.inValues().lastIndexOf(receiver) == 0
+ && ListUtils.lastIndexMatching(
+ invokedDirect.inValues(), v -> v.getAliasedValue() == receiver) == 0
&& !seenSuperInitCall
&& instanceInitializer) {
seenSuperInitCall = true;
@@ -184,7 +189,7 @@
method, new ClassInlinerEligibility(receiverUsedAsReturnValue));
}
- public void identifyParameterUsages(
+ private void identifyParameterUsages(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
List<ParameterUsage> usages = new ArrayList<>();
List<Value> values = code.collectArguments();
@@ -203,7 +208,7 @@
private ParameterUsage collectParameterUsages(int i, Value value) {
ParameterUsageBuilder builder = new ParameterUsageBuilder(value, i);
- for (Instruction user : value.uniqueUsers()) {
+ for (Instruction user : value.aliasedUsers()) {
if (!builder.note(user)) {
return null;
}
@@ -211,7 +216,7 @@
return builder.build();
}
- public void identifyReturnsArgument(
+ private void identifyReturnsArgument(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
List<BasicBlock> normalExits = code.computeNormalExitBlocks();
if (normalExits.isEmpty()) {
@@ -233,18 +238,19 @@
isNeverNull &= value.getTypeLattice().isReference() && value.isNeverNull();
}
if (returnValue != null) {
- if (returnValue.isArgument()) {
+ Value aliasedValue = returnValue.getAliasedValue();
+ if (aliasedValue.isArgument()) {
// Find the argument number.
- int index = code.collectArguments().indexOf(returnValue);
- assert index != -1;
+ int index = aliasedValue.computeArgumentPosition(code);
+ assert index >= 0;
feedback.methodReturnsArgument(method, index);
}
- if (returnValue.isConstant()) {
- if (returnValue.definition.isConstNumber()) {
- long value = returnValue.definition.asConstNumber().getRawValue();
+ if (aliasedValue.isConstant()) {
+ if (aliasedValue.definition.isConstNumber()) {
+ long value = aliasedValue.definition.asConstNumber().getRawValue();
feedback.methodReturnsConstantNumber(method, value);
- } else if (returnValue.definition.isConstString()) {
- ConstString constStringInstruction = returnValue.definition.asConstString();
+ } else if (aliasedValue.definition.isConstString()) {
+ ConstString constStringInstruction = aliasedValue.definition.asConstString();
if (!constStringInstruction.instructionInstanceCanThrow()) {
feedback.methodReturnsConstantString(method, constStringInstruction.getValue());
}
@@ -256,9 +262,11 @@
}
}
- public void identifyTrivialInitializer(
+ private void identifyTrivialInitializer(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
- if (!method.isInstanceInitializer() && !method.isClassInitializer()) {
+ assert !appView.appInfo().isPinned(method.method);
+
+ if (!method.isInitializer()) {
return;
}
@@ -266,8 +274,13 @@
return;
}
+ if (appView.appInfo().mayHaveSideEffects.containsKey(method.method)) {
+ return;
+ }
+
DexClass clazz = appView.appInfo().definitionFor(method.method.holder);
if (clazz == null) {
+ assert false;
return;
}
@@ -303,6 +316,10 @@
continue;
}
+ if (insn.isAssume()) {
+ continue;
+ }
+
if (insn.isNewInstance()) {
NewInstance newInstance = insn.asNewInstance();
if (createdSingletonInstance != null
@@ -374,6 +391,10 @@
continue;
}
+ if (insn.isAssume()) {
+ continue;
+ }
+
if (insn.isArgument()) {
continue;
}
@@ -440,7 +461,7 @@
return TrivialInstanceInitializer.INSTANCE;
}
- public void identifyInvokeSemanticsForInlining(
+ private void identifyInvokeSemanticsForInlining(
DexEncodedMethod method, IRCode code, AppView<?> appView, OptimizationFeedback feedback) {
if (method.isStatic()) {
// Identifies if the method preserves class initialization after inlining.
@@ -692,7 +713,7 @@
return true;
}
- public void computeDynamicReturnType(
+ private void computeDynamicReturnType(
DynamicTypeOptimization dynamicTypeOptimization,
OptimizationFeedback feedback,
DexEncodedMethod method,
@@ -721,7 +742,7 @@
}
}
- public void computeInitializedClassesOnNormalExit(
+ private void computeInitializedClassesOnNormalExit(
OptimizationFeedback feedback, DexEncodedMethod method, IRCode code) {
if (options.enableInitializedClassesAnalysis && appView.appInfo().hasLiveness()) {
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
@@ -734,7 +755,7 @@
}
}
- public void computeMayHaveSideEffects(
+ private void computeMayHaveSideEffects(
OptimizationFeedback feedback, DexEncodedMethod method, IRCode code) {
// If the method is native, we don't know what could happen.
assert !method.accessFlags.isNative();
@@ -802,7 +823,7 @@
return false;
}
- public void computeReturnValueOnlyDependsOnArguments(
+ private void computeReturnValueOnlyDependsOnArguments(
OptimizationFeedback feedback, DexEncodedMethod method, IRCode code) {
if (!options.enableDeterminismAnalysis) {
return;
@@ -815,7 +836,7 @@
}
// Track usage of parameters and compute their nullability and possibility of NPE.
- public void computeNonNullParamOrThrow(
+ private void computeNonNullParamOrThrow(
OptimizationFeedback feedback, DexEncodedMethod method, IRCode code) {
if (method.getOptimizationInfo().getNonNullParamOrThrow() != null) {
return;
@@ -843,7 +864,7 @@
}
}
- public void computeNonNullParamOnNormalExits(OptimizationFeedback feedback, IRCode code) {
+ private void computeNonNullParamOnNormalExits(OptimizationFeedback feedback, IRCode code) {
Set<BasicBlock> normalExits = Sets.newIdentityHashSet();
normalExits.addAll(code.computeNormalExitBlocks());
DominatorTree dominatorTree = new DominatorTree(code, MAY_HAVE_UNREACHABLE_BLOCKS);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
index 55ce1a4..9d3bb4a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.graph.AppInfoWithSubtyping;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import java.util.function.Function;
@@ -22,12 +23,16 @@
private int readBits = 0;
private boolean cannotBeKept = false;
private boolean valueHasBeenPropagated = false;
- private TypeLatticeElement dynamicType = null;
+ private ClassTypeLatticeElement dynamicLowerBoundType = null;
+ private TypeLatticeElement dynamicUpperBoundType = null;
public void fixupClassTypeReferences(
Function<DexType, DexType> mapping, AppView<? extends AppInfoWithSubtyping> appView) {
- if (dynamicType != null) {
- dynamicType = dynamicType.fixupClassTypeReferences(mapping, appView);
+ if (dynamicLowerBoundType != null) {
+ dynamicLowerBoundType = dynamicLowerBoundType.fixupClassTypeReferences(mapping, appView);
+ }
+ if (dynamicUpperBoundType != null) {
+ dynamicUpperBoundType = dynamicUpperBoundType.fixupClassTypeReferences(mapping, appView);
}
}
@@ -58,12 +63,21 @@
}
@Override
- public TypeLatticeElement getDynamicType() {
- return dynamicType;
+ public ClassTypeLatticeElement getDynamicLowerBoundType() {
+ return dynamicLowerBoundType;
}
- void setDynamicType(TypeLatticeElement type) {
- dynamicType = type;
+ void setDynamicLowerBoundType(ClassTypeLatticeElement type) {
+ dynamicLowerBoundType = type;
+ }
+
+ @Override
+ public TypeLatticeElement getDynamicUpperBoundType() {
+ return dynamicUpperBoundType;
+ }
+
+ void setDynamicUpperBoundType(TypeLatticeElement type) {
+ dynamicUpperBoundType = type;
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index d185a37..a994f5d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -95,8 +95,14 @@
}
@Override
- public void markFieldHasDynamicType(DexEncodedField field, TypeLatticeElement type) {
- getFieldOptimizationInfoForUpdating(field).setDynamicType(type);
+ public void markFieldHasDynamicLowerBoundType(
+ DexEncodedField field, ClassTypeLatticeElement type) {
+ getFieldOptimizationInfoForUpdating(field).setDynamicLowerBoundType(type);
+ }
+
+ @Override
+ public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeLatticeElement type) {
+ getFieldOptimizationInfoForUpdating(field).setDynamicUpperBoundType(type);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
index 79b2e7f..9b5c988 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
@@ -36,7 +36,11 @@
public void markFieldAsPropagated(DexEncodedField field) {}
@Override
- public void markFieldHasDynamicType(DexEncodedField field, TypeLatticeElement type) {}
+ public void markFieldHasDynamicLowerBoundType(
+ DexEncodedField field, ClassTypeLatticeElement type) {}
+
+ @Override
+ public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeLatticeElement type) {}
@Override
public void markFieldBitsRead(DexEncodedField field, int bitsRead) {}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 9119b4b..474a963 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -40,7 +40,13 @@
}
@Override
- public void markFieldHasDynamicType(DexEncodedField field, TypeLatticeElement type) {
+ public void markFieldHasDynamicLowerBoundType(
+ DexEncodedField field, ClassTypeLatticeElement type) {
+ // Ignored.
+ }
+
+ @Override
+ public void markFieldHasDynamicUpperBoundType(DexEncodedField field, TypeLatticeElement type) {
// Ignored.
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
index 0495bba..7e61600 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/ParameterUsagesInfo.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
import com.android.tools.r8.ir.code.Return;
import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Pair;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
@@ -110,6 +111,10 @@
// Returns false if the instruction is not supported.
public boolean note(Instruction instruction) {
+ if (instruction.isAssume()) {
+ // Keep examining other users, but the param usage builder should consider aliased users.
+ return true;
+ }
if (instruction.isIf()) {
return note(instruction.asIf());
}
@@ -141,7 +146,8 @@
private boolean note(If ifInstruction) {
if (ifInstruction.asIf().isZeroTest()) {
- assert ifInstruction.inValues().size() == 1 && ifInstruction.inValues().get(0) == arg;
+ assert ifInstruction.inValues().size() == 1
+ && ifInstruction.inValues().get(0).getAliasedValue() == arg;
ifZeroTestTypes.add(ifInstruction.asIf().getType());
return true;
}
@@ -150,7 +156,7 @@
private boolean note(InstanceGet instanceGetInstruction) {
assert arg != instanceGetInstruction.outValue();
- if (instanceGetInstruction.object() == arg) {
+ if (instanceGetInstruction.object().getAliasedValue() == arg) {
hasFieldRead = true;
return true;
}
@@ -159,12 +165,12 @@
private boolean note(InstancePut instancePutInstruction) {
assert arg != instancePutInstruction.outValue();
- if (instancePutInstruction.object() == arg) {
+ if (instancePutInstruction.object().getAliasedValue() == arg) {
hasFieldAssignment = true;
- isAssignedToField |= instancePutInstruction.value() == arg;
+ isAssignedToField |= instancePutInstruction.value().getAliasedValue() == arg;
return true;
}
- if (instancePutInstruction.value() == arg) {
+ if (instancePutInstruction.value().getAliasedValue() == arg) {
isAssignedToField = true;
return true;
}
@@ -172,7 +178,8 @@
}
private boolean note(InvokeMethodWithReceiver invokeInstruction) {
- if (invokeInstruction.inValues().lastIndexOf(arg) == 0) {
+ if (ListUtils.lastIndexMatching(
+ invokeInstruction.inValues(), v -> v.getAliasedValue() == arg) == 0) {
callsOnReceiver.add(
new Pair<>(
invokeInstruction.asInvokeMethodWithReceiver().getType(),
@@ -183,7 +190,8 @@
}
private boolean note(Return returnInstruction) {
- assert returnInstruction.inValues().size() == 1 && returnInstruction.inValues().get(0) == arg;
+ assert returnInstruction.inValues().size() == 1
+ && returnInstruction.inValues().get(0).getAliasedValue() == arg;
isReturned = true;
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
index 06e7332..09a8d13 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
@@ -371,7 +371,12 @@
// We may get more precise type information if the method is reprocessed (e.g., due to
// optimization info collected from all call sites), and hence the `returnsObjectOfType` is
// allowed to become more precise.
- assert returnsObjectOfType == UNKNOWN_TYPE || type.lessThanOrEqual(returnsObjectOfType, appView)
+ // TODO(b/142559221): non-materializable assume instructions?
+ // Nullability could be less precise, though. For example, suppose a value is known to be
+ // non-null after a safe invocation, hence recorded with the non-null variant. If that call is
+ // inlined and the method is reprocessed, such non-null assumption cannot be made again.
+ assert returnsObjectOfType == UNKNOWN_TYPE
+ || type.lessThanOrEqualUpToNullability(returnsObjectOfType, appView)
: "return type changed from " + returnsObjectOfType + " to " + type;
returnsObjectOfType = type;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/inliner/NopWhyAreYouNotInliningReporter.java b/src/main/java/com/android/tools/r8/ir/optimize/inliner/NopWhyAreYouNotInliningReporter.java
index 467a5b6..8cbb1f4 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/inliner/NopWhyAreYouNotInliningReporter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/inliner/NopWhyAreYouNotInliningReporter.java
@@ -119,11 +119,14 @@
public void reportWillExceedInstructionBudget(int numberOfInstructions, int threshold) {}
@Override
+ public void reportWillExceedMaxInliningDepth(int actualInliningDepth, int threshold) {}
+
+ @Override
public void reportWillExceedMonitorEnterValuesBudget(
int numberOfMonitorEnterValuesAfterInlining, int threshold) {}
@Override
- public boolean verifyReasonHasBeenReported() {
+ public boolean unsetReasonHasBeenReportedFlag() {
return true;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporter.java b/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporter.java
index ab80544..1ff91c0 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporter.java
@@ -113,8 +113,10 @@
public abstract void reportWillExceedInstructionBudget(int numberOfInstructions, int threshold);
+ public abstract void reportWillExceedMaxInliningDepth(int actualInliningDepth, int threshold);
+
public abstract void reportWillExceedMonitorEnterValuesBudget(
int numberOfMonitorEnterValuesAfterInlining, int threshold);
- public abstract boolean verifyReasonHasBeenReported();
+ public abstract boolean unsetReasonHasBeenReportedFlag();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporterImpl.java b/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporterImpl.java
index 7d25661..64026ca 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporterImpl.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/inliner/WhyAreYouNotInliningReporterImpl.java
@@ -247,6 +247,15 @@
}
@Override
+ public void reportWillExceedMaxInliningDepth(int actualInliningDepth, int threshold) {
+ printWithExceededThreshold(
+ "would exceed the maximum inlining depth",
+ "current inlining depth",
+ actualInliningDepth,
+ threshold);
+ }
+
+ @Override
public void reportWillExceedMonitorEnterValuesBudget(
int numberOfMonitorEnterValuesAfterInlining, int threshold) {
printWithExceededThreshold(
@@ -257,8 +266,9 @@
}
@Override
- public boolean verifyReasonHasBeenReported() {
+ public boolean unsetReasonHasBeenReportedFlag() {
assert reasonHasBeenReported;
+ reasonHasBeenReported = false;
return true;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java
index 5c6cb8f..f10c3fe 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.CheckCast;
@@ -147,12 +148,25 @@
public final ListIterator<BasicBlock> blocks;
private InstructionListIterator instructions;
+ // The inlining context (caller), if any.
+ private final DexEncodedMethod context;
+
CodeProcessor(
AppView<AppInfoWithLiveness> appView,
Function<DexType, Strategy> strategyProvider,
LambdaTypeVisitor lambdaChecker,
DexEncodedMethod method,
IRCode code) {
+ this(appView, strategyProvider, lambdaChecker, method, code, null);
+ }
+
+ CodeProcessor(
+ AppView<AppInfoWithLiveness> appView,
+ Function<DexType, Strategy> strategyProvider,
+ LambdaTypeVisitor lambdaChecker,
+ DexEncodedMethod method,
+ IRCode code,
+ DexEncodedMethod context) {
this.appView = appView;
this.strategyProvider = strategyProvider;
this.factory = appView.dexItemFactory();
@@ -161,6 +175,7 @@
this.method = method;
this.code = code;
this.blocks = code.listIterator();
+ this.context = context;
}
public final InstructionListIterator instructions() {
@@ -178,6 +193,19 @@
}
}
+ private boolean shouldRewrite(DexField field) {
+ return shouldRewrite(field.holder);
+ }
+
+ private boolean shouldRewrite(DexMethod method) {
+ return shouldRewrite(method.holder);
+ }
+
+ private boolean shouldRewrite(DexType type) {
+ // Rewrite references to lambda classes if we are outside the class.
+ return type != (context != null ? context : method).method.holder;
+ }
+
@Override
public Void handleInvoke(Invoke invoke) {
if (invoke.isInvokeNewArray()) {
@@ -199,7 +227,7 @@
// Invalidate signature, there still should not be lambda references.
lambdaChecker.accept(invokeMethod.getInvokedMethod().proto);
// Only rewrite references to lambda classes if we are outside the class.
- if (invokeMethod.getInvokedMethod().holder != this.method.method.holder) {
+ if (shouldRewrite(invokeMethod.getInvokedMethod())) {
process(strategy, invokeMethod);
}
return null;
@@ -218,7 +246,7 @@
Strategy strategy = strategyProvider.apply(newInstance.clazz);
if (strategy.isValidNewInstance(this, newInstance)) {
// Only rewrite references to lambda classes if we are outside the class.
- if (newInstance.clazz != this.method.method.holder) {
+ if (shouldRewrite(newInstance.clazz)) {
process(strategy, newInstance);
}
}
@@ -260,7 +288,7 @@
DexField field = instanceGet.getField();
Strategy strategy = strategyProvider.apply(field.holder);
if (strategy.isValidInstanceFieldRead(this, field)) {
- if (field.holder != this.method.method.holder) {
+ if (shouldRewrite(field)) {
// Only rewrite references to lambda classes if we are outside the class.
process(strategy, instanceGet);
}
@@ -279,7 +307,7 @@
DexField field = instancePut.getField();
Strategy strategy = strategyProvider.apply(field.holder);
if (strategy.isValidInstanceFieldWrite(this, field)) {
- if (field.holder != this.method.method.holder) {
+ if (shouldRewrite(field)) {
// Only rewrite references to lambda classes if we are outside the class.
process(strategy, instancePut);
}
@@ -298,7 +326,7 @@
DexField field = staticGet.getField();
Strategy strategy = strategyProvider.apply(field.holder);
if (strategy.isValidStaticFieldRead(this, field)) {
- if (field.holder != this.method.method.holder) {
+ if (shouldRewrite(field)) {
// Only rewrite references to lambda classes if we are outside the class.
process(strategy, staticGet);
}
@@ -314,7 +342,7 @@
DexField field = staticPut.getField();
Strategy strategy = strategyProvider.apply(field.holder);
if (strategy.isValidStaticFieldWrite(this, field)) {
- if (field.holder != this.method.method.holder) {
+ if (shouldRewrite(field)) {
// Only rewrite references to lambda classes if we are outside the class.
process(strategy, staticPut);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index a90704a..b226521 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -56,7 +56,6 @@
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
@@ -84,6 +83,43 @@
// 5. synthesize group lambda classes.
//
public final class LambdaMerger {
+
+ private abstract static class Mode {
+
+ void rewriteCode(DexEncodedMethod method, IRCode code, DexEncodedMethod context) {}
+
+ void analyzeCode(DexEncodedMethod method, IRCode code) {}
+ }
+
+ private class AnalyzeMode extends Mode {
+
+ @Override
+ void analyzeCode(DexEncodedMethod method, IRCode code) {
+ new AnalysisStrategy(method, code).processCode();
+ }
+ }
+
+ private class ApplyMode extends Mode {
+
+ private final Set<DexType> lambdaGroupsClasses;
+ private final LambdaMergerOptimizationInfoFixer optimizationInfoFixer;
+
+ ApplyMode(
+ Set<DexType> lambdaGroupTypes, LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
+ this.lambdaGroupsClasses = lambdaGroupTypes;
+ this.optimizationInfoFixer = optimizationInfoFixer;
+ }
+
+ @Override
+ void rewriteCode(DexEncodedMethod method, IRCode code, DexEncodedMethod context) {
+ if (lambdaGroupsClasses.contains(method.method.holder)) {
+ // Don't rewrite the methods that we have synthesized for the lambda group classes.
+ return;
+ }
+ new ApplyStrategy(method, code, context, optimizationInfoFixer).processCode();
+ }
+ }
+
// Maps lambda into a group, only contains lambdas we decided to merge.
// NOTE: needs synchronization.
private final Map<DexType, LambdaGroup> lambdas = new IdentityHashMap<>();
@@ -113,7 +149,7 @@
private final Kotlin kotlin;
private final DiagnosticsHandler reporter;
- private BiFunction<DexEncodedMethod, IRCode, CodeProcessor> strategyFactory = null;
+ private Mode mode;
// Lambda visitor invalidating lambdas it sees.
private final LambdaTypeVisitor lambdaInvalidator;
@@ -153,8 +189,7 @@
// Collect all group candidates and assign unique lambda ids inside each group.
// We do this before methods are being processed to guarantee stable order of
// lambdas inside each group.
- public final void collectGroupCandidates(
- DexApplication app, AppView<AppInfoWithLiveness> appView) {
+ public final void collectGroupCandidates(DexApplication app) {
// Collect lambda groups.
app.classes().stream()
.filter(cls -> !appView.appInfo().isPinned(cls.type))
@@ -188,20 +223,50 @@
// Remove trivial groups.
removeTrivialLambdaGroups();
- assert strategyFactory == null;
- strategyFactory = AnalysisStrategy::new;
+ assert mode == null;
+ mode = new AnalyzeMode();
}
- // Is called by IRConverter::rewriteCode, performs different actions
- // depending on phase:
- // - in ANALYZE phase just analyzes invalid usages of lambda classes
- // inside the method code, invalidated such lambda classes,
- // collects methods that need to be patched.
- // - in APPLY phase patches the code to use lambda group classes, also
- // asserts that there are no more invalid lambda class references.
- public final void processMethodCode(DexEncodedMethod method, IRCode code) {
- if (strategyFactory != null) {
- strategyFactory.apply(method, code).processCode();
+ /**
+ * Is called by IRConverter::rewriteCode. Performs different actions depending on the current
+ * mode.
+ *
+ * <ol>
+ * <li>in ANALYZE mode analyzes invalid usages of lambda classes inside the method code,
+ * invalidated such lambda classes, collects methods that need to be patched.
+ * <li>in APPLY mode does nothing.
+ * </ol>
+ */
+ public final void analyzeCode(DexEncodedMethod method, IRCode code) {
+ if (mode != null) {
+ mode.analyzeCode(method, code);
+ }
+ }
+
+ /**
+ * Is called by IRConverter::rewriteCode. Performs different actions depending on the current
+ * mode.
+ *
+ * <ol>
+ * <li>in ANALYZE mode does nothing.
+ * <li>in APPLY mode patches the code to use lambda group classes, also asserts that there are
+ * no more invalid lambda class references.
+ * </ol>
+ */
+ public final void rewriteCode(DexEncodedMethod method, IRCode code) {
+ if (mode != null) {
+ mode.rewriteCode(method, code, null);
+ }
+ }
+
+ /**
+ * Similar to {@link #rewriteCode(DexEncodedMethod, IRCode)}, but for rewriting code for inlining.
+ * The {@param context} is the caller that {@param method} is being inlined into.
+ */
+ public final void rewriteCodeForInlining(
+ DexEncodedMethod method, IRCode code, DexEncodedMethod context) {
+ if (mode != null) {
+ mode.rewriteCode(method, code, context);
}
}
@@ -239,7 +304,9 @@
feedback.fixupOptimizationInfos(appView, executorService, optimizationInfoFixer);
// Switch to APPLY strategy.
- this.strategyFactory = (method, code) -> new ApplyStrategy(method, code, optimizationInfoFixer);
+ Set<DexType> lambdaGroupTypes =
+ lambdaGroupsClasses.values().stream().map(clazz -> clazz.type).collect(Collectors.toSet());
+ this.mode = new ApplyMode(lambdaGroupTypes, optimizationInfoFixer);
// Add synthesized lambda group classes to the builder.
for (Entry<LambdaGroup, DexProgramClass> entry : lambdaGroupsClasses.entrySet()) {
@@ -274,7 +341,7 @@
// Rewrite lambda class references into lambda group class
// references inside methods from the processing queue.
rewriteLambdaReferences(converter, executorService, feedback);
- this.strategyFactory = null;
+ this.mode = null;
}
private void analyzeReferencesInProgramClasses(
@@ -459,13 +526,15 @@
private ApplyStrategy(
DexEncodedMethod method,
IRCode code,
+ DexEncodedMethod context,
LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
super(
LambdaMerger.this.appView,
LambdaMerger.this::strategyProvider,
lambdaChecker,
method,
- code);
+ code,
+ context);
this.optimizationInfoFixer = optimizationInfoFixer;
}
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index 8456912..26fbcee 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -38,11 +38,13 @@
import com.android.tools.r8.ir.regalloc.RegisterPositions.Type;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multisets;
+import com.google.common.collect.Sets;
import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
import it.unimi.dsi.fastutil.ints.Int2ReferenceMap.Entry;
import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
@@ -280,7 +282,8 @@
boolean isEntryBlock = true;
for (BasicBlock block : blocks) {
InstructionListIterator instructionIterator = block.listIterator(code);
- Set<Value> liveLocalValues = new HashSet<>(liveAtEntrySets.get(block).liveLocalValues);
+ Set<Value> liveLocalValues =
+ SetUtils.newIdentityHashSet(liveAtEntrySets.get(block).liveLocalValues);
// Skip past arguments and open argument and phi locals.
if (isEntryBlock) {
isEntryBlock = false;
@@ -2516,9 +2519,9 @@
Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets,
List<LiveIntervals> liveIntervals) {
for (BasicBlock block : code.topologicallySortedBlocks()) {
- Set<Value> live = new HashSet<>();
- Set<Value> phiOperands = new HashSet<>();
- Set<Value> liveAtThrowingInstruction = new HashSet<>();
+ Set<Value> live = Sets.newIdentityHashSet();
+ Set<Value> phiOperands = Sets.newIdentityHashSet();
+ Set<Value> liveAtThrowingInstruction = Sets.newIdentityHashSet();
Set<BasicBlock> exceptionalSuccessors = block.getCatchHandlers().getUniqueTargets();
for (BasicBlock successor : block.getSuccessors()) {
// Values live at entry to a block that is an exceptional successor are only live
diff --git a/src/main/java/com/android/tools/r8/shaking/AnnotationFixer.java b/src/main/java/com/android/tools/r8/shaking/AnnotationFixer.java
new file mode 100644
index 0000000..356f609
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/AnnotationFixer.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2019, 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.shaking;
+
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexAnnotationElement;
+import com.android.tools.r8.graph.DexEncodedAnnotation;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.DexValue.DexValueArray;
+import com.android.tools.r8.graph.DexValue.DexValueType;
+import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.utils.ArrayUtils;
+
+public class AnnotationFixer {
+
+ private final GraphLense lense;
+
+ public AnnotationFixer(GraphLense lense) {
+ this.lense = lense;
+ }
+
+ public void run(Iterable<DexProgramClass> classes) {
+ for (DexProgramClass clazz : classes) {
+ clazz.annotations = clazz.annotations.rewrite(this::rewriteAnnotation);
+ clazz.forEachMethod(this::processMethod);
+ clazz.forEachField(this::processField);
+ }
+ }
+
+ private void processMethod(DexEncodedMethod method) {
+ method.annotations = method.annotations.rewrite(this::rewriteAnnotation);
+ method.parameterAnnotationsList =
+ method.parameterAnnotationsList.rewrite(
+ dexAnnotationSet -> dexAnnotationSet.rewrite(this::rewriteAnnotation));
+ }
+
+ private void processField(DexEncodedField field) {
+ field.annotations = field.annotations.rewrite(this::rewriteAnnotation);
+ }
+
+ private DexAnnotation rewriteAnnotation(DexAnnotation original) {
+ return original.rewrite(this::rewriteEncodedAnnotation);
+ }
+
+ private DexEncodedAnnotation rewriteEncodedAnnotation(DexEncodedAnnotation original) {
+ DexEncodedAnnotation rewritten =
+ original.rewrite(lense::lookupType, this::rewriteAnnotationElement);
+ assert rewritten != null;
+ return rewritten;
+ }
+
+ private DexAnnotationElement rewriteAnnotationElement(DexAnnotationElement original) {
+ DexValue rewrittenValue = rewriteValue(original.value);
+ if (rewrittenValue != original.value) {
+ return new DexAnnotationElement(original.name, rewrittenValue);
+ }
+ return original;
+ }
+
+ private DexValue rewriteValue(DexValue value) {
+ if (value.isDexValueType()) {
+ DexType originalType = value.asDexValueType().value;
+ DexType rewrittenType = lense.lookupType(originalType);
+ if (rewrittenType != originalType) {
+ return new DexValueType(rewrittenType);
+ }
+ } else if (value.isDexValueArray()) {
+ DexValue[] originalValues = value.asDexValueArray().getValues();
+ DexValue[] rewrittenValues =
+ ArrayUtils.map(DexValue[].class, originalValues, this::rewriteValue);
+ if (rewrittenValues != originalValues) {
+ return new DexValueArray(rewrittenValues);
+ }
+ }
+ return value;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
index 693058b..701904c 100644
--- a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
+++ b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
@@ -108,11 +108,6 @@
private boolean isAnnotationTypeLive(DexAnnotation annotation) {
DexType annotationType = annotation.annotation.type.toBaseType(appView.dexItemFactory());
- DexClass definition = appView.definitionFor(annotationType);
- // TODO(b/73102187): How to handle annotations without definition.
- if (appView.options().isShrinking() && definition == null) {
- return false;
- }
return appView.appInfo().isNonProgramTypeOrLiveProgramType(annotationType);
}
@@ -276,7 +271,8 @@
private DexAnnotationElement rewriteAnnotationElement(
DexType annotationType, DexAnnotationElement original) {
DexClass definition = appView.definitionFor(annotationType);
- // TODO(b/73102187): How to handle annotations without definition.
+ // We cannot strip annotations where we cannot look up the definition, because this will break
+ // apps that rely on the annotation to exist. See b/134766810 for more information.
if (definition == null) {
return original;
}
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 0689533..5eebf8b 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -182,6 +182,10 @@
/** Set of live types defined in the library and classpath. Used to avoid duplicate tracing. */
private final Set<DexClass> liveNonProgramTypes = Sets.newIdentityHashSet();
+ /** Mapping from each unused interface to the set of live types that implements the interface. */
+ private final Map<DexProgramClass, Set<DexProgramClass>> unusedInterfaceTypes =
+ new IdentityHashMap<>();
+
/**
* Set of proto extension types that are technically live, but which we have not traced because
* they are dead according to the generated extension registry shrinker.
@@ -226,7 +230,7 @@
* Set of methods that belong to live classes and can be reached by invokes. These need to be
* kept.
*/
- private final SetWithReason<DexEncodedMethod> liveMethods;
+ private final LiveMethodsSet liveMethods;
/**
* Set of fields that belong to live classes and can be reached by invokes. These need to be kept.
@@ -309,7 +313,7 @@
liveAnnotations = new SetWithReason<>(graphReporter::registerAnnotation);
instantiatedTypes = new SetWithReason<>(graphReporter::registerClass);
targetedMethods = new SetWithReason<>(graphReporter::registerMethod);
- liveMethods = new SetWithReason<>(graphReporter::registerMethod);
+ liveMethods = new LiveMethodsSet(graphReporter::registerMethod);
liveFields = new SetWithReason<>(graphReporter::registerField);
instantiatedInterfaceTypes = new SetWithReason<>(graphReporter::registerInterface);
}
@@ -483,7 +487,7 @@
private boolean enqueueMarkMethodLiveAction(
DexProgramClass clazz, DexEncodedMethod method, KeepReason reason) {
assert method.method.holder == clazz.type;
- if (liveMethods.add(method, reason)) {
+ if (liveMethods.add(clazz, method, reason)) {
workList.enqueueMarkMethodLiveAction(clazz, method, reason);
return true;
}
@@ -1128,7 +1132,7 @@
KeepReason reason = KeepReason.reachableFromLiveType(holder.type);
for (DexType iface : holder.interfaces.values) {
- markInterfaceTypeAsLiveViaInheritanceClause(iface, reason);
+ markInterfaceTypeAsLiveViaInheritanceClause(iface, holder);
}
if (holder.superType != null) {
@@ -1139,6 +1143,10 @@
markTypeAsLive(holder.superType, reason);
}
+ // If this is an interface that has just become live, then report previously seen but unreported
+ // implemented-by edges.
+ transitionUnusedInterfaceToLive(holder);
+
// We cannot remove virtual methods defined earlier in the type hierarchy if it is widening
// access and is defined in an interface:
//
@@ -1204,32 +1212,29 @@
}
}
- private void markInterfaceTypeAsLiveViaInheritanceClause(DexType type, KeepReason reason) {
- if (appView.options().enableUnusedInterfaceRemoval && !mode.isTracingMainDex()) {
- DexProgramClass clazz = getProgramClassOrNull(type);
- if (clazz == null) {
- return;
- }
+ private void markInterfaceTypeAsLiveViaInheritanceClause(
+ DexType type, DexProgramClass implementer) {
+ DexProgramClass clazz = getProgramClassOrNull(type);
+ if (clazz == null) {
+ return;
+ }
- assert clazz.isInterface();
-
- if (!clazz.interfaces.isEmpty()) {
- markTypeAsLive(type, reason);
- return;
- }
-
- for (DexEncodedMethod method : clazz.virtualMethods()) {
- if (!method.accessFlags.isAbstract()) {
- markTypeAsLive(type, reason);
- return;
- }
- }
-
- // No need to mark the type as live. If an interface type is only reachable via the
- // inheritance clause of another type, and the interface only has abstract methods, it can
- // simply be removed from the inheritance clause.
+ if (!appView.options().enableUnusedInterfaceRemoval || mode.isTracingMainDex()) {
+ markTypeAsLive(clazz, graphReporter.reportClassReferencedFrom(clazz, implementer));
} else {
- markTypeAsLive(type, reason);
+ if (liveTypes.contains(clazz)) {
+ // The interface is already live, so make sure to report this implements-edge.
+ graphReporter.reportClassReferencedFrom(clazz, implementer);
+ } else {
+ // No need to mark the type as live. If an interface type is only reachable via the
+ // inheritance clause of another type it can simply be removed from the inheritance clause.
+ // The interface is needed if it has a live default interface method or field, though.
+ // Therefore, we record that this implemented-by edge has not been reported, such that we
+ // can report it in the future if one its members becomes live.
+ unusedInterfaceTypes
+ .computeIfAbsent(clazz, ignore -> Sets.newIdentityHashSet())
+ .add(implementer);
+ }
}
}
@@ -1394,9 +1399,7 @@
// Already targeted.
return;
}
- markTypeAsLive(method.method.holder,
- holder -> graphReporter.reportClassReferencedFrom(holder, method));
- markParameterAndReturnTypesAsLive(method);
+ markReferencedTypesAsLive(method);
processAnnotations(method, method.annotations.annotations);
method.parameterAnnotationsList.forEachAnnotation(
annotation -> processAnnotation(method, annotation));
@@ -1652,6 +1655,19 @@
&& !instantiatedTypes.contains(current.asProgramClass()));
}
+ private void transitionUnusedInterfaceToLive(DexProgramClass clazz) {
+ if (clazz.isInterface()) {
+ Set<DexProgramClass> implementedBy = unusedInterfaceTypes.remove(clazz);
+ if (implementedBy != null) {
+ for (DexProgramClass implementer : implementedBy) {
+ markTypeAsLive(clazz, graphReporter.reportClassReferencedFrom(clazz, implementer));
+ }
+ }
+ } else {
+ assert !unusedInterfaceTypes.containsKey(clazz);
+ }
+ }
+
private void markFieldAsTargeted(DexField field, DexEncodedMethod context) {
markTypeAsLive(field.type, clazz -> graphReporter.reportClassReferencedFrom(clazz, context));
markTypeAsLive(field.holder, clazz -> graphReporter.reportClassReferencedFrom(clazz, context));
@@ -2083,7 +2099,7 @@
}
if (resolutionTarget.accessFlags.isPrivate() || resolutionTarget.accessFlags.isStatic()) {
- brokenSuperInvokes.add(method);
+ brokenSuperInvokes.add(resolutionTarget.method);
}
DexProgramClass resolutionTargetClass = getProgramClassOrNull(resolutionTarget.method.holder);
if (resolutionTargetClass != null) {
@@ -2103,7 +2119,7 @@
return;
}
if (target.accessFlags.isPrivate()) {
- brokenSuperInvokes.add(method);
+ brokenSuperInvokes.add(resolutionTarget.method);
}
if (Log.ENABLED) {
Log.verbose(getClass(), "Adding super constraint from `%s` to `%s`", from.method,
@@ -2474,11 +2490,9 @@
}
}
markParameterAndReturnTypesAsLive(method);
- if (appView.definitionFor(method.method.holder).isProgramClass()) {
- processAnnotations(method, method.annotations.annotations);
- method.parameterAnnotationsList.forEachAnnotation(
- annotation -> processAnnotation(method, annotation));
- }
+ processAnnotations(method, method.annotations.annotations);
+ method.parameterAnnotationsList.forEachAnnotation(
+ annotation -> processAnnotation(method, annotation));
method.registerCodeReferences(new UseRegistry(options.itemFactory, clazz, method));
// Add all dependent members to the workqueue.
@@ -2488,6 +2502,12 @@
analyses.forEach(analysis -> analysis.processNewlyLiveMethod(method));
}
+ private void markReferencedTypesAsLive(DexEncodedMethod method) {
+ markTypeAsLive(
+ method.method.holder, clazz -> graphReporter.reportClassReferencedFrom(clazz, method));
+ markParameterAndReturnTypesAsLive(method);
+ }
+
private void markParameterAndReturnTypesAsLive(DexEncodedMethod method) {
for (DexType parameterType : method.method.proto.parameters.values) {
markTypeAsLive(
@@ -2880,6 +2900,31 @@
}
}
+ private class LiveMethodsSet {
+
+ private final Set<DexEncodedMethod> items = Sets.newIdentityHashSet();
+
+ private final BiConsumer<DexEncodedMethod, KeepReason> register;
+
+ LiveMethodsSet(BiConsumer<DexEncodedMethod, KeepReason> register) {
+ this.register = register;
+ }
+
+ boolean add(DexProgramClass clazz, DexEncodedMethod method, KeepReason reason) {
+ register.accept(method, reason);
+ transitionUnusedInterfaceToLive(clazz);
+ return items.add(method);
+ }
+
+ boolean contains(DexEncodedMethod method) {
+ return items.contains(method);
+ }
+
+ Set<DexEncodedMethod> getItems() {
+ return Collections.unmodifiableSet(items);
+ }
+ }
+
private static class SetWithReason<T> {
private final Set<T> items = Sets.newIdentityHashSet();
diff --git a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
index 5dc405e..521b90c 100644
--- a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
+++ b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
@@ -199,6 +199,16 @@
}
public KeepReasonWitness reportClassReferencedFrom(
+ DexProgramClass clazz, DexProgramClass implementer) {
+ if (keptGraphConsumer != null) {
+ ClassGraphNode source = getClassGraphNode(implementer.type);
+ ClassGraphNode target = getClassGraphNode(clazz.type);
+ return reportEdge(source, target, EdgeKind.ReferencedFrom);
+ }
+ return KeepReasonWitness.INSTANCE;
+ }
+
+ public KeepReasonWitness reportClassReferencedFrom(
DexProgramClass clazz, DexEncodedMethod method) {
if (keptGraphConsumer != null) {
MethodGraphNode source = getMethodGraphNode(method.method);
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationSourceStrings.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationSourceStrings.java
index 5ab6474..cc9fafa 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationSourceStrings.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationSourceStrings.java
@@ -32,7 +32,7 @@
}
@VisibleForTesting
- static ProguardConfigurationSourceStrings createConfigurationForTesting(
+ public static ProguardConfigurationSourceStrings createConfigurationForTesting(
List<String> config) {
return new ProguardConfigurationSourceStrings(config);
}
diff --git a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
index 487afa2..9326e31 100644
--- a/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/StaticClassMerger.java
@@ -157,6 +157,8 @@
private final HashMultiset<Wrapper<DexField>> fieldBuckets = HashMultiset.create();
private final HashMultiset<Wrapper<DexMethod>> methodBuckets = HashMultiset.create();
+ private boolean hasSynchronizedMethods = false;
+
public Representative(DexProgramClass clazz) {
this.clazz = clazz;
include(clazz);
@@ -168,10 +170,14 @@
Wrapper<DexField> wrapper = fieldEquivalence.wrap(field.field);
fieldBuckets.add(wrapper);
}
+ boolean classHasSynchronizedMethods = false;
for (DexEncodedMethod method : clazz.methods()) {
+ assert !hasSynchronizedMethods || !method.accessFlags.isSynchronized();
+ classHasSynchronizedMethods |= method.accessFlags.isSynchronized();
Wrapper<DexMethod> wrapper = methodEquivalence.wrap(method.method);
methodBuckets.add(wrapper);
}
+ hasSynchronizedMethods |= classHasSynchronizedMethods;
}
// Returns true if this representative should no longer be used. The current heuristic is to
@@ -322,83 +328,42 @@
assert satisfiesMergeCriteria(clazz) == group;
assert group != MergeGroup.DONT_MERGE;
- String pkg = clazz.type.getPackageDescriptor();
- return mayMergeAcrossPackageBoundaries(clazz)
- ? mergeGlobally(clazz, pkg, group)
- : mergeInsidePackage(clazz, pkg, group);
+ return merge(
+ clazz,
+ mayMergeAcrossPackageBoundaries(clazz)
+ ? group.globalKey()
+ : group.key(clazz.type.getPackageDescriptor()));
}
- private boolean mergeGlobally(DexProgramClass clazz, String pkg, MergeGroup group) {
- Representative globalRepresentative = representatives.get(group.globalKey());
- if (globalRepresentative == null) {
- if (isValidRepresentative(clazz)) {
- // Make the current class the global representative.
- setRepresentative(group.globalKey(), getOrCreateRepresentative(group.key(pkg), clazz));
- } else {
- clearRepresentative(group.globalKey());
- }
-
- // Do not attempt to merge this class inside its own package, because that could lead to
- // an increase in the global representative, which is not desirable.
- return false;
- } else {
- // Check if we can merge the current class into the current global representative.
- globalRepresentative.include(clazz);
-
- if (globalRepresentative.isFull()) {
- if (isValidRepresentative(clazz)) {
- // Make the current class the global representative instead.
- setRepresentative(group.globalKey(), getOrCreateRepresentative(group.key(pkg), clazz));
- } else {
- clearRepresentative(group.globalKey());
- }
-
- // Do not attempt to merge this class inside its own package, because that could lead to
- // an increase in the global representative, which is not desirable.
+ private boolean merge(DexProgramClass clazz, MergeGroup.Key key) {
+ Representative representative = representatives.get(key);
+ if (representative != null) {
+ if (representative.hasSynchronizedMethods && clazz.hasStaticSynchronizedMethods()) {
+ // We are not allowed to merge synchronized classes with synchronized methods.
return false;
- } else {
- // Merge this class into the global representative.
- moveMembersFromSourceToTarget(clazz, globalRepresentative.clazz);
- return true;
}
- }
- }
-
- private boolean mergeInsidePackage(DexProgramClass clazz, String pkg, MergeGroup group) {
- MergeGroup.Key key = group.key(pkg);
- Representative packageRepresentative = representatives.get(key);
- if (packageRepresentative != null) {
+ // Check if current candidate is a better choice depending on visibility. For package private
+ // or protected, the key is parameterized by the package name already, so we just have to
+ // check accessibility-flags. For global this is no-op.
if (isValidRepresentative(clazz)
- && clazz.accessFlags.isMoreVisibleThan(
- packageRepresentative.clazz.accessFlags,
- clazz.type.getPackageName(),
- packageRepresentative.clazz.type.getPackageName())) {
- // Use `clazz` as a representative for this package instead.
+ && !representative.clazz.accessFlags.isAtLeastAsVisibleAs(clazz.accessFlags)) {
+ assert clazz.type.getPackageDescriptor().equals(key.packageOrGlobal);
+ assert representative.clazz.type.getPackageDescriptor().equals(key.packageOrGlobal);
Representative newRepresentative = getOrCreateRepresentative(key, clazz);
- newRepresentative.include(packageRepresentative.clazz);
-
+ newRepresentative.include(representative.clazz);
if (!newRepresentative.isFull()) {
- setRepresentative(group.key(pkg), newRepresentative);
- moveMembersFromSourceToTarget(packageRepresentative.clazz, clazz);
+ setRepresentative(key, newRepresentative);
+ moveMembersFromSourceToTarget(representative.clazz, clazz);
return true;
}
-
- // We are not allowed to merge members into a class that is less visible.
- return false;
- }
-
- // Merge current class into the representative of this package if it has room.
- packageRepresentative.include(clazz);
-
- // If there is room, then merge, otherwise fall-through to update the representative of this
- // package.
- if (!packageRepresentative.isFull()) {
- moveMembersFromSourceToTarget(clazz, packageRepresentative.clazz);
- return true;
+ } else {
+ representative.include(clazz);
+ if (!representative.isFull()) {
+ moveMembersFromSourceToTarget(clazz, representative.clazz);
+ return true;
+ }
}
}
-
- // We were unable to use the current representative for this package (if any).
if (isValidRepresentative(clazz)) {
setRepresentative(key, getOrCreateRepresentative(key, clazz));
}
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index cd23ff7..cccf0f4 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -25,6 +25,7 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
@@ -108,32 +109,41 @@
}
private void pruneUnusedInterfaces(DexProgramClass clazz) {
- int numberOfReachableInterfaces = 0;
+ boolean implementsUnusedInterfaces = false;
for (DexType type : clazz.interfaces.values) {
// TODO(christofferqa): Extend unused interface removal to library classes.
- if (isTypeLive(type)) {
- numberOfReachableInterfaces++;
+ if (!isTypeLive(type)) {
+ implementsUnusedInterfaces = true;
+ break;
}
}
- if (numberOfReachableInterfaces == clazz.interfaces.size()) {
+ if (!implementsUnusedInterfaces) {
return;
}
- if (numberOfReachableInterfaces == 0) {
- clazz.interfaces = DexTypeList.empty();
- return;
- }
-
- DexType[] reachableInterfaces = new DexType[numberOfReachableInterfaces];
- int i = 0;
+ Set<DexType> reachableInterfaces = new LinkedHashSet<>();
for (DexType type : clazz.interfaces.values) {
- if (isTypeLive(type)) {
- reachableInterfaces[i] = type;
- i++;
+ retainReachableInterfacesFrom(type, reachableInterfaces);
+ }
+ if (reachableInterfaces.isEmpty()) {
+ clazz.interfaces = DexTypeList.empty();
+ } else {
+ clazz.interfaces = new DexTypeList(reachableInterfaces.toArray(DexType.EMPTY_ARRAY));
+ }
+ }
+
+ private void retainReachableInterfacesFrom(DexType type, Set<DexType> reachableInterfaces) {
+ if (isTypeLive(type)) {
+ reachableInterfaces.add(type);
+ } else {
+ DexProgramClass unusedInterface = appView.definitionForProgramType(type);
+ assert unusedInterface != null;
+ assert unusedInterface.isInterface();
+ for (DexType interfaceType : unusedInterface.interfaces.values) {
+ retainReachableInterfacesFrom(interfaceType, reachableInterfaces);
}
}
- clazz.interfaces = new DexTypeList(reachableInterfaces);
}
private void pruneMembersAndAttributes(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index b8b8482..4dc15ab 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -138,6 +138,7 @@
RESOLUTION_FOR_METHODS_MAY_CHANGE,
SERVICE_LOADER,
STATIC_INITIALIZERS,
+ STATIC_SYNCHRONIZED_METHODS,
UNHANDLED_INVOKE_DIRECT,
UNHANDLED_INVOKE_SUPER,
UNSAFE_INLINING,
@@ -198,6 +199,9 @@
case UNSUPPORTED_ATTRIBUTES:
message = "since inner-class attributes are not supported";
break;
+ case STATIC_SYNCHRONIZED_METHODS:
+ message = "since it has static synchronized methods which can lead to unwanted behavior";
+ break;
default:
assert false;
}
@@ -806,6 +810,14 @@
assert isStillMergeCandidate(clazz);
}
+ // Check for static synchronized methods on source
+ if (clazz.hasStaticSynchronizedMethods()) {
+ if (Log.ENABLED) {
+ AbortReason.STATIC_SYNCHRONIZED_METHODS.printLogMessageForClass(clazz);
+ }
+ return;
+ }
+
// Guard against the case where we have two methods that may get the same signature
// if we replace types. This is rare, so we approximate and err on the safe side here.
if (new CollisionDetector(clazz.type, targetClass.type).mayCollide()) {
@@ -1460,7 +1472,9 @@
for (SynthesizedBridgeCode synthesizedBridge : synthesizedBridges) {
synthesizedBridge.updateMethodSignatures(this::fixupMethod);
}
- return lensBuilder.build(appView, mergedClasses);
+ GraphLense graphLense = lensBuilder.build(appView, mergedClasses);
+ new AnnotationFixer(graphLense).run(appView.appInfo().classes());
+ return graphLense;
}
private void fixupMethods(List<DexEncodedMethod> methods, MethodSetter setter) {
diff --git a/src/main/java/com/android/tools/r8/utils/AarArchiveResourceProvider.java b/src/main/java/com/android/tools/r8/utils/AarArchiveResourceProvider.java
index 7de79dc..6b36180 100644
--- a/src/main/java/com/android/tools/r8/utils/AarArchiveResourceProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/AarArchiveResourceProvider.java
@@ -66,7 +66,7 @@
private List<ProgramResource> readArchive() throws IOException {
List<ProgramResource> classResources = null;
- try (ZipFile zipFile = new ZipFile(archive.toFile(), StandardCharsets.UTF_8)) {
+ try (ZipFile zipFile = FileUtils.createZipFile(archive.toFile(), StandardCharsets.UTF_8)) {
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
diff --git a/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java b/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
index e612e60..5a50f1b 100644
--- a/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
@@ -53,7 +53,8 @@
private List<ProgramResource> readArchive() throws IOException {
List<ProgramResource> dexResources = new ArrayList<>();
List<ProgramResource> classResources = new ArrayList<>();
- try (ZipFile zipFile = new ZipFile(archive.getPath().toFile(), StandardCharsets.UTF_8)) {
+ try (ZipFile zipFile =
+ FileUtils.createZipFile(archive.getPath().toFile(), StandardCharsets.UTF_8)) {
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
@@ -109,7 +110,8 @@
@Override
public void accept(Visitor resourceBrowser) throws ResourceException {
- try (ZipFile zipFile = new ZipFile(archive.getPath().toFile(), StandardCharsets.UTF_8)) {
+ try (ZipFile zipFile =
+ FileUtils.createZipFile(archive.getPath().toFile(), StandardCharsets.UTF_8)) {
final Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
diff --git a/src/main/java/com/android/tools/r8/utils/ClassMap.java b/src/main/java/com/android/tools/r8/utils/ClassMap.java
index 416b389..474f5d0 100644
--- a/src/main/java/com/android/tools/r8/utils/ClassMap.java
+++ b/src/main/java/com/android/tools/r8/utils/ClassMap.java
@@ -42,7 +42,7 @@
* We also allow the transition from Supplier of a null value to the actual value null and vice
* versa.
*/
- private final ConcurrentHashMap<DexType, Supplier<T>> classes;
+ private final Map<DexType, Supplier<T>> classes;
/**
* Class provider if available.
@@ -55,7 +55,7 @@
*/
private final AtomicReference<ClassProvider<T>> classProvider = new AtomicReference<>();
- ClassMap(ConcurrentHashMap<DexType, Supplier<T>> classes, ClassProvider<T> classProvider) {
+ ClassMap(Map<DexType, Supplier<T>> classes, ClassProvider<T> classProvider) {
assert classProvider == null || classProvider.getClassKind() == getClassKind();
this.classes = classes == null ? new ConcurrentHashMap<>() : classes;
this.classProvider.set(classProvider);
diff --git a/src/main/java/com/android/tools/r8/utils/FileUtils.java b/src/main/java/com/android/tools/r8/utils/FileUtils.java
index 87b8506..7185445 100644
--- a/src/main/java/com/android/tools/r8/utils/FileUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/FileUtils.java
@@ -9,12 +9,14 @@
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Arrays;
import java.util.List;
+import java.util.zip.ZipFile;
public class FileUtils {
@@ -28,6 +30,9 @@
public static final String JAVA_EXTENSION = ".java";
public static final String MODULE_INFO_CLASS = "module-info.class";
+ public static final boolean isAndroid =
+ System.getProperty("java.vm.name").equalsIgnoreCase("Dalvik");
+
public static boolean isDexFile(Path path) {
String name = path.getFileName().toString().toLowerCase();
return name.endsWith(DEX_EXTENSION);
@@ -94,7 +99,7 @@
public static Path validateOutputFile(Path path, Reporter reporter) {
if (path != null) {
boolean isJarOrZip = isZipFile(path) || isJarFile(path);
- if (!isJarOrZip && !(Files.exists(path) && Files.isDirectory(path))) {
+ if (!isJarOrZip && !(Files.exists(path) && Files.isDirectory(path))) {
reporter.error(new StringDiagnostic(
"Invalid output: "
+ path
@@ -184,4 +189,21 @@
return path.replace('/', '\\');
}
}
+
+ public static ZipFile createZipFile(File file, Charset charset) throws IOException {
+ if (!isAndroid) {
+ return new ZipFile(file, charset);
+ }
+ // On Android pre-26 we cannot use the constructor ZipFile(file, charset).
+ // By default Android use UTF_8 as the charset, so we can use the default constructor.
+ if (Charset.defaultCharset() == StandardCharsets.UTF_8) {
+ return new ZipFile(file);
+ }
+ // If the Android runtime is started with a different default charset, the default constructor
+ // won't work. It is possible to support this case if we read/write the ZipFile not with it's
+ // own Input/OutputStream, but an external one which one can define on a different Charset than
+ // default. We do not support this at the moment since R8 on dex is used only in tests, and
+ // UTF_8 is the default charset used in tests.
+ throw new RuntimeException("R8 can run on dex only with UTF_8 as the default charset.");
+ }
}
diff --git a/src/main/java/com/android/tools/r8/utils/InternalArchiveClassFileProvider.java b/src/main/java/com/android/tools/r8/utils/InternalArchiveClassFileProvider.java
index cf30d7a..e5557d9 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalArchiveClassFileProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalArchiveClassFileProvider.java
@@ -100,7 +100,7 @@
private ZipFile getOpenZipFile() throws IOException {
if (openedZipFile == null) {
try {
- openedZipFile = new ZipFile(path.toFile(), StandardCharsets.UTF_8);
+ openedZipFile = FileUtils.createZipFile(path.toFile(), StandardCharsets.UTF_8);
} catch (IOException e) {
if (!Files.exists(path)) {
throw new NoSuchFileException(path.toString());
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 89aeb2d..687e7da 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -198,6 +198,9 @@
public boolean enableNonNullTracking = true;
public boolean enableInlining =
!Version.isDev() || System.getProperty("com.android.tools.r8.disableinlining") == null;
+ // TODO(b/141451716): Evaluate the effect of allowing inlining in the inlinee.
+ public boolean applyInliningToInlinee = false;
+ public int applyInliningToInlineeMaxDepth = 0;
public boolean enableInliningOfInvokesWithNullableReceivers = true;
public boolean disableInliningOfLibraryMethodOverrides = true;
public boolean enableClassInlining = true;
@@ -970,6 +973,8 @@
public boolean dontReportFailingCheckDiscarded = false;
public boolean deterministicSortingBasedOnDexType = true;
public PrintStream whyAreYouNotInliningConsumer = System.out;
+ public boolean trackDesugaredAPIConversions =
+ System.getProperty("com.android.tools.r8.trackDesugaredAPIConversions") != null;
// Flag to turn on/off JDK11+ nest-access control even when not required (Cf backend)
public boolean enableForceNestBasedAccessDesugaringForTest = false;
diff --git a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
index 8e3fe1a..7ffce35 100644
--- a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.utils;
import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionIterator;
import com.android.tools.r8.ir.code.InstructionListIterator;
@@ -65,6 +66,16 @@
return null;
}
+ public static <T> T previousUntil(ListIterator<T> iterator, Predicate<T> predicate) {
+ while (iterator.hasPrevious()) {
+ T previous = iterator.previous();
+ if (predicate.test(previous)) {
+ return previous;
+ }
+ }
+ throw new Unreachable();
+ }
+
public static <T> void removeIf(Iterator<T> iterator, Predicate<T> predicate) {
while (iterator.hasNext()) {
T item = iterator.next();
diff --git a/src/test/examples/classmerging/ConflictingInterfaceSignaturesTest.java b/src/test/examples/classmerging/ConflictingInterfaceSignaturesTest.java
index 223ff37..7de7a1f 100644
--- a/src/test/examples/classmerging/ConflictingInterfaceSignaturesTest.java
+++ b/src/test/examples/classmerging/ConflictingInterfaceSignaturesTest.java
@@ -12,6 +12,17 @@
B b = new InterfaceImpl();
b.foo();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(a);
+ escape(b);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
public interface A {
diff --git a/src/test/examples/classmerging/MethodCollisionTest.java b/src/test/examples/classmerging/MethodCollisionTest.java
index a9010a4..4456498 100644
--- a/src/test/examples/classmerging/MethodCollisionTest.java
+++ b/src/test/examples/classmerging/MethodCollisionTest.java
@@ -7,8 +7,22 @@
public class MethodCollisionTest {
public static void main(String[] args) {
- new B().m();
- new D().m();
+ B b = new B();
+ b.m();
+
+ D d = new D();
+ d.m();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(b);
+ escape(d);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
public static class A {
diff --git a/src/test/examples/classmerging/NeverInline.java b/src/test/examples/classmerging/NeverInline.java
new file mode 100644
index 0000000..9438902
--- /dev/null
+++ b/src/test/examples/classmerging/NeverInline.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2019, 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 classmerging;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface NeverInline {}
diff --git a/src/test/examples/classmerging/SimpleInterfaceAccessTest.java b/src/test/examples/classmerging/SimpleInterfaceAccessTest.java
index ce7bf14..6fde90e 100644
--- a/src/test/examples/classmerging/SimpleInterfaceAccessTest.java
+++ b/src/test/examples/classmerging/SimpleInterfaceAccessTest.java
@@ -18,6 +18,17 @@
// package references OtherSimpleInterface.
OtherSimpleInterface y = new OtherSimpleInterfaceImpl();
y.bar();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(x);
+ escape(y);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
// Should only be merged into OtherSimpleInterfaceImpl if access modifications are allowed.
diff --git a/src/test/examples/classmerging/SuperCallRewritingTest.java b/src/test/examples/classmerging/SuperCallRewritingTest.java
index 7a3d45c..6f59419 100644
--- a/src/test/examples/classmerging/SuperCallRewritingTest.java
+++ b/src/test/examples/classmerging/SuperCallRewritingTest.java
@@ -7,6 +7,17 @@
public class SuperCallRewritingTest {
public static void main(String[] args) {
System.out.println("Calling referencedMethod on SubClassThatReferencesSuperMethod");
- System.out.println(new SubClassThatReferencesSuperMethod().referencedMethod());
+ SubClassThatReferencesSuperMethod obj = new SubClassThatReferencesSuperMethod();
+ System.out.println(obj.referencedMethod());
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(obj);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
}
diff --git a/src/test/examples/classmerging/SyntheticBridgeSignaturesTest.java b/src/test/examples/classmerging/SyntheticBridgeSignaturesTest.java
index a17d30a..c263e98 100644
--- a/src/test/examples/classmerging/SyntheticBridgeSignaturesTest.java
+++ b/src/test/examples/classmerging/SyntheticBridgeSignaturesTest.java
@@ -15,6 +15,17 @@
BSub b = new BSub();
a.m(b);
b.m(a);
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(a);
+ escape(b);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
private static class A {
diff --git a/src/test/examples/classmerging/TemplateMethodTest.java b/src/test/examples/classmerging/TemplateMethodTest.java
index ac9de15..fe7de76 100644
--- a/src/test/examples/classmerging/TemplateMethodTest.java
+++ b/src/test/examples/classmerging/TemplateMethodTest.java
@@ -9,6 +9,16 @@
public static void main(String[] args) {
AbstractClass obj = new AbstractClassImpl();
obj.foo();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(obj);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
private abstract static class AbstractClass {
diff --git a/src/test/examples/classmerging/Test.java b/src/test/examples/classmerging/Test.java
index 6d5c51f..d3b2762 100644
--- a/src/test/examples/classmerging/Test.java
+++ b/src/test/examples/classmerging/Test.java
@@ -13,8 +13,17 @@
ConflictingInterfaceImpl impl = new ConflictingInterfaceImpl();
callMethodOnIface(impl);
System.out.println(new SubClassThatReferencesSuperMethod().referencedMethod());
- System.out.println(new Outer().getInstance().method());
+ Outer outer = new Outer();
+ Outer.SubClass inner = outer.getInstance();
+ System.out.println(outer.getInstance().method());
System.out.println(new SubClass(42));
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(clazz);
+ escape(iface);
+ escape(impl);
+ escape(inner);
+ escape(outer);
}
private static void callMethodOnIface(GenericInterface iface) {
@@ -31,4 +40,11 @@
System.out.println(ClassWithConflictingMethod.conflict(null));
System.out.println(OtherClassWithConflictingMethod.conflict(null));
}
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
+ }
}
diff --git a/src/test/examples/classmerging/keep-rules.txt b/src/test/examples/classmerging/keep-rules.txt
index c75058d..11a66c6 100644
--- a/src/test/examples/classmerging/keep-rules.txt
+++ b/src/test/examples/classmerging/keep-rules.txt
@@ -68,4 +68,8 @@
public static void main(...);
}
+-neverinline class * {
+ @classmerging.NeverInline <methods>;
+}
+
-printmapping
diff --git a/src/test/examples/hello/keep-rules.txt b/src/test/examples/hello/keep-rules.txt
new file mode 100644
index 0000000..5a49e41
--- /dev/null
+++ b/src/test/examples/hello/keep-rules.txt
@@ -0,0 +1 @@
+-keep class hello.Hello { public static void main(...);}
diff --git a/src/test/examplesAndroidO/classmerging/MergeDefaultMethodIntoClassTest.java b/src/test/examplesAndroidO/classmerging/MergeDefaultMethodIntoClassTest.java
index 10f995d..5158228 100644
--- a/src/test/examplesAndroidO/classmerging/MergeDefaultMethodIntoClassTest.java
+++ b/src/test/examplesAndroidO/classmerging/MergeDefaultMethodIntoClassTest.java
@@ -11,6 +11,16 @@
// invoke-interface instruction and not invoke-virtual instruction.
A obj = new B();
obj.f();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(obj);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
public interface A {
diff --git a/src/test/examplesAndroidO/classmerging/NestedDefaultInterfaceMethodsTest.java b/src/test/examplesAndroidO/classmerging/NestedDefaultInterfaceMethodsTest.java
index 7a0e325..f237c2e 100644
--- a/src/test/examplesAndroidO/classmerging/NestedDefaultInterfaceMethodsTest.java
+++ b/src/test/examplesAndroidO/classmerging/NestedDefaultInterfaceMethodsTest.java
@@ -7,7 +7,18 @@
public class NestedDefaultInterfaceMethodsTest {
public static void main(String[] args) {
- new C().m();
+ C obj = new C();
+ obj.m();
+
+ // Ensure that the instantiations are not dead code eliminated.
+ escape(obj);
+ }
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
}
public interface A {
diff --git a/src/test/examplesAndroidO/classmerging/NeverInline.java b/src/test/examplesAndroidO/classmerging/NeverInline.java
new file mode 100644
index 0000000..9438902
--- /dev/null
+++ b/src/test/examplesAndroidO/classmerging/NeverInline.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2019, 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 classmerging;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface NeverInline {}
diff --git a/src/test/examplesAndroidO/classmerging/keep-rules.txt b/src/test/examplesAndroidO/classmerging/keep-rules.txt
index 4df182e..18a133d 100644
--- a/src/test/examplesAndroidO/classmerging/keep-rules.txt
+++ b/src/test/examplesAndroidO/classmerging/keep-rules.txt
@@ -14,5 +14,9 @@
public static void main(...);
}
+-neverinline class * {
+ @classmerging.NeverInline <methods>;
+}
+
# TODO(herhut): Consider supporting merging of inner-class attributes.
# -keepattributes *
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/AlwaysInline.java b/src/test/java/com/android/tools/r8/AlwaysInline.java
new file mode 100644
index 0000000..97a799a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/AlwaysInline.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2019, 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface AlwaysInline {}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
index 6695f46..e53fdce 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -17,6 +17,7 @@
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
@@ -193,6 +194,28 @@
}
@Override
+ public ProguardTestBuilder addLibraryClasses(Class<?>... classes) {
+ addLibraryClasses(Arrays.asList(classes));
+ return self();
+ }
+
+ @Override
+ public ProguardTestBuilder addLibraryClasses(Collection<Class<?>> classes) {
+ List<Path> pathsForClasses = new ArrayList<>(classes.size());
+ for (Class<?> clazz : classes) {
+ pathsForClasses.add(ToolHelper.getClassFileForTestClass(clazz));
+ }
+ try {
+ Path out = getState().getNewTempFolder().resolve("out.jar");
+ TestBase.writeClassFilesToJar(out, pathsForClasses);
+ libraryjars.add(out);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ return self();
+ }
+
+ @Override
public ProguardTestBuilder addClasspathClasses(Collection<Class<?>> classes) {
throw new Unimplemented("No support for adding classpath data directly");
}
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index b834aac..8a7d989 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -196,6 +196,19 @@
options -> options.testing.allowUnusedProguardConfigurationRules = true);
}
+ public T enableAlwaysInliningAnnotations() {
+ return enableAlwaysInliningAnnotations(AlwaysInline.class.getPackage().getName());
+ }
+
+ public T enableAlwaysInliningAnnotations(String annotationPackageName) {
+ if (!enableInliningAnnotations) {
+ enableInliningAnnotations = true;
+ addInternalKeepRules(
+ "-alwaysinline class * { @" + annotationPackageName + ".AlwaysInline *; }");
+ }
+ return self();
+ }
+
public T enableInliningAnnotations() {
return enableInliningAnnotations(NeverInline.class.getPackage().getName());
}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 9b8abe6..797d185 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -147,6 +147,17 @@
return testForJvm(temp);
}
+ public TestBuilder<?, ?> testForRuntime(TestRuntime runtime, AndroidApiLevel apiLevel) {
+ if (runtime.isCf()) {
+ return testForJvm();
+ } else {
+ assert runtime.isDex();
+ D8TestBuilder d8TestBuilder = testForD8();
+ d8TestBuilder.setMinApi(apiLevel);
+ return d8TestBuilder;
+ }
+ }
+
public ProguardTestBuilder testForProguard() {
return testForProguard(temp);
}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 0464ccb..84e8cc9 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -137,7 +137,7 @@
private static final String PROGUARD6_0_1 = "third_party/proguard/proguard6.0.1/bin/proguard";
private static final String PROGUARD = PROGUARD5_2_1;
public static final String JACOCO_AGENT = "third_party/jacoco/org.jacoco.agent-0.8.2-runtime.jar";
- public static final String PROGUARD_SETTINGS_FOR_INTERNAL_APPS = "third_party/proguardsettings";
+ public static final String PROGUARD_SETTINGS_FOR_INTERNAL_APPS = "third_party/proguardsettings/";
private static final String RETRACE6_0_1 = "third_party/proguard/proguard6.0.1/bin/retrace";
private static final String RETRACE = RETRACE6_0_1;
@@ -1147,6 +1147,10 @@
return compatSink.build();
}
+ public static void runL8(L8Command command) throws CompilationFailedException {
+ runL8(command, options -> {});
+ }
+
public static void runL8(L8Command command, Consumer<InternalOptions> optionsModifier)
throws CompilationFailedException {
InternalOptions internalOptions = command.getInternalOptions();
diff --git a/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerShouldMergeSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerShouldMergeSynchronizedMethodTest.java
new file mode 100644
index 0000000..7007821
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerShouldMergeSynchronizedMethodTest.java
@@ -0,0 +1,82 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HorizontalClassMergerShouldMergeSynchronizedMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public HorizontalClassMergerShouldMergeSynchronizedMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testNoMergingOfClassUsedInMonitor()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(HorizontalClassMergerShouldMergeSynchronizedMethodTest.class)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("1", "2", "3")
+ .inspect(
+ inspector -> {
+ assertFalse(
+ inspector.clazz(LockOne.class).isPresent()
+ && inspector.clazz(LockTwo.class).isPresent());
+ assertTrue(
+ inspector.clazz(LockOne.class).isPresent()
+ || inspector.clazz(LockTwo.class).isPresent());
+ });
+ }
+
+ // Will be merged with LockTwo.
+ static class LockOne {
+
+ static synchronized void print1() {
+ System.out.println("1");
+ }
+
+ static synchronized void print2() {
+ System.out.println("2");
+ }
+ }
+
+ public static class LockTwo {
+
+ static void print3() {
+ System.out.println("3");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ LockOne.print1();
+ LockOne.print2();
+ LockTwo.print3();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerSynchronizedMethodTest.java
new file mode 100644
index 0000000..a811257
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/HorizontalClassMergerSynchronizedMethodTest.java
@@ -0,0 +1,150 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import java.io.IOException;
+import java.lang.Thread.State;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HorizontalClassMergerSynchronizedMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ // The 4.0.4 runtime will flakily mark threads as blocking and report DEADLOCKED.
+ return getTestParameters()
+ .withDexRuntimesStartingFromExcluding(Version.V4_0_4)
+ .withAllApiLevels()
+ .build();
+ }
+
+ public HorizontalClassMergerSynchronizedMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testOnRuntime() throws IOException, CompilationFailedException, ExecutionException {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addInnerClasses(HorizontalClassMergerSynchronizedMethodTest.class)
+ .run(parameters.getRuntime(), HorizontalClassMergerSynchronizedMethodTest.Main.class)
+ .assertSuccessWithOutput("Hello World!");
+ }
+
+ @Test
+ public void testNoMergingOfClassUsedInMonitor()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(HorizontalClassMergerSynchronizedMethodTest.class)
+ .addKeepMainRule(Main.class)
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput("Hello World!")
+ .inspect(inspector -> assertThat(inspector.clazz(LockOne.class), isPresent()));
+ }
+
+ private interface I {
+
+ void action();
+ }
+
+ // Will be merged with LockTwo.
+ static class LockOne {
+
+ static synchronized void acquire(I c) {
+ c.action();
+ }
+ }
+
+ public static class LockTwo {
+
+ static synchronized void acquire(I c) {
+ Main.inTwoCritical = true;
+ while (!Main.inThreeCritical) {}
+ c.action();
+ }
+ }
+
+ @NeverMerge
+ public static class LockThree {
+
+ static synchronized void acquire(I c) {
+ Main.inThreeCritical = true;
+ while (!Main.inTwoCritical) {}
+ c.action();
+ }
+ }
+
+ public static class AcquireOne implements I {
+
+ @Override
+ public void action() {
+ LockOne.acquire(() -> System.out.print("Hello "));
+ }
+ }
+
+ public static class AcquireThree implements I {
+
+ @Override
+ public void action() {
+ LockThree.acquire(() -> System.out.print("World!"));
+ }
+ }
+
+ public static class Main {
+
+ static volatile boolean inTwoCritical = false;
+ static volatile boolean inThreeCritical = false;
+ static volatile boolean arnoldWillNotBeBack = false;
+
+ private static volatile Thread t1 = new Thread(Main::lockThreeThenOne);
+ private static volatile Thread t2 = new Thread(Main::lockTwoThenThree);
+ private static volatile Thread terminator = new Thread(Main::arnold);
+
+ public static void main(String[] args) {
+ t1.start();
+ t2.start();
+ // This thread is started to ensure termination in case we are rewriting incorrectly.
+ terminator.start();
+
+ while (!arnoldWillNotBeBack) {}
+ }
+
+ static void lockThreeThenOne() {
+ LockThree.acquire(new AcquireOne());
+ }
+
+ static void lockTwoThenThree() {
+ LockTwo.acquire(new AcquireThree());
+ }
+
+ static void arnold() {
+ while (t1.getState() != State.TERMINATED || t2.getState() != State.TERMINATED) {
+ if (t1.getState() == State.BLOCKED && t2.getState() == State.BLOCKED) {
+ System.err.println("DEADLOCKED!");
+ System.exit(1);
+ break;
+ }
+ }
+ arnoldWillNotBeBack = true;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerTest.java
index cd0f8b6..3fa47cb 100644
--- a/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerTest.java
@@ -7,15 +7,17 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.AssumeMayHaveSideEffects;
+import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -51,6 +53,9 @@
}
}
+ private final String EXPECTED =
+ StringUtils.joinLines("StaticMergeCandidateA.m()", "StaticMergeCandidateB.m()");
+
private final TestParameters parameters;
public StaticClassMergerTest(TestParameters parameters) {
@@ -59,16 +64,19 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ @Test
+ public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addInnerClasses(StaticClassMergerTest.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
}
@Test
public void testStaticClassIsRemoved() throws Exception {
- String expected =
- StringUtils.joinLines("StaticMergeCandidateA.m()", "StaticMergeCandidateB.m()");
-
- testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expected);
-
CodeInspector inspector =
testForR8(parameters.getBackend())
.addInnerClasses(StaticClassMergerTest.class)
@@ -76,8 +84,9 @@
.noMinification()
.enableInliningAnnotations()
.enableSideEffectAnnotations()
+ .setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), TestClass.class)
- .assertSuccessWithOutput(expected)
+ .assertSuccessWithOutput(EXPECTED)
.inspector();
// Check that one of the two static merge candidates has been removed
diff --git a/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerVisibilityTest.java b/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerVisibilityTest.java
new file mode 100644
index 0000000..46ccfd2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/StaticClassMergerVisibilityTest.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class StaticClassMergerVisibilityTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ public StaticClassMergerVisibilityTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ @Test
+ public void testStaticClassIsRemoved() throws Exception {
+ CodeInspector inspector =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(StaticClassMergerVisibilityTest.class)
+ .addKeepMainRule(Main.class)
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("A.print()", "B.print()", "C.print()", "D.print()")
+ .inspector();
+
+ // The global group will have one representative, which is C.
+ ClassSubject clazzC = inspector.clazz(C.class);
+ assertThat(clazzC, isPresent());
+ assertEquals(1, clazzC.allMethods().size());
+
+ // The package group will be merged into one of A, B or C.
+ assertExactlyOneIsPresent(
+ inspector.clazz(A.class), inspector.clazz(B.class), inspector.clazz(D.class));
+ }
+
+ private void assertExactlyOneIsPresent(ClassSubject... subjects) {
+ boolean seenPresent = false;
+ for (ClassSubject subject : subjects) {
+ if (subject.isPresent()) {
+ assertFalse(seenPresent);
+ seenPresent = true;
+ }
+ }
+ assertTrue(seenPresent);
+ }
+
+ // Will be merged into the package group.
+ private static class A {
+ @NeverInline
+ private static void print() {
+ System.out.println("A.print()");
+ }
+ }
+
+ // Will be merged into the package group.
+ static class B {
+ @NeverInline
+ static void print() {
+ System.out.println("B.print()");
+ }
+ }
+
+ // Will be merged into global group
+ public static class C {
+ @NeverInline
+ public static void print() {
+ System.out.println("C.print()");
+ }
+ }
+
+ // Will be merged into the package group.
+ protected static class D {
+ @NeverInline
+ protected static void print() {
+ System.out.println("D.print()");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ A.print();
+ B.print();
+ C.print();
+ D.print();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerShouldMergeSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerShouldMergeSynchronizedMethodTest.java
new file mode 100644
index 0000000..5f6e255
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerShouldMergeSynchronizedMethodTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class VerticalClassMergerShouldMergeSynchronizedMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public VerticalClassMergerShouldMergeSynchronizedMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testNoMergingOfClassUsedInMonitor()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(VerticalClassMergerShouldMergeSynchronizedMethodTest.class)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("1", "2", "3", "4")
+ .inspect(
+ inspector -> {
+ assertThat(inspector.clazz(LockOne.class), not(isPresent()));
+ assertThat(inspector.clazz(LockTwo.class), isPresent());
+ });
+ }
+
+ // Will be merged with LockTwo.
+ static class LockOne {
+
+ synchronized void print1() {
+ System.out.println("1");
+ print2();
+ }
+
+ private synchronized void print2() {
+ System.out.println("2");
+ }
+ }
+
+ public static class LockTwo extends LockOne {
+
+ synchronized void print3() {
+ System.out.println("3");
+ }
+
+ static void print4() {
+ System.out.println("4");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ LockTwo lockTwo = new LockTwo();
+ lockTwo.print1();
+ lockTwo.print3();
+ LockTwo.print4();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedBlockTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedBlockTest.java
new file mode 100644
index 0000000..9b3c384
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedBlockTest.java
@@ -0,0 +1,128 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringContains.containsString;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import java.io.IOException;
+import java.lang.Thread.State;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class VerticalClassMergerSynchronizedBlockTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ // The 4.0.4 runtime will flakily mark threads as blocking and report DEADLOCKED.
+ return getTestParameters()
+ .withDexRuntimesStartingFromExcluding(Version.V4_0_4)
+ .withAllApiLevels()
+ .build();
+ }
+
+ public VerticalClassMergerSynchronizedBlockTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testOnRuntime() throws IOException, CompilationFailedException, ExecutionException {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addInnerClasses(VerticalClassMergerSynchronizedBlockTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput("Hello World!");
+ }
+
+ @Test
+ public void testNoMergingOfClassUsedInMonitor()
+ throws IOException, CompilationFailedException, ExecutionException {
+ // TODO(b/142438687): Fix expectation when fixed.
+ R8TestRunResult result =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(VerticalClassMergerSynchronizedBlockTest.class)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatMatches(containsString("DEADLOCKED!"));
+ if (result.getExitCode() == 0) {
+ result.inspect(inspector -> assertThat(inspector.clazz(LockOne.class), isPresent()));
+ }
+ }
+
+ abstract static class LockOne {}
+
+ static class LockTwo extends LockOne {}
+
+ static class LockThree {}
+
+ public static class Main {
+
+ private static volatile boolean inLockThreeCritical = false;
+ private static volatile boolean inLockTwoCritical = false;
+ private static volatile boolean arnoldWillNotBeBack = false;
+
+ private static volatile Thread t1 = new Thread(Main::lockThreeThenOne);
+ private static volatile Thread t2 = new Thread(Main::lockTwoThenThree);
+ private static volatile Thread t3 = new Thread(Main::arnold);
+
+ static void synchronizedAccessThroughLocks(String arg) {
+ System.out.print(arg);
+ }
+
+ public static void main(String[] args) {
+ t1.start();
+ t2.start();
+ // This thread is started to ensure termination in case we are rewriting incorrectly.
+ t3.start();
+
+ while (!arnoldWillNotBeBack) {}
+ }
+
+ static void lockThreeThenOne() {
+ synchronized (LockThree.class) {
+ inLockThreeCritical = true;
+ while (!inLockTwoCritical) {}
+ synchronized (LockOne.class) {
+ synchronizedAccessThroughLocks("Hello ");
+ }
+ }
+ }
+
+ static void lockTwoThenThree() {
+ synchronized (LockTwo.class) {
+ inLockTwoCritical = true;
+ while (!inLockThreeCritical) {}
+ synchronized (LockThree.class) {
+ synchronizedAccessThroughLocks("World!");
+ }
+ }
+ }
+
+ static void arnold() {
+ while (t1.getState() != State.TERMINATED || t2.getState() != State.TERMINATED) {
+ if (t1.getState() == State.BLOCKED && t2.getState() == State.BLOCKED) {
+ System.err.println("DEADLOCKED!");
+ System.exit(1);
+ break;
+ }
+ }
+ arnoldWillNotBeBack = true;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedMethodTest.java
new file mode 100644
index 0000000..e77ee05
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerSynchronizedMethodTest.java
@@ -0,0 +1,150 @@
+// Copyright (c) 2019, 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.classmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import java.io.IOException;
+import java.lang.Thread.State;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class VerticalClassMergerSynchronizedMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ // The 4.0.4 runtime will flakily mark threads as blocking and report DEADLOCKED.
+ return getTestParameters()
+ .withDexRuntimesStartingFromExcluding(Version.V4_0_4)
+ .withAllApiLevels()
+ .build();
+ }
+
+ public VerticalClassMergerSynchronizedMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testOnRuntime() throws IOException, CompilationFailedException, ExecutionException {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addInnerClasses(VerticalClassMergerSynchronizedMethodTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput("Hello World!");
+ }
+
+ @Test
+ public void testNoMergingOfClassUsedInMonitor()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(VerticalClassMergerSynchronizedMethodTest.class)
+ .addKeepMainRule(Main.class)
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput("Hello World!")
+ .inspect(inspector -> assertThat(inspector.clazz(LockOne.class), isPresent()));
+ }
+
+ private interface I {
+
+ void action();
+ }
+
+ // Will be merged into LockTwo.
+ abstract static class LockOne {
+
+ static synchronized void acquire(I c) {
+ c.action();
+ }
+ }
+
+ @NeverMerge
+ public static class LockTwo extends LockOne {
+
+ static synchronized void acquire(I c) {
+ Main.inTwoCritical = true;
+ while (!Main.inThreeCritical) {}
+ c.action();
+ }
+ }
+
+ @NeverMerge
+ public static class LockThree {
+
+ static synchronized void acquire(I c) {
+ Main.inThreeCritical = true;
+ while (!Main.inTwoCritical) {}
+ c.action();
+ }
+ }
+
+ public static class AcquireOne implements I {
+
+ @Override
+ public void action() {
+ LockOne.acquire(() -> System.out.print("Hello "));
+ }
+ }
+
+ public static class AcquireThree implements I {
+
+ @Override
+ public void action() {
+ LockThree.acquire(() -> System.out.print("World!"));
+ }
+ }
+
+ public static class Main {
+
+ static volatile boolean inTwoCritical = false;
+ static volatile boolean inThreeCritical = false;
+ static volatile boolean arnoldWillNotBeBack = false;
+
+ private static volatile Thread t1 = new Thread(Main::lockThreeThenOne);
+ private static volatile Thread t2 = new Thread(Main::lockTwoThenThree);
+ private static volatile Thread terminator = new Thread(Main::arnold);
+
+ public static void main(String[] args) {
+ t1.start();
+ t2.start();
+ // This thread is started to ensure termination in case we are rewriting incorrectly.
+ terminator.start();
+
+ while (!arnoldWillNotBeBack) {}
+ }
+
+ static void lockThreeThenOne() {
+ LockThree.acquire(new AcquireOne());
+ }
+
+ static void lockTwoThenThree() {
+ LockTwo.acquire(new AcquireThree());
+ }
+
+ static void arnold() {
+ while (t1.getState() != State.TERMINATED || t2.getState() != State.TERMINATED) {
+ if (t1.getState() == State.BLOCKED && t2.getState() == State.BLOCKED) {
+ System.err.println("DEADLOCKED!");
+ System.exit(1);
+ break;
+ }
+ }
+ arnoldWillNotBeBack = true;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
index 6b4f17d..82385a2 100644
--- a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
@@ -10,8 +10,6 @@
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.OutputMode;
@@ -78,7 +76,6 @@
.resolve("classmerging").resolve("keep-rules-dontoptimize.txt");
private void configure(InternalOptions options) {
- options.enableClassInlining = false;
options.enableSideEffectAnalysis = false;
options.enableUnusedInterfaceRemoval = false;
options.testing.nondeterministicCycleElimination = true;
@@ -90,6 +87,7 @@
testForR8(Backend.DEX)
.addProgramFiles(EXAMPLE_JAR)
.addKeepRuleFiles(proguardConfig)
+ .enableProguardTestOptions()
.noMinification()
.addOptionsModification(optionsConsumer)
.compile()
@@ -110,18 +108,18 @@
runR8(EXAMPLE_KEEP, this::configure);
// GenericInterface should be merged into GenericInterfaceImpl.
for (String candidate : CAN_BE_MERGED) {
- assertFalse(inspector.clazz(candidate).isPresent());
+ assertThat(inspector.clazz(candidate), not(isPresent()));
}
- assertTrue(inspector.clazz("classmerging.GenericInterfaceImpl").isPresent());
- assertTrue(inspector.clazz("classmerging.Outer$SubClass").isPresent());
- assertTrue(inspector.clazz("classmerging.SubClass").isPresent());
+ assertThat(inspector.clazz("classmerging.GenericInterfaceImpl"), isPresent());
+ assertThat(inspector.clazz("classmerging.Outer$SubClass"), isPresent());
+ assertThat(inspector.clazz("classmerging.SubClass"), isPresent());
}
@Test
public void testClassesHaveNotBeenMerged() throws Throwable {
runR8(DONT_OPTIMIZE, null);
for (String candidate : CAN_BE_MERGED) {
- assertTrue(inspector.clazz(candidate).isPresent());
+ assertThat(inspector.clazz(candidate), isPresent());
}
}
@@ -304,8 +302,8 @@
@Test
public void testConflictWasDetected() throws Throwable {
runR8(EXAMPLE_KEEP, this::configure);
- assertTrue(inspector.clazz("classmerging.ConflictingInterface").isPresent());
- assertTrue(inspector.clazz("classmerging.ConflictingInterfaceImpl").isPresent());
+ assertThat(inspector.clazz("classmerging.ConflictingInterface"), isPresent());
+ assertThat(inspector.clazz("classmerging.ConflictingInterfaceImpl"), isPresent());
}
@Test
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/EmptyDesugaredLibrary.java b/src/test/java/com/android/tools/r8/desugar/corelib/EmptyDesugaredLibrary.java
new file mode 100644
index 0000000..998682c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/EmptyDesugaredLibrary.java
@@ -0,0 +1,101 @@
+// Copyright (c) 2019, 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.desugar.corelib;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ByteDataView;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.L8Command;
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.StringResource;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.zip.ZipFile;
+import org.junit.Test;
+
+public class EmptyDesugaredLibrary extends CoreLibDesugarTestBase {
+
+ private L8Command.Builder prepareL8Builder(AndroidApiLevel minApiLevel) {
+ return L8Command.builder()
+ .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+ .addProgramFiles(ToolHelper.getDesugarJDKLibs())
+ .addDesugaredLibraryConfiguration(
+ StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING))
+ .setMinApiLevel(minApiLevel.getLevel());
+ }
+
+ static class CountingProgramConsumer extends DexIndexedConsumer.ForwardingConsumer {
+
+ public int count = 0;
+
+ public CountingProgramConsumer() {
+ super(null);
+ }
+
+ @Override
+ public void accept(
+ int fileIndex, ByteDataView data, Set<String> descriptors, DiagnosticsHandler handler) {
+ count++;
+ }
+ }
+
+ @Test
+ public void testEmptyDesugaredLibrary() throws Exception {
+ for (AndroidApiLevel apiLevel : AndroidApiLevel.values()) {
+ if (apiLevel.getLevel() < AndroidApiLevel.K.getLevel()) {
+ // No need to test all API levels.
+ continue;
+ }
+ CountingProgramConsumer programConsumer = new CountingProgramConsumer();
+ ToolHelper.runL8(prepareL8Builder(apiLevel).setProgramConsumer(programConsumer).build());
+ assertEquals(
+ apiLevel.getLevel() >= AndroidApiLevel.O.getLevel() ? 0 : 1, programConsumer.count);
+ }
+ }
+
+ @Test
+ public void testEmptyDesugaredLibraryDexZip() throws Exception {
+ for (AndroidApiLevel apiLevel : AndroidApiLevel.values()) {
+ if (apiLevel.getLevel() < AndroidApiLevel.K.getLevel()) {
+ // No need to test all API levels.
+ continue;
+ }
+ Path desugaredLibraryZip = temp.newFolder().toPath().resolve("desugar_jdk_libs_dex.zip");
+ ToolHelper.runL8(
+ prepareL8Builder(apiLevel).setOutput(desugaredLibraryZip, OutputMode.DexIndexed).build());
+ assertTrue(Files.exists(desugaredLibraryZip));
+ assertEquals(
+ apiLevel.getLevel() >= AndroidApiLevel.O.getLevel() ? 0 : 1,
+ new ZipFile(desugaredLibraryZip.toFile(), StandardCharsets.UTF_8).size());
+ }
+ }
+
+ @Test
+ public void testEmptyDesugaredLibraryDexDirectory() throws Exception {
+ for (AndroidApiLevel apiLevel : AndroidApiLevel.values()) {
+ if (apiLevel.getLevel() < AndroidApiLevel.K.getLevel()) {
+ // No need to test all API levels.
+ continue;
+ }
+ Path desugaredLibraryDirectory = temp.newFolder().toPath();
+ ToolHelper.runL8(
+ prepareL8Builder(apiLevel)
+ .setOutput(desugaredLibraryDirectory, OutputMode.DexIndexed)
+ .build());
+ assertEquals(
+ apiLevel.getLevel() >= AndroidApiLevel.O.getLevel() ? 0 : 1,
+ Files.walk(desugaredLibraryDirectory)
+ .filter(path -> path.toString().endsWith(".dex"))
+ .count());
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/HelloWorldCompiledOnArtTest.java b/src/test/java/com/android/tools/r8/desugar/corelib/HelloWorldCompiledOnArtTest.java
new file mode 100644
index 0000000..044f075
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/HelloWorldCompiledOnArtTest.java
@@ -0,0 +1,135 @@
+// Copyright (c) 2019, 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.desugar.corelib;
+
+import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.D8;
+import com.android.tools.r8.D8TestBuilder;
+import com.android.tools.r8.D8TestCompileResult;
+import com.android.tools.r8.R8;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class HelloWorldCompiledOnArtTest extends CoreLibDesugarTestBase {
+
+ // TODO(b/142621961): Create an abstraction to easily run tests on External DexR8.
+ // Manage pathMock in the abstraction.
+ private static Path pathMock;
+
+ @BeforeClass
+ public static void compilePathBackport() throws Exception {
+ assumeTrue("JDK8 is not checked-in on Windows", !ToolHelper.isWindows());
+ pathMock = getStaticTemp().newFolder("PathMock").toPath();
+ ProcessResult processResult =
+ ToolHelper.runJavac(
+ CfVm.JDK8,
+ Collections.emptyList(),
+ pathMock,
+ getAllFilesWithSuffixInDirectory(Paths.get("src/test/r8OnArtBackport"), "java"));
+ assertEquals(0, processResult.exitCode);
+ }
+
+ public static Path[] getPathBackport() throws Exception {
+ return getAllFilesWithSuffixInDirectory(pathMock, "class");
+ }
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.L)
+ .build();
+ }
+
+ public HelloWorldCompiledOnArtTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ private static String commandLinePathFor(String string) {
+ return Paths.get(string).toAbsolutePath().toString();
+ }
+
+ private static final String HELLO_KEEP =
+ commandLinePathFor("src/test/examples/hello/keep-rules.txt");
+ private static final String HELLO_PATH =
+ commandLinePathFor(ToolHelper.EXAMPLES_BUILD_DIR + "hello" + JAR_EXTENSION);
+
+ @Test
+ public void testHelloCompiledWithR8Dex() throws Exception {
+ Path helloOutput = temp.newFolder("helloOutput").toPath().resolve("out.zip").toAbsolutePath();
+ compileR8ToDexWithD8()
+ .run(
+ parameters.getRuntime(),
+ R8.class,
+ "--release",
+ "--output",
+ helloOutput.toString(),
+ "--lib",
+ commandLinePathFor(ToolHelper.JAVA_8_RUNTIME),
+ "--pg-conf",
+ HELLO_KEEP,
+ HELLO_PATH)
+ .assertSuccess();
+ verifyResult(helloOutput);
+ }
+
+ @Test
+ public void testHelloCompiledWithD8Dex() throws Exception {
+ Path helloOutput = temp.newFolder("helloOutput").toPath().resolve("out.zip").toAbsolutePath();
+ compileR8ToDexWithD8()
+ .run(
+ parameters.getRuntime(),
+ D8.class,
+ "--release",
+ "--output",
+ helloOutput.toString(),
+ "--lib",
+ commandLinePathFor(ToolHelper.JAVA_8_RUNTIME),
+ HELLO_PATH)
+ .assertSuccess();
+ verifyResult(helloOutput);
+ }
+
+ private void verifyResult(Path helloOutput) throws IOException {
+ ProcessResult processResult = ToolHelper.runArtRaw(helloOutput.toString(), "hello.Hello");
+ assertEquals(StringUtils.lines("Hello, world"), processResult.stdout);
+ }
+
+ private D8TestCompileResult compileR8ToDexWithD8() throws Exception {
+ D8TestBuilder d8TestBuilder =
+ testForD8().addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR);
+ if (parameters.getApiLevel().getLevel() < AndroidApiLevel.O.getLevel()) {
+ d8TestBuilder.addProgramFiles(getPathBackport());
+ }
+ return d8TestBuilder
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, parameters.getApiLevel())
+ .withArt6Plus64BitsLib()
+ .withArtFrameworks();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/LinkedHashSetTest.java b/src/test/java/com/android/tools/r8/desugar/corelib/LinkedHashSetTest.java
new file mode 100644
index 0000000..178af61
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/LinkedHashSetTest.java
@@ -0,0 +1,120 @@
+// Copyright (c) 2019, 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.desugar.corelib;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.util.LinkedHashSet;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class LinkedHashSetTest extends CoreLibDesugarTestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ }
+
+ public LinkedHashSetTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testLinkedHashSetOverrides() throws Exception {
+ String stdOut =
+ testForD8()
+ .addInnerClasses(LinkedHashSetTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary, parameters.getApiLevel())
+ .run(parameters.getRuntime(), Executor.class)
+ .assertSuccess()
+ .getStdOut();
+ assertLines2By2Correct(stdOut);
+ }
+
+ static class Executor {
+ @SuppressWarnings("RedundantOperationOnEmptyContainer")
+ public static void main(String[] args) {
+ Spliterator<String> spliterator;
+
+ // Spliterator of Set is only distinct.
+ // Spliterator of LinkedHashSet is distinct and ordered.
+ // Spliterator of CustomLinkedHashSetOverride is distinct, ordered and immutable.
+ // If an incorrect method is found, characteristics are incorrect.
+
+ spliterator = new LinkedHashSet<String>().spliterator();
+ System.out.println(spliterator.hasCharacteristics(Spliterator.DISTINCT));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.ORDERED));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.IMMUTABLE));
+ System.out.println("false");
+
+ spliterator = new CustomLinkedHashSetOverride<String>().spliterator();
+ System.out.println(spliterator.hasCharacteristics(Spliterator.DISTINCT));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.ORDERED));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.IMMUTABLE));
+ System.out.println("true");
+
+ spliterator = new CustomLinkedHashSetNoOverride<String>().spliterator();
+ System.out.println(spliterator.hasCharacteristics(Spliterator.DISTINCT));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.ORDERED));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.IMMUTABLE));
+ System.out.println("false");
+
+ spliterator = new CustomLinkedHashSetOverride<String>().superSpliterator();
+ System.out.println(spliterator.hasCharacteristics(Spliterator.DISTINCT));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.ORDERED));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.IMMUTABLE));
+ System.out.println("false");
+
+ spliterator = new SubclassOverride<String>().superSpliterator();
+ System.out.println(spliterator.hasCharacteristics(Spliterator.DISTINCT));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.ORDERED));
+ System.out.println("true");
+ System.out.println(spliterator.hasCharacteristics(Spliterator.IMMUTABLE));
+ System.out.println("true");
+ }
+ }
+
+ static class CustomLinkedHashSetOverride<E> extends LinkedHashSet<E> {
+
+ @Override
+ public Spliterator<E> spliterator() {
+ return Spliterators.spliterator(
+ this, Spliterator.DISTINCT | Spliterator.ORDERED | Spliterator.IMMUTABLE);
+ }
+
+ public Spliterator<E> superSpliterator() {
+ return super.spliterator();
+ }
+ }
+
+ static class SubclassOverride<E> extends CustomLinkedHashSetOverride<E> {
+ @Override
+ public Spliterator<E> superSpliterator() {
+ return super.spliterator();
+ }
+ }
+
+ @SuppressWarnings("WeakerAccess")
+ static class CustomLinkedHashSetNoOverride<E> extends LinkedHashSet<E> {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/RetargetOverrideTest.java b/src/test/java/com/android/tools/r8/desugar/corelib/RetargetOverrideTest.java
new file mode 100644
index 0000000..df4e4d8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/RetargetOverrideTest.java
@@ -0,0 +1,156 @@
+// Copyright (c) 2019, 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.desugar.corelib;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RetargetOverrideTest extends CoreLibDesugarTestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ }
+
+ public RetargetOverrideTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRetargetOverrideD8() throws Exception {
+ String stdout =
+ testForD8()
+ .addInnerClasses(RetargetOverrideTest.class)
+ .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary, parameters.getApiLevel())
+ .run(parameters.getRuntime(), Executor.class)
+ .assertSuccess()
+ .getStdOut();
+ assertLines2By2Correct(stdout);
+ }
+
+ @Test
+ public void testRetargetOverrideR8() throws Exception {
+ String stdout =
+ testForR8(Backend.DEX)
+ .addKeepMainRule(Executor.class)
+ .addInnerClasses(RetargetOverrideTest.class)
+ .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary, parameters.getApiLevel())
+ .run(parameters.getRuntime(), Executor.class)
+ .assertSuccess()
+ .getStdOut();
+ assertLines2By2Correct(stdout);
+ }
+
+ static class Executor {
+
+ public static void main(String[] args) {
+ java.sql.Date date = new java.sql.Date(123456789);
+ System.out.println(date.toInstant());
+ System.out.println("1970-01-02T10:17:36.789Z");
+
+ GregorianCalendar gregCal = new GregorianCalendar(1990, 2, 22);
+ System.out.println(gregCal.toInstant());
+ System.out.println("1990-03-22T00:00:00Z");
+
+ // TODO(b/142846107): Enable overrides of retarget core members.
+ // MyCalendarOverride myCal = new MyCalendarOverride(1990, 2, 22);
+ // System.out.println(myCal.toZonedDateTime());
+ // System.out.println("1990-11-22T00:00Z[GMT]");
+ // System.out.println(myCal.toInstant());
+ // System.out.println("1990-03-22T00:00:00Z");
+
+ MyCalendarNoOverride myCalN = new MyCalendarNoOverride(1990, 2, 22);
+ System.out.println(myCalN.toZonedDateTime());
+ System.out.println("1990-03-22T00:00Z[GMT]");
+ System.out.println(myCalN.toInstant());
+ System.out.println("1990-03-22T00:00:00Z");
+
+ // TODO(b/142846107): Enable overrides of retarget core members.
+ // MyDateOverride myDate = new MyDateOverride(123456789);
+ // System.out.println(myDate.toInstant());
+ // System.out.println("1970-01-02T10:17:45.789Z");
+
+ MyDateNoOverride myDateN = new MyDateNoOverride(123456789);
+ System.out.println(myDateN.toInstant());
+ System.out.println("1970-01-02T10:17:36.789Z");
+
+ MyAtomicInteger myAtomicInteger = new MyAtomicInteger(42);
+ System.out.println(myAtomicInteger.getAndUpdate(x -> x + 1));
+ System.out.println("42");
+ System.out.println(myAtomicInteger.getAndUpdate(x -> x + 5));
+ System.out.println("43");
+ System.out.println(myAtomicInteger.updateAndGet(x -> x + 100));
+ System.out.println("148");
+ System.out.println(myAtomicInteger.updateAndGet(x -> x + 500));
+ System.out.println("648");
+ }
+ }
+
+ // static class MyCalendarOverride extends GregorianCalendar {
+ //
+ // public MyCalendarOverride(int year, int month, int dayOfMonth) {
+ // super(year, month, dayOfMonth);
+ // }
+ //
+ // // Cannot override toInstant (final).
+ //
+ // @Override
+ // public ZonedDateTime toZonedDateTime() {
+ // return super.toZonedDateTime().withMonth(11);
+ // }
+ // }
+
+ static class MyCalendarNoOverride extends GregorianCalendar {
+ public MyCalendarNoOverride(int year, int month, int dayOfMonth) {
+ super(year, month, dayOfMonth);
+ }
+ }
+
+ // static class MyDateOverride extends Date {
+ //
+ // public MyDateOverride(long date) {
+ // super(date);
+ // }
+ //
+ // @Override
+ // public Instant toInstant() {
+ // return super.toInstant().plusSeconds(9);
+ // }
+ // }
+
+ static class MyDateNoOverride extends Date {
+
+ public MyDateNoOverride(long date) {
+ super(date);
+ }
+ }
+
+ static class MyAtomicInteger extends AtomicInteger {
+ // No overrides, all final methods.
+ public MyAtomicInteger(int initialValue) {
+ super(initialValue);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/corelib/conversionTests/AllTimeConversionTest.java b/src/test/java/com/android/tools/r8/desugar/corelib/conversionTests/AllTimeConversionTest.java
index ed5ca26..3775eba 100644
--- a/src/test/java/com/android/tools/r8/desugar/corelib/conversionTests/AllTimeConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/corelib/conversionTests/AllTimeConversionTest.java
@@ -4,6 +4,11 @@
package com.android.tools.r8.desugar.corelib.conversionTests;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
+import com.android.tools.r8.D8TestCompileResult;
+import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestRuntime.DexRuntime;
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.utils.AndroidApiLevel;
@@ -22,12 +27,15 @@
@Test
public void testRewrittenAPICalls() throws Exception {
Path customLib = testForD8().addProgramClasses(CustomLibClass.class).compile().writeToZip();
- testForD8()
- .setMinApi(AndroidApiLevel.B)
- .addProgramClasses(Executor.class)
- .addLibraryClasses(CustomLibClass.class)
- .enableCoreLibraryDesugaring(AndroidApiLevel.B)
- .compile()
+ D8TestCompileResult compileResult =
+ testForD8()
+ .setMinApi(AndroidApiLevel.B)
+ .addProgramClasses(Executor.class)
+ .addLibraryClasses(CustomLibClass.class)
+ .addOptionsModification(options -> options.testing.trackDesugaredAPIConversions = true)
+ .enableCoreLibraryDesugaring(AndroidApiLevel.B)
+ .compile();
+ compileResult
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibraryWithConversionExtension, AndroidApiLevel.B)
.addRunClasspathFiles(customLib)
@@ -41,8 +49,29 @@
"-1000000000-01-01T00:00:00.999999999Z",
"GMT",
"GMT"));
+ assertTrackedAPIS(compileResult.getDiagnosticMessages());
}
+ private void assertTrackedAPIS(TestDiagnosticMessages diagnosticMessages) {
+ assertTrue(
+ diagnosticMessages
+ .getWarnings()
+ .get(0)
+ .getDiagnosticMessage()
+ .startsWith("Tracked desugared API conversions:"));
+ assertEquals(
+ 9, diagnosticMessages.getWarnings().get(0).getDiagnosticMessage().split("\n").length);
+ assertTrue(
+ diagnosticMessages
+ .getWarnings()
+ .get(1)
+ .getDiagnosticMessage()
+ .startsWith("Tracked callback desugared API conversions:"));
+ assertEquals(
+ 1, diagnosticMessages.getWarnings().get(1).getDiagnosticMessage().split("\n").length);
+ }
+
+
static class Executor {
private static final String ZONE_ID = "GMT";
diff --git a/src/test/java/com/android/tools/r8/internal/Gmail17060416TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/Gmail17060416TreeShakeJarVerificationTest.java
new file mode 100644
index 0000000..82e7e93
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/internal/Gmail17060416TreeShakeJarVerificationTest.java
@@ -0,0 +1,49 @@
+// Copyright (c) 2019, 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.internal;
+
+import static com.android.tools.r8.ToolHelper.isLocalDevelopment;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.nio.file.Paths;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class Gmail17060416TreeShakeJarVerificationTest extends GmailCompilationBase {
+ private static final int MAX_SIZE = 20000000;
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().build();
+ }
+
+ public Gmail17060416TreeShakeJarVerificationTest(TestParameters parameters) {
+ super(170604, 16);
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void buildAndTreeShakeFromDeployJar() throws Exception {
+ assumeTrue(isLocalDevelopment());
+
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addKeepRuleFiles(Paths.get(base).resolve(BASE_PG_CONF))
+ .allowUnusedProguardConfigurationRules()
+ .compile();
+
+ int appSize = applicationSize(compileResult.app);
+ assertTrue("Expected max size of " + MAX_SIZE+ ", got " + appSize, appSize < MAX_SIZE);
+ }
+
+}
diff --git a/src/test/java/com/android/tools/r8/internal/Gmail18082615TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/Gmail18082615TreeShakeJarVerificationTest.java
new file mode 100644
index 0000000..0f6a563
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/internal/Gmail18082615TreeShakeJarVerificationTest.java
@@ -0,0 +1,51 @@
+// Copyright (c) 2019, 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.internal;
+
+import static com.android.tools.r8.ToolHelper.isLocalDevelopment;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import java.nio.file.Paths;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class Gmail18082615TreeShakeJarVerificationTest extends GmailCompilationBase {
+ private static final int MAX_SIZE = 20000000;
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().build();
+ }
+
+ public Gmail18082615TreeShakeJarVerificationTest(TestParameters parameters) {
+ super(180826, 15);
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void buildAndTreeShakeFromDeployJar() throws Exception {
+ assumeTrue(isLocalDevelopment());
+
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addKeepRuleFiles(
+ Paths.get(base).resolve(BASE_PG_CONF),
+ Paths.get(ToolHelper.PROGUARD_SETTINGS_FOR_INTERNAL_APPS, PG_CONF))
+ .allowUnusedProguardConfigurationRules()
+ .compile();
+
+ int appSize = applicationSize(compileResult.app);
+ assertTrue("Expected max size of " + MAX_SIZE+ ", got " + appSize, appSize < MAX_SIZE);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/internal/GmailCompilationBase.java b/src/test/java/com/android/tools/r8/internal/GmailCompilationBase.java
new file mode 100644
index 0000000..7332dd8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/internal/GmailCompilationBase.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2019, 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.internal;
+
+abstract class GmailCompilationBase extends CompilationTestBase {
+ static final String APK = "Gmail_release_unsigned.apk";
+ static final String DEPLOY_JAR = "Gmail_release_unstripped_deploy.jar";
+ static final String PG_JAR = "Gmail_release_unstripped_proguard.jar";
+ static final String PG_MAP = "Gmail_release_unstripped_proguard.map";
+ static final String BASE_PG_CONF = "Gmail_release_unstripped_proguard.config";
+ static final String PG_CONF = "Gmail_proguard.config";
+
+ final String base;
+
+ GmailCompilationBase(int majorVersion, int minorVersion) {
+ this.base = "third_party/gmail/gmail_android_" + majorVersion + "." + minorVersion + "/";
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreLatestTreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreLatestTreeShakeJarVerificationTest.java
index 0168988..e8417f1 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreLatestTreeShakeJarVerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreLatestTreeShakeJarVerificationTest.java
@@ -22,7 +22,7 @@
public void buildAndTreeShakeFromDeployJar() throws Exception {
List<String> additionalProguardConfiguration =
ImmutableList.of(
- ToolHelper.PROGUARD_SETTINGS_FOR_INTERNAL_APPS + "/GmsCore_proguard.config");
+ ToolHelper.PROGUARD_SETTINGS_FOR_INTERNAL_APPS + "GmsCore_proguard.config");
AndroidApp app1 =
buildAndTreeShakeFromDeployJar(
CompilationMode.RELEASE,
diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java b/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
index 4ffbe2b..92b7c68 100644
--- a/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
@@ -28,13 +28,13 @@
this.base = "third_party/youtube/youtube.android_" + majorVersion + "." + minorVersion + "/";
}
- public List<Path> getKeepRuleFiles() {
+ protected List<Path> getKeepRuleFiles() {
return ImmutableList.of(
Paths.get(base).resolve(PG_CONF),
Paths.get(ToolHelper.PROGUARD_SETTINGS_FOR_INTERNAL_APPS).resolve(PG_CONF));
}
- public List<Path> getProgramFiles() throws IOException {
+ protected List<Path> getProgramFiles() throws IOException {
List<Path> result = new ArrayList<>();
for (Path keepRuleFile : getKeepRuleFiles()) {
for (String line : FileUtils.readAllLines(keepRuleFile)) {
@@ -47,12 +47,12 @@
return result;
}
- public Path getReleaseApk() {
+ Path getReleaseApk() {
return Paths.get(base).resolve("YouTubeRelease.apk");
}
- public Path getReleaseProguardMap() {
- return Paths.get(base).resolve("YouTubeRelease_proguard.map");
+ Path getReleaseProguardMap() {
+ return Paths.get(base).resolve(PG_MAP);
}
void runR8AndCheckVerification(CompilationMode mode, String input) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
new file mode 100644
index 0000000..7813a2d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCanBePostponedTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2019, 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.sideeffect;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingletonClassInitializerPatternCanBePostponedTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public SingletonClassInitializerPatternCanBePostponedTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(SingletonClassInitializerPatternCanBePostponedTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(A.class);
+ assertThat(classSubject, isPresent());
+
+ // A.inlineable() should be inlined because we should be able to determine that A.<clinit>() can
+ // safely be postponed.
+ assertThat(classSubject.uniqueMethodWithName("inlineable"), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ A.inlineable();
+ System.out.println(A.getInstance().getMessage());
+ }
+ }
+
+ static class A {
+
+ static A INSTANCE = new A(" world!");
+
+ final String message;
+
+ A(String message) {
+ this.message = message;
+ }
+
+ static void inlineable() {
+ System.out.print("Hello");
+ }
+
+ static A getInstance() {
+ return INSTANCE;
+ }
+
+ String getMessage() {
+ return message;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
new file mode 100644
index 0000000..d29753b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/analysis/sideeffect/SingletonClassInitializerPatternCannotBePostponedTest.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2019, 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.sideeffect;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingletonClassInitializerPatternCannotBePostponedTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public SingletonClassInitializerPatternCannotBePostponedTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(SingletonClassInitializerPatternCannotBePostponedTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(A.class);
+ assertThat(classSubject, isPresent());
+
+ // A.inlineable() cannot be inlined because it should trigger the class initialization of A,
+ // which should trigger the class initialization of B, which will print "Hello".
+ assertThat(classSubject.uniqueMethodWithName("inlineable"), isPresent());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ A.inlineable();
+ System.out.println(A.getInstance().getMessage());
+ }
+ }
+
+ static class A {
+
+ static B INSTANCE = new B("world!");
+
+ static void inlineable() {
+ System.out.print(" ");
+ }
+
+ static B getInstance() {
+ return INSTANCE;
+ }
+ }
+
+ static class B {
+
+ static {
+ System.out.print("Hello");
+ }
+
+ final String message;
+
+ B(String message) {
+ this.message = message;
+ }
+
+ String getMessage() {
+ return message;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/CallGraphTestBase.java b/src/test/java/com/android/tools/r8/ir/conversion/CallGraphTestBase.java
new file mode 100644
index 0000000..b567014
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/conversion/CallGraphTestBase.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2019, 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.conversion;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.ir.conversion.CallGraph.Node;
+
+class CallGraphTestBase extends TestBase {
+ private DexItemFactory dexItemFactory = new DexItemFactory();
+
+ Node createNode(String methodName) {
+ DexMethod signature =
+ dexItemFactory.createMethod(
+ dexItemFactory.objectType,
+ dexItemFactory.createProto(dexItemFactory.voidType),
+ methodName);
+ return new Node(
+ new DexEncodedMethod(signature, null, null, ParameterAnnotationsList.empty(), null));
+ }
+
+ Node createForceInlinedNode(String methodName) {
+ Node node = createNode(methodName);
+ node.method.getMutableOptimizationInfo().markForceInline();
+ return node;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/callgraph/CycleEliminationTest.java b/src/test/java/com/android/tools/r8/ir/conversion/CycleEliminationTest.java
similarity index 87%
rename from src/test/java/com/android/tools/r8/ir/callgraph/CycleEliminationTest.java
rename to src/test/java/com/android/tools/r8/ir/conversion/CycleEliminationTest.java
index f767bf2..f38629f 100644
--- a/src/test/java/com/android/tools/r8/ir/callgraph/CycleEliminationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/CycleEliminationTest.java
@@ -2,7 +2,7 @@
// 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.callgraph;
+package com.android.tools.r8.ir.conversion;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -11,14 +11,9 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.android.tools.r8.TestBase;
import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.ir.conversion.CallGraph.Node;
-import com.android.tools.r8.ir.conversion.CallGraphBuilder.CycleEliminator;
+import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
@@ -29,7 +24,7 @@
import java.util.function.BooleanSupplier;
import org.junit.Test;
-public class CycleEliminationTest extends TestBase {
+public class CycleEliminationTest extends CallGraphTestBase {
private static class Configuration {
@@ -44,8 +39,6 @@
}
}
- private DexItemFactory dexItemFactory = new DexItemFactory();
-
@Test
public void testSimpleCycle() {
Node method = createNode("n1");
@@ -197,20 +190,4 @@
}
}
}
-
- private Node createNode(String methodName) {
- DexMethod signature =
- dexItemFactory.createMethod(
- dexItemFactory.objectType,
- dexItemFactory.createProto(dexItemFactory.voidType),
- methodName);
- return new Node(
- new DexEncodedMethod(signature, null, null, ParameterAnnotationsList.empty(), null));
- }
-
- private Node createForceInlinedNode(String methodName) {
- Node node = createNode(methodName);
- node.method.getMutableOptimizationInfo().markForceInline();
- return node;
- }
}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java b/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java
new file mode 100644
index 0000000..2cde812
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java
@@ -0,0 +1,223 @@
+// Copyright (c) 2019, 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.conversion;
+
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ir.conversion.CallGraph.Node;
+import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.Sets;
+import java.util.Set;
+import java.util.TreeSet;
+import org.junit.Test;
+
+public class NodeExtractionTest extends CallGraphTestBase {
+
+ private InternalOptions options = new InternalOptions();
+
+ // Note that building a test graph is intentionally repeated to avoid race conditions and/or
+ // non-deterministic test results due to cycle elimination.
+
+ @Test
+ public void testExtractLeaves_withoutCycle() {
+ Node n1, n2, n3, n4, n5, n6;
+ Set<Node> nodes;
+
+ n1 = createNode("n1");
+ n2 = createNode("n2");
+ n3 = createNode("n3");
+ n4 = createNode("n4");
+ n5 = createNode("n5");
+ n6 = createNode("n6");
+
+ n2.addCallerConcurrently(n1);
+ n3.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n5);
+ n6.addCallerConcurrently(n5);
+
+ nodes = new TreeSet<>();
+ nodes.add(n1);
+ nodes.add(n2);
+ nodes.add(n3);
+ nodes.add(n4);
+ nodes.add(n5);
+ nodes.add(n6);
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(3, wave.size());
+ assertThat(wave, hasItem(n3));
+ assertThat(wave, hasItem(n4));
+ assertThat(wave, hasItem(n6));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n2));
+ assertThat(wave, hasItem(n5));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(1, wave.size());
+ assertThat(wave, hasItem(n1));
+ assertTrue(nodes.isEmpty());
+ }
+
+ @Test
+ public void testExtractLeaves_withCycle() {
+ Node n1, n2, n3, n4, n5, n6;
+ Set<Node> nodes;
+
+ n1 = createNode("n1");
+ n2 = createNode("n2");
+ n3 = createNode("n3");
+ n4 = createNode("n4");
+ n5 = createNode("n5");
+ n6 = createNode("n6");
+
+ n2.addCallerConcurrently(n1);
+ n3.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n5);
+ n6.addCallerConcurrently(n5);
+
+ nodes = new TreeSet<>();
+ nodes.add(n1);
+ nodes.add(n2);
+ nodes.add(n3);
+ nodes.add(n4);
+ nodes.add(n5);
+ nodes.add(n6);
+
+ n1.addCallerConcurrently(n3);
+ n3.method.getMutableOptimizationInfo().markForceInline();
+ CycleEliminator cycleEliminator = new CycleEliminator(nodes, options);
+ assertEquals(1, cycleEliminator.breakCycles().numberOfRemovedEdges());
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(3, wave.size());
+ assertThat(wave, hasItem(n3));
+ assertThat(wave, hasItem(n4));
+ assertThat(wave, hasItem(n6));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n2));
+ assertThat(wave, hasItem(n5));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(nodes, wave::add);
+ assertEquals(1, wave.size());
+ assertThat(wave, hasItem(n1));
+ assertTrue(nodes.isEmpty());
+ }
+
+ @Test
+ public void testExtractRoots_withoutCycle() {
+ Node n1, n2, n3, n4, n5, n6;
+ Set<Node> nodes;
+
+ n1 = createNode("n1");
+ n2 = createNode("n2");
+ n3 = createNode("n3");
+ n4 = createNode("n4");
+ n5 = createNode("n5");
+ n6 = createNode("n6");
+
+ n2.addCallerConcurrently(n1);
+ n3.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n5);
+ n6.addCallerConcurrently(n5);
+
+ nodes = new TreeSet<>();
+ nodes.add(n1);
+ nodes.add(n2);
+ nodes.add(n3);
+ nodes.add(n4);
+ nodes.add(n5);
+ nodes.add(n6);
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n1));
+ assertThat(wave, hasItem(n5));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n2));
+ assertThat(wave, hasItem(n6));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n3));
+ assertThat(wave, hasItem(n4));
+ assertTrue(nodes.isEmpty());
+ }
+
+ @Test
+ public void testExtractRoots_withCycle() {
+ Node n1, n2, n3, n4, n5, n6;
+ Set<Node> nodes;
+
+ n1 = createNode("n1");
+ n2 = createNode("n2");
+ n3 = createNode("n3");
+ n4 = createNode("n4");
+ n5 = createNode("n5");
+ n6 = createNode("n6");
+
+ n2.addCallerConcurrently(n1);
+ n3.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n2);
+ n4.addCallerConcurrently(n5);
+ n6.addCallerConcurrently(n5);
+
+ nodes = new TreeSet<>();
+ nodes.add(n1);
+ nodes.add(n2);
+ nodes.add(n3);
+ nodes.add(n4);
+ nodes.add(n5);
+ nodes.add(n6);
+
+ n1.addCallerConcurrently(n3);
+ n3.method.getMutableOptimizationInfo().markForceInline();
+ CycleEliminator cycleEliminator = new CycleEliminator(nodes, options);
+ assertEquals(1, cycleEliminator.breakCycles().numberOfRemovedEdges());
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n1));
+ assertThat(wave, hasItem(n5));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n2));
+ assertThat(wave, hasItem(n6));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(n3));
+ assertThat(wave, hasItem(n4));
+ assertTrue(nodes.isEmpty());
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
new file mode 100644
index 0000000..769515c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
@@ -0,0 +1,198 @@
+// Copyright (c) 2019, 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.conversion;
+
+import static com.android.tools.r8.shaking.ProguardConfigurationSourceStrings.createConfigurationForTesting;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppServices;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.conversion.CallGraph.Node;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.Enqueuer;
+import com.android.tools.r8.shaking.EnqueuerFactory;
+import com.android.tools.r8.shaking.ProguardConfigurationParser;
+import com.android.tools.r8.shaking.RootSetBuilder;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import org.junit.Test;
+
+public class PartialCallGraphTest extends CallGraphTestBase {
+ private final AppView<AppInfoWithLiveness> appView;
+ private final InternalOptions options = new InternalOptions();
+ private final ExecutorService executorService = ThreadUtils.getExecutorService(options);
+
+ public PartialCallGraphTest() throws Exception {
+ Timing timing = new Timing("PartialCallGraphTest.setup");
+ AndroidApp app = testForD8().addProgramClasses(TestClass.class).compile().app;
+ DexApplication application = new ApplicationReader(app, options, timing).read().toDirect();
+ AppView<AppInfoWithSubtyping> appView =
+ AppView.createForR8(new AppInfoWithSubtyping(application), options);
+ appView.setAppServices(AppServices.builder(appView).build());
+ ProguardConfigurationParser parser =
+ new ProguardConfigurationParser(appView.dexItemFactory(), options.reporter);
+ parser.parse(
+ createConfigurationForTesting(
+ ImmutableList.of("-keep class ** { void m1(); void m5(); }")));
+ appView.setRootSet(
+ new RootSetBuilder(
+ appView, application, parser.getConfig().getRules()).run(executorService));
+ Enqueuer enqueuer = EnqueuerFactory.createForInitialTreeShaking(appView);
+ this.appView =
+ appView.setAppInfo(
+ enqueuer.traceApplication(
+ appView.rootSet(),
+ parser.getConfig().getDontWarnPatterns(),
+ executorService,
+ timing));
+ }
+
+ @Test
+ public void testFullGraph() throws Exception {
+ CallGraph cg =
+ new CallGraphBuilder(appView).build(executorService, new Timing("testFullGraph"));
+ Node m1 = findNode(cg.nodes, "m1");
+ Node m2 = findNode(cg.nodes, "m2");
+ Node m3 = findNode(cg.nodes, "m3");
+ Node m4 = findNode(cg.nodes, "m4");
+ Node m5 = findNode(cg.nodes, "m5");
+ Node m6 = findNode(cg.nodes, "m6");
+ assertNotNull(m1);
+ assertNotNull(m2);
+ assertNotNull(m3);
+ assertNotNull(m4);
+ assertNotNull(m5);
+ assertNotNull(m6);
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ MethodProcessor.extractLeaves(cg.nodes, wave::add);
+ assertEquals(4, wave.size()); // including <init>
+ assertThat(wave, hasItem(m3));
+ assertThat(wave, hasItem(m4));
+ assertThat(wave, hasItem(m6));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(cg.nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(m2));
+ assertThat(wave, hasItem(m5));
+ wave.clear();
+
+ MethodProcessor.extractLeaves(cg.nodes, wave::add);
+ assertEquals(1, wave.size());
+ assertThat(wave, hasItem(m1));
+ assertTrue(cg.nodes.isEmpty());
+ }
+
+ @Test
+ public void testPartialGraph() throws Exception {
+ DexEncodedMethod em1 = findMethod("m1");
+ DexEncodedMethod em2 = findMethod("m2");
+ DexEncodedMethod em4 = findMethod("m4");
+ DexEncodedMethod em5 = findMethod("m5");
+ assertNotNull(em1);
+ assertNotNull(em2);
+ assertNotNull(em4);
+ assertNotNull(em5);
+
+ CallGraph pg =
+ new PartialCallGraphBuilder(appView, ImmutableSet.of(em1, em2, em4, em5))
+ .build(executorService, new Timing("tetPartialGraph"));
+
+ Node m1 = findNode(pg.nodes, "m1");
+ Node m2 = findNode(pg.nodes, "m2");
+ Node m4 = findNode(pg.nodes, "m4");
+ Node m5 = findNode(pg.nodes, "m5");
+ assertNotNull(m1);
+ assertNotNull(m2);
+ assertNotNull(m4);
+ assertNotNull(m5);
+
+ Set<Node> wave = Sets.newIdentityHashSet();
+
+ PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ assertEquals(2, wave.size());
+ assertThat(wave, hasItem(m1));
+ assertThat(wave, hasItem(m5));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ assertEquals(1, wave.size());
+ assertThat(wave, hasItem(m2));
+ wave.clear();
+
+ PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ assertEquals(1, wave.size());
+ assertThat(wave, hasItem(m4));
+ assertTrue(pg.nodes.isEmpty());
+ }
+
+ private Node findNode(Iterable<Node> nodes, String name) {
+ for (Node n : nodes) {
+ if (n.method.method.name.toString().equals(name)) {
+ return n;
+ }
+ }
+ return null;
+ }
+
+ private DexEncodedMethod findMethod(String name) {
+ for (DexClass clazz : appView.appInfo().classes()) {
+ for (DexEncodedMethod method : clazz.methods()) {
+ if (method.method.name.toString().equals(name)) {
+ return method;
+ }
+ }
+ }
+ return null;
+ }
+
+ static class TestClass {
+ void m1() {
+ System.out.println("m1");
+ m2();
+ }
+
+ void m2() {
+ System.out.println("m2");
+ m3();
+ m4();
+ }
+
+ void m3() {
+ System.out.println("m3");
+ }
+
+ void m4() {
+ System.out.println("m4");
+ }
+
+ void m5() {
+ System.out.println("m5");
+ m6();
+ m4();
+ }
+
+ void m6() {
+ System.out.println("m6");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index 86245a3..5e0e77f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -121,6 +121,9 @@
o.enableInlining = inlining;
o.enableInliningOfInvokesWithNullableReceivers = false;
o.inliningInstructionLimit = 6;
+ // Tests depend on nullability of receiver and argument in general. Learning very accurate
+ // nullability from actual usage in tests bothers what we want to test.
+ o.enableCallSiteOptimizationInfoPropagation = false;
});
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
new file mode 100644
index 0000000..a1577a3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/TrivialTypeTestsAfterBranchPruningTest.java
@@ -0,0 +1,103 @@
+// Copyright (c) 2019, 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.optimize.checkcast;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class TrivialTypeTestsAfterBranchPruningTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public TrivialTypeTestsAfterBranchPruningTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(TrivialTypeTestsAfterBranchPruningTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(TestClass.class);
+ assertThat(classSubject, isPresent());
+ assertThat(classSubject.uniqueMethodWithName("dead"), not(isPresent()));
+
+ MethodSubject trivialCastMethodSubject =
+ classSubject.uniqueMethodWithName("trivialCastAfterBranchPruningTest");
+ assertThat(trivialCastMethodSubject, isPresent());
+ assertTrue(
+ trivialCastMethodSubject.streamInstructions().noneMatch(InstructionSubject::isCheckCast));
+
+ MethodSubject branchPruningMethodSubject =
+ classSubject.uniqueMethodWithName("branchPruningAfterInstanceOfOptimization");
+ assertThat(branchPruningMethodSubject, isPresent());
+ assertTrue(
+ branchPruningMethodSubject
+ .streamInstructions()
+ .noneMatch(InstructionSubject::isInstanceOf));
+ }
+
+ static class TestClass {
+
+ static boolean alwaysTrue = true;
+
+ public static void main(String[] args) {
+ branchPruningAfterInstanceOfOptimization(trivialCastAfterBranchPruningTest());
+ }
+
+ @NeverInline
+ static A trivialCastAfterBranchPruningTest() {
+ return (A) (alwaysTrue ? new A() : new B());
+ }
+
+ @NeverInline
+ static void branchPruningAfterInstanceOfOptimization(A obj) {
+ if (obj instanceof A) {
+ System.out.println("Hello world!");
+ } else {
+ dead();
+ }
+ }
+
+ @NeverInline
+ static void dead() {
+ throw new RuntimeException();
+ }
+ }
+
+ static class A {}
+
+ static class B {}
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index fbcc6a1..afdfabb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -64,7 +64,8 @@
@RunWith(Parameterized.class)
public class ClassInlinerTest extends TestBase {
- private Backend backend;
+
+ private final Backend backend;
@Parameterized.Parameters(name = "Backend: {0}")
public static Backend[] data() {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapingBuilderTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapingBuilderTest.java
index 4dd3551..bf5e92a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapingBuilderTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/EscapingBuilderTest.java
@@ -74,7 +74,11 @@
}
@NeverInline
- public static void escape(Object o) {}
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
+ }
}
// Simple builder that should be class inlined.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ifs/EnumComparisonTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ifs/EnumComparisonTest.java
new file mode 100644
index 0000000..94d775b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ifs/EnumComparisonTest.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2019, 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.optimize.ifs;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class EnumComparisonTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public EnumComparisonTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(EnumComparisonTest.class)
+ .addKeepMainRule(TestClass.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("MyEnum.A == MyEnum.A", "MyEnum.A != MyEnum.B");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(TestClass.class);
+ assertThat(classSubject, isPresent());
+
+ MethodSubject mainMethodSubject = classSubject.mainMethod();
+ assertThat(mainMethodSubject, isPresent());
+ assertTrue(mainMethodSubject.streamInstructions().noneMatch(InstructionSubject::isThrow));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ if (MyEnum.A == MyEnum.A) {
+ System.out.println("MyEnum.A == MyEnum.A");
+ } else {
+ throw new RuntimeException();
+ }
+ if (MyEnum.A == MyEnum.B) {
+ throw new RuntimeException();
+ } else {
+ System.out.println("MyEnum.A != MyEnum.B");
+ }
+ }
+ }
+
+ enum MyEnum {
+ A,
+ B
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
index e8308f7..5f1b7a5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
@@ -4,19 +4,19 @@
package com.android.tools.r8.ir.optimize.inliner;
-import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
+import com.android.tools.r8.AlwaysInline;
import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -25,14 +25,17 @@
@RunWith(Parameterized.class)
public class SingleTargetAfterInliningTest extends TestBase {
+ private final int maxInliningDepth;
private final TestParameters parameters;
- @Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ @Parameters(name = "{1}, max inlining depth: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ ImmutableList.of(0, 1), getTestParameters().withAllRuntimesAndApiLevels().build());
}
- public SingleTargetAfterInliningTest(TestParameters parameters) {
+ public SingleTargetAfterInliningTest(int maxInliningDepth, TestParameters parameters) {
+ this.maxInliningDepth = maxInliningDepth;
this.parameters = parameters;
}
@@ -41,31 +44,41 @@
testForR8(parameters.getBackend())
.addInnerClasses(SingleTargetAfterInliningTest.class)
.addKeepMainRule(TestClass.class)
+ .addOptionsModification(
+ options -> {
+ options.applyInliningToInlinee = true;
+ options.applyInliningToInlineeMaxDepth = maxInliningDepth;
+ })
+ .enableAlwaysInliningAnnotations()
.enableClassInliningAnnotations()
.enableSideEffectAnnotations()
- .setMinApi(parameters.getRuntime())
- .noMinification()
+ .setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::inspect)
.run(parameters.getRuntime(), TestClass.class)
- .assertSuccessWithOutputLines("B");
+ .assertSuccessWithOutputLines("B.foo()", "B.bar()");
}
private void inspect(CodeInspector inspector) {
- ClassSubject aClassSubject = inspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
-
ClassSubject testClassSubject = inspector.clazz(TestClass.class);
assertThat(testClassSubject, isPresent());
// The indirection() method should be inlined.
assertThat(testClassSubject.uniqueMethodWithName("indirection"), not(isPresent()));
- // The main() method invokes A.method().
- // TODO(b/141451716): A.method() should be inlined into main().
- MethodSubject mainMethodSubject = testClassSubject.mainMethod();
- assertThat(mainMethodSubject, isPresent());
- assertThat(mainMethodSubject, invokesMethod(aClassSubject.uniqueMethodWithName("method")));
+ // A.foo() should be absent if the max inlining depth is 1, because indirection() has been
+ // inlined into main(), which makes A.foo() eligible for inlining into main().
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ if (maxInliningDepth == 0) {
+ assertThat(aClassSubject.uniqueMethodWithName("foo"), isPresent());
+ } else {
+ assert maxInliningDepth == 1;
+ assertThat(aClassSubject.uniqueMethodWithName("foo"), not(isPresent()));
+ }
+
+ // A.bar() should always be inlined because it is marked as @AlwaysInline.
+ assertThat(aClassSubject.uniqueMethodWithName("bar"), not(isPresent()));
}
static class TestClass {
@@ -78,13 +91,16 @@
}
private static void indirection(A obj) {
- obj.method();
+ obj.foo();
+ obj.bar();
}
}
abstract static class A {
- abstract void method();
+ abstract void foo();
+
+ abstract void bar();
}
@NeverClassInline
@@ -94,8 +110,14 @@
B() {}
@Override
- void method() {
- System.out.println("B");
+ void foo() {
+ System.out.println("B.foo()");
+ }
+
+ @AlwaysInline
+ @Override
+ void bar() {
+ System.out.println("B.bar()");
}
}
@@ -106,8 +128,13 @@
C() {}
@Override
- void method() {
- System.out.println("C");
+ void foo() {
+ System.out.println("C.foo()");
+ }
+
+ @Override
+ void bar() {
+ System.out.println("C.bar()");
}
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
index b0828fe..f0c6a78 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
@@ -167,6 +167,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(classes)
.enableInliningAnnotations()
+ .enableSideEffectAnnotations()
.addKeepMainRule(main)
.allowAccessModification()
.noMinification()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/movetohost/MoveToHostFieldOnlyTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/movetohost/MoveToHostFieldOnlyTestClass.java
index f725d21..eb8e6a4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/movetohost/MoveToHostFieldOnlyTestClass.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/movetohost/MoveToHostFieldOnlyTestClass.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize.staticizer.movetohost;
+import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverInline;
public class MoveToHostFieldOnlyTestClass {
@@ -12,6 +13,7 @@
test.testOk_fieldOnly();
}
+ @AssumeMayHaveSideEffects
@NeverInline
private void testOk_fieldOnly() {
// Any instance method call whose target holder is not the candidate will invalidate candidacy,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java
new file mode 100644
index 0000000..d2fa3f8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceRemovalTest.java
@@ -0,0 +1,119 @@
+// Copyright (c) 2019, 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.optimize.unusedinterfaces;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class UnusedInterfaceRemovalTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public UnusedInterfaceRemovalTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(UnusedInterfaceRemovalTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("A.foo()", "A.bar()");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject iClassSubject = inspector.clazz(I.class);
+ assertThat(iClassSubject, isPresent());
+
+ ClassSubject jClassSubject = inspector.clazz(J.class);
+ assertThat(jClassSubject, isPresent());
+
+ ClassSubject kClassSubject = inspector.clazz(K.class);
+ assertThat(kClassSubject, not(isPresent()));
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ assertEquals(2, aClassSubject.getDexClass().interfaces.size());
+ assertEquals(
+ aClassSubject.getDexClass().interfaces.values[0], iClassSubject.getDexClass().type);
+ assertEquals(
+ aClassSubject.getDexClass().interfaces.values[1], jClassSubject.getDexClass().type);
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ I obj = System.currentTimeMillis() >= 0 ? new A() : new B();
+ obj.foo();
+ ((J) obj).bar();
+ }
+ }
+
+ @NeverMerge
+ interface I {
+
+ void foo();
+ }
+
+ @NeverMerge
+ interface J {
+
+ void bar();
+ }
+
+ interface K extends I, J {}
+
+ static class A implements K {
+
+ @Override
+ public void foo() {
+ System.out.println("A.foo()");
+ }
+
+ @Override
+ public void bar() {
+ System.out.println("A.bar()");
+ }
+ }
+
+ // To prevent that we detect a single target and start inlining or rewriting the signature in the
+ // invoke.
+ static class B implements K {
+
+ @Override
+ public void foo() {
+ throw new RuntimeException();
+ }
+
+ @Override
+ public void bar() {
+ throw new RuntimeException();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java
new file mode 100644
index 0000000..90761db
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedinterfaces/UnusedInterfaceWithDefaultMethodTest.java
@@ -0,0 +1,97 @@
+// Copyright (c) 2019, 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.optimize.unusedinterfaces;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class UnusedInterfaceWithDefaultMethodTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public UnusedInterfaceWithDefaultMethodTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(UnusedInterfaceWithDefaultMethodTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("J.m()");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject iClassSubject = inspector.clazz(I.class);
+ assertThat(iClassSubject, isPresent());
+
+ ClassSubject jClassSubject = inspector.clazz(J.class);
+ assertThat(jClassSubject, isPresent());
+
+ ClassSubject aClassSubject = inspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+
+ // Verify that J is not considered an unused interface, since it provides an implementation of
+ // m() that happens to be used.
+ assertEquals(1, aClassSubject.getDexClass().interfaces.size());
+ assertEquals(
+ jClassSubject.getDexClass().type, aClassSubject.getDexClass().interfaces.values[0]);
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ indirection(new A());
+ }
+
+ @NeverInline
+ private static void indirection(I obj) {
+ obj.m();
+ }
+ }
+
+ @NeverMerge
+ interface I {
+
+ void m();
+ }
+
+ @NeverMerge
+ interface J extends I {
+
+ @NeverInline
+ @Override
+ default void m() {
+ System.out.println("J.m()");
+ }
+ }
+
+ static class A implements J {}
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index f0a8a84..cfeb611 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -291,30 +291,18 @@
@Test
public void testAccessor() throws Exception {
TestKotlinCompanionClass testedClass = ACCESSOR_COMPANION_PROPERTY_CLASS;
- String mainClass = addMainToClasspath("accessors.AccessorKt",
- "accessor_accessPropertyFromCompanionClass");
+ String mainClass =
+ addMainToClasspath("accessors.AccessorKt", "accessor_accessPropertyFromCompanionClass");
runTest(
"accessors",
mainClass,
disableClassStaticizer,
- (app) -> {
+ app -> {
+ // The classes are removed entirely as a result of member value propagation, inlining, and
+ // the fact that the classes do not have observable side effects.
CodeInspector codeInspector = new CodeInspector(app);
- ClassSubject outerClass =
- checkClassIsKept(codeInspector, testedClass.getOuterClassName());
- ClassSubject companionClass = checkClassIsKept(codeInspector, testedClass.getClassName());
-
- // Property field has been removed due to member value propagation.
- String propertyName = "property";
- checkFieldIsRemoved(outerClass, JAVA_LANG_STRING, propertyName);
-
- // The getter is always inlined since it just calls into the accessor.
- MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
- checkMethodIsAbsent(companionClass, getter);
-
- // The accessor is also inlined.
- MemberNaming.MethodSignature getterAccessor =
- testedClass.getGetterAccessorForProperty(propertyName, AccessorKind.FROM_COMPANION);
- checkMethodIsRemoved(outerClass, getterAccessor);
+ checkClassIsRemoved(codeInspector, testedClass.getOuterClassName());
+ checkClassIsRemoved(codeInspector, testedClass.getClassName());
});
}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java
new file mode 100644
index 0000000..cb4bed0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceClInitTest.java
@@ -0,0 +1,104 @@
+// Copyright (c) 2019, 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.naming.applymapping;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApplyMappingInterfaceClInitTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ApplyMappingInterfaceClInitTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ @Ignore("b/142909857")
+ public void testNotRenamingClInitIfNotInMap()
+ throws ExecutionException, CompilationFailedException, IOException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ApplyMappingInterfaceClInitTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepClassAndMembersRules(TestInterface.class)
+ .addApplyMapping("")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .inspect(this::verifyNoRenamingOfClInit);
+ }
+
+ @Test
+ @Ignore("b/142909857")
+ public void testNotRenamingClInitIfInMap()
+ throws ExecutionException, CompilationFailedException, IOException {
+ String interfaceName = TestInterface.class.getTypeName();
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ApplyMappingInterfaceClInitTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepClassAndMembersRules(TestInterface.class)
+ .addApplyMapping(
+ StringUtils.lines(
+ interfaceName + " -> " + interfaceName + ":", " void <clinit>() -> a"))
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .inspect(this::verifyNoRenamingOfClInit);
+ }
+
+ private void verifyNoRenamingOfClInit(CodeInspector inspector) {
+ ClassSubject interfaceSubject = inspector.clazz(TestInterface.class);
+ assertThat(interfaceSubject, isPresent());
+ interfaceSubject.allMethods().stream()
+ .allMatch(
+ method -> {
+ boolean classInitNotRenamed = !method.isClassInitializer() || !method.isRenamed();
+ assertTrue(classInitNotRenamed);
+ return classInitNotRenamed;
+ });
+ }
+
+ public interface TestInterface {
+ Throwable t = new Throwable();
+
+ void foo();
+ }
+
+ @NeverClassInline
+ public static class Main implements TestInterface {
+
+ public static void main(String[] args) {
+ new Main().foo();
+ }
+
+ @Override
+ @NeverInline
+ public void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java
new file mode 100644
index 0000000..484fb10
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/AnnotationShakingBehaviorTest.java
@@ -0,0 +1,159 @@
+// 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.shaking.annotations;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AnnotationShakingBehaviorTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public AnnotationShakingBehaviorTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testKeepUnusedTypeInAnnotation()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Factory.class, Main.class, C.class)
+ .addKeepMainRule(Main.class)
+ .addKeepClassAndMembersRules(Factory.class)
+ .addKeepAttributes("*Annotation*")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(inspector -> assertThat(inspector.clazz(C.class), isPresent()));
+ }
+
+ @Test
+ public void testWillKeepAnnotatedProgramClass()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Factory.class, MainWithMethodAnnotation.class, C.class)
+ .addKeepMainRule(MainWithMethodAnnotation.class)
+ .addKeepClassAndMembersRules(Factory.class)
+ .addKeepAttributes("*Annotation*")
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MainWithMethodAnnotation.class)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(inspector -> assertThat(inspector.clazz(C.class), isPresent()));
+ }
+
+ @Test
+ public void testGenericSignatureDoNotKeepType()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(MainWithGenericC.class, C.class)
+ .addKeepMainRule(MainWithGenericC.class)
+ .addKeepAttributes("Signature", "InnerClasses", "EnclosingMethod")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MainWithGenericC.class)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(
+ inspector -> {
+ assertThat(inspector.clazz(C.class), not(isPresent()));
+ });
+ }
+
+ @Test
+ public void testDisappearsWhenMerging()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Factory.class, MainWithNewB.class, A.class, B.class, C.class)
+ .addKeepMainRule(MainWithNewB.class)
+ .addKeepClassAndMembersRules(Factory.class)
+ .addKeepAttributes("*Annotation*")
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), MainWithNewB.class)
+ .assertSuccessWithOutputLines("Hello World!")
+ .inspect(
+ inspector -> {
+ assertThat(inspector.clazz(C.class), not(isPresent()));
+ });
+ }
+
+ @Retention(value = RetentionPolicy.RUNTIME)
+ public @interface Factory {
+ Class<?> ref() default Object.class;
+ }
+
+ public static class C {}
+
+ @Factory(ref = C.class) // <-- we are explicitly keeping Main.
+ public static class Main {
+
+ public static void main(String[] args) {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class MainWithMethodAnnotation {
+
+ public static void main(String[] args) {
+ test();
+ }
+
+ @Factory(ref = C.class) // <-- We are not explicitly saying that test() should be kept.
+ @NeverInline
+ public static void test() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class MainWithGenericC {
+
+ static List<C> cs = new ArrayList<>();
+
+ public static void main(String[] args) {
+ if (cs.size() == args.length) {
+ System.out.println("Hello World!");
+ }
+ }
+ }
+
+ @Factory(ref = C.class)
+ public static class A {}
+
+ @NeverClassInline
+ public static class B extends A {
+ @NeverInline
+ public void world() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class MainWithNewB {
+
+ public static void main(String[] args) {
+ new B().world();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
new file mode 100644
index 0000000..4e6adad
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
@@ -0,0 +1,181 @@
+// Copyright (c) 2019, 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.shaking.annotations;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.BaseCompilerCommand;
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.function.Function;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class LibraryAndMissingAnnotationsTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final boolean includeOnLibraryPath;
+
+ @Parameters(name = "{0}, includeOnLibraryPath: {1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+ }
+
+ private static Function<TestParameters, Path> compilationResults =
+ memoizeFunction(LibraryAndMissingAnnotationsTest::compileLibraryAnnotationToRuntime);
+
+ private static Path compileLibraryAnnotationToRuntime(TestParameters parameters)
+ throws CompilationFailedException, IOException {
+ return testForR8(getStaticTemp(), parameters.getBackend())
+ .addProgramClasses(LibraryAnnotation.class)
+ .addKeepClassAndMembersRulesWithAllowObfuscation(LibraryAnnotation.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .writeToZip();
+ }
+
+ public LibraryAndMissingAnnotationsTest(TestParameters parameters, boolean includeOnLibraryPath) {
+ this.parameters = parameters;
+ this.includeOnLibraryPath = includeOnLibraryPath;
+ }
+
+ @Test
+ public void testMainWithUseR8() throws Exception {
+ runTest(testForR8(parameters.getBackend()), MainWithUse.class);
+ }
+
+ @Test
+ public void testMainWithUseR8Compat() throws Exception {
+ runTest(testForR8Compat(parameters.getBackend()), MainWithUse.class);
+ }
+
+ @Test
+ public void testMainWithUseProguard() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ runTest(testForProguard(), MainWithUse.class);
+ }
+
+ @Test
+ public void testMainWithoutUseR8() throws Exception {
+ runTest(testForR8(parameters.getBackend()), MainWithoutUse.class);
+ }
+
+ @Test
+ public void testMainWithoutUseR8Compat() throws Exception {
+ runTest(testForR8Compat(parameters.getBackend()), MainWithoutUse.class);
+ }
+
+ @Test
+ public void testMainWithoutUseProguard() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+ runTest(testForProguard(), MainWithoutUse.class);
+ }
+
+ private <
+ C extends BaseCompilerCommand,
+ B extends BaseCompilerCommand.Builder<C, B>,
+ CR extends TestCompileResult<CR, RR>,
+ RR extends TestRunResult<RR>,
+ T extends TestShrinkerBuilder<C, B, CR, RR, T>>
+ void runTest(TestShrinkerBuilder<C, B, CR, RR, T> builder, Class<?> mainClass)
+ throws Exception {
+ T t =
+ builder
+ .addProgramClasses(Foo.class, mainClass)
+ .addKeepAttributes("*Annotation*")
+ .addLibraryFiles(runtimeJar(parameters))
+ .addKeepClassAndMembersRules(Foo.class)
+ .addKeepRules("-dontwarn " + LibraryAndMissingAnnotationsTest.class.getTypeName())
+ .addKeepMainRule(mainClass)
+ .setMinApi(parameters.getApiLevel());
+ if (includeOnLibraryPath) {
+ t.addLibraryClasses(LibraryAnnotation.class);
+ } else {
+ t.addKeepRules("-dontwarn " + LibraryAnnotation.class.getTypeName());
+ }
+ t.compile()
+ .addRunClasspathFiles(compilationResults.apply(parameters))
+ .run(parameters.getRuntime(), mainClass)
+ .inspect(
+ inspector -> {
+ ClassSubject clazz = inspector.clazz(Foo.class);
+ assertThat(clazz, isPresent());
+ assertThat(clazz.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
+ MethodSubject foo = clazz.uniqueMethodWithName("foo");
+ assertThat(foo, isPresent());
+ assertThat(foo.annotation(LibraryAnnotation.class.getTypeName()), isPresent());
+ assertFalse(foo.getMethod().parameterAnnotationsList.isEmpty());
+ assertEquals(
+ LibraryAnnotation.class.getTypeName(),
+ foo.getMethod()
+ .parameterAnnotationsList
+ .get(0)
+ .annotations[0]
+ .getAnnotationType()
+ .toSourceString());
+ assertThat(
+ clazz
+ .uniqueFieldWithName("bar")
+ .annotation(LibraryAnnotation.class.getTypeName()),
+ isPresent());
+ })
+ .assertSuccessWithOutputLines("Hello World!");
+ }
+
+ @Test
+ public void testMainWithoutUse() {}
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @interface LibraryAnnotation {}
+
+ @LibraryAnnotation
+ public static class Foo {
+
+ @LibraryAnnotation public String bar = "Hello World!";
+
+ @LibraryAnnotation
+ public void foo(@LibraryAnnotation String arg) {
+ System.out.println(arg);
+ }
+ }
+
+ public static class MainWithoutUse {
+
+ public static void main(String[] args) {
+ Foo foo = new Foo();
+ foo.foo(foo.bar);
+ }
+ }
+
+ public static class MainWithUse {
+ public static void main(String[] args) {
+ if (args.length > 0 && args[0].equals(LibraryAnnotation.class.getTypeName())) {
+ System.out.print("This will never be printed");
+ }
+ Foo foo = new Foo();
+ foo.foo(foo.bar);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/PrunedOrMergedAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/PrunedOrMergedAnnotationTest.java
new file mode 100644
index 0000000..45b29f7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/PrunedOrMergedAnnotationTest.java
@@ -0,0 +1,119 @@
+// 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.shaking.annotations;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.DexAnnotationSet;
+import com.android.tools.r8.graph.DexEncodedAnnotation;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class PrunedOrMergedAnnotationTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public PrunedOrMergedAnnotationTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRewritingInFactory()
+ throws IOException, CompilationFailedException, ExecutionException {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(PrunedOrMergedAnnotationTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepAttributes("*Annotation*")
+ .addKeepClassAndMembersRules(Factory.class)
+ .enableInliningAnnotations()
+ .enableClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Hello", "World!")
+ .inspect(
+ inspector -> {
+ assertThat(inspector.clazz(A.class), not(isPresent()));
+ DexType mergedType = inspector.clazz(B.class).getDexClass().type;
+ ClassSubject classC = inspector.clazz(C.class);
+ assertThat(classC, isPresent());
+ DexEncodedAnnotation annotation =
+ classC.annotation(Factory.class.getTypeName()).getAnnotation();
+ assertTrue(valueIsDexType(mergedType, annotation.elements[0].value));
+ assertTrue(
+ Arrays.stream(annotation.elements[1].value.asDexValueArray().getValues())
+ .allMatch(value -> valueIsDexType(mergedType, value)));
+ // Check that method parameter annotations are rewritten as well.
+ DexEncodedMethod method = inspector.clazz(Main.class).mainMethod().getMethod();
+ DexAnnotationSet annotationSet = method.parameterAnnotationsList.get(0);
+ DexEncodedAnnotation parameterAnnotation = annotationSet.annotations[0].annotation;
+ assertTrue(valueIsDexType(mergedType, parameterAnnotation.elements[0].value));
+ });
+ }
+
+ private boolean valueIsDexType(DexType type, DexValue value) {
+ assertTrue(value.isDexValueType());
+ assertEquals(type, value.asDexValueType().value);
+ return true;
+ }
+
+ public @interface Factory {
+
+ Class<?> extending() default Object.class;
+
+ Class<?>[] other() default Object[].class;
+ }
+
+ public static class A {}
+
+ @NeverClassInline
+ public static class B extends A {
+ @NeverInline
+ public void world() {
+ System.out.println("World!");
+ }
+ }
+
+ @Factory(
+ extending = A.class,
+ other = {A.class, B.class})
+ public static class C {
+ @NeverInline
+ public static void hello() {
+ System.out.println("Hello");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(@Factory(extending = A.class) String[] args) {
+ C.hello();
+ new B().world();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
index ca354f9..a5fbc59 100644
--- a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
@@ -8,7 +8,6 @@
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverMerge;
import com.android.tools.r8.TestBase;
@@ -29,7 +28,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public LibraryMethodOverrideTest(TestParameters parameters) {
@@ -44,8 +43,7 @@
.addOptionsModification(options -> options.enableTreeShakingOfLibraryMethodOverrides = true)
.enableClassInliningAnnotations()
.enableMergeAnnotations()
- .enableSideEffectAnnotations()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::verifyOutput)
.run(parameters.getRuntime(), TestClass.class)
@@ -68,7 +66,16 @@
for (Class<?> nonEscapingClass : nonEscapingClasses) {
ClassSubject classSubject = inspector.clazz(nonEscapingClass);
assertThat(classSubject, isPresent());
- assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
+
+ // TODO(b/142772856): None of the non-escaping classes should have a toString() method. It is
+ // a requirement that the instance initializers are considered trivial for this to work,
+ // though, even when they have a side effect (as long as the receiver does not escape via the
+ // side effecting instruction).
+ if (nonEscapingClass == DoesNotEscapeWithSubThatDoesNotOverrideSub.class) {
+ assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
+ } else {
+ assertThat(classSubject.uniqueMethodWithName("toString"), isPresent());
+ }
}
}
@@ -128,8 +135,12 @@
@NeverClassInline
static class DoesNotEscape {
- @AssumeMayHaveSideEffects
- DoesNotEscape() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscape() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
@@ -140,8 +151,12 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatDoesNotOverride {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatDoesNotOverride() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatDoesNotOverride() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
@@ -153,15 +168,23 @@
static class DoesNotEscapeWithSubThatDoesNotOverrideSub
extends DoesNotEscapeWithSubThatDoesNotOverride {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatDoesNotOverrideSub() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatDoesNotOverrideSub() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
}
@NeverClassInline
static class DoesNotEscapeWithSubThatOverrides {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatOverrides() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatOverrides() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
@@ -172,8 +195,12 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatOverridesSub extends DoesNotEscapeWithSubThatOverrides {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatOverridesSub() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatOverridesSub() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
@@ -188,8 +215,12 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatOverridesAndEscapes {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatOverridesAndEscapes() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatOverridesAndEscapes() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
@@ -201,8 +232,12 @@
static class DoesNotEscapeWithSubThatOverridesAndEscapesSub
extends DoesNotEscapeWithSubThatOverridesAndEscapes {
- @AssumeMayHaveSideEffects
- DoesNotEscapeWithSubThatOverridesAndEscapesSub() {}
+ // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
+ // side effect.
+ DoesNotEscapeWithSubThatOverridesAndEscapesSub() {
+ // Side effect to ensure that the constructor is not removed from main().
+ System.out.print("");
+ }
@Override
public String toString() {
diff --git a/src/test/r8OnArtBackport/FileAlreadyExistsException.java b/src/test/r8OnArtBackport/FileAlreadyExistsException.java
new file mode 100644
index 0000000..a725932
--- /dev/null
+++ b/src/test/r8OnArtBackport/FileAlreadyExistsException.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+import java.io.IOException;
+
+public class FileAlreadyExistsException extends IOException {
+ public FileAlreadyExistsException(String file) {
+ super(file);
+ }
+}
diff --git a/src/test/r8OnArtBackport/Files.java b/src/test/r8OnArtBackport/Files.java
new file mode 100644
index 0000000..99d1956
--- /dev/null
+++ b/src/test/r8OnArtBackport/Files.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+import com.android.tools.r8.MockedPath;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+
+public final class Files {
+ private Files() {}
+
+ public static boolean exists(Path path, LinkOption... options) {
+ if (options.length != 0) {
+ throw new RuntimeException("Unsupported in the Files mock.");
+ }
+ return new File(path.toString()).exists();
+ }
+
+ public static boolean isDirectory(Path path, LinkOption... options) {
+ if (options.length != 0) {
+ throw new RuntimeException("Unsupported in the Files mock.");
+ }
+ return new File(path.toString()).isDirectory();
+ }
+
+ public static byte[] readAllBytes(Path path) throws IOException {
+ if (!(path instanceof MockedPath)) {
+ throw new RuntimeException("Unsupported in the Files mock.");
+ }
+ MockedPath mockedPath = (MockedPath) path;
+ return mockedPath.getAllBytes();
+ }
+
+ public static OutputStream newOutputStream(Path path, OpenOption... options) throws IOException {
+ boolean append = false;
+ for (OpenOption option : options) {
+ if (option == StandardOpenOption.APPEND) {
+ append = true;
+ }
+ }
+ if (!(path instanceof MockedPath)) {
+ throw new RuntimeException("Unsupported in the Files mock.");
+ }
+ MockedPath mockedPath = (MockedPath) path;
+ return mockedPath.newOutputStream(append);
+ }
+}
diff --git a/src/test/r8OnArtBackport/LinkOption.java b/src/test/r8OnArtBackport/LinkOption.java
new file mode 100644
index 0000000..3b4b510
--- /dev/null
+++ b/src/test/r8OnArtBackport/LinkOption.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+public interface LinkOption {}
diff --git a/src/test/r8OnArtBackport/MockedPath.java b/src/test/r8OnArtBackport/MockedPath.java
new file mode 100644
index 0000000..c5147df
--- /dev/null
+++ b/src/test/r8OnArtBackport/MockedPath.java
@@ -0,0 +1,151 @@
+// Copyright (c) 2019, 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;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+
+// Mock Path since Path is not present before Dex-8.
+// File is present and it contains most of the utilities.
+public class MockedPath implements Path {
+
+ private MockedPath(File file) {
+ this.wrappedFile = file;
+ }
+
+ public static Path of(File file, String... more) {
+ // Delegate to File separator management.
+ File current = file;
+ for (String s : more) {
+ current = new File(current.getPath(), s);
+ }
+ return new MockedPath(current);
+ }
+
+ public static Path of(String first, String... more) {
+ return of(new File(first), more);
+ }
+
+ // MockedPath wraps the path in a file.
+ private File wrappedFile;
+
+ @Override
+ public FileSystem getFileSystem() {
+ throw new RuntimeException("Mocked Path does not implement getFileSystem");
+ }
+
+ @Override
+ public boolean isAbsolute() {
+ throw new RuntimeException("Mocked Path does not implement isAbsolute");
+ }
+
+ @Override
+ public Path getRoot() {
+ throw new RuntimeException("Mocked Path does not implement getRoot");
+ }
+
+ @Override
+ public Path getFileName() {
+ return of(wrappedFile.getName());
+ }
+
+ @Override
+ public Path getParent() {
+ return of(wrappedFile.getParent());
+ }
+
+ @Override
+ public int getNameCount() {
+ throw new RuntimeException("Mocked Path does not implement getNameCount");
+ }
+
+ @Override
+ public Path getName(int index) {
+ throw new RuntimeException("Mocked Path does not implement getName");
+ }
+
+ @Override
+ public Path subpath(int beginIndex, int endIndex) {
+ throw new RuntimeException("Mocked Path does not implement subpath");
+ }
+
+ @Override
+ public boolean startsWith(Path other) {
+ throw new RuntimeException("Mocked Path does not implement startsWith");
+ }
+
+ @Override
+ public boolean endsWith(Path other) {
+ throw new RuntimeException("Mocked Path does not implement endswith");
+ }
+
+ @Override
+ public Path normalize() {
+ throw new RuntimeException("Mocked Path does not implement normalize");
+ }
+
+ @Override
+ public Path resolve(Path other) {
+ return new MockedPath(new File(wrappedFile.getPath(), other.toString()));
+ }
+
+ @Override
+ public Path relativize(Path other) {
+ throw new RuntimeException("Mocked Path does not implement relativize");
+ }
+
+ @Override
+ public URI toUri() {
+ throw new RuntimeException("Mocked Path does not implement toUri");
+ }
+
+ @Override
+ public Path toAbsolutePath() {
+ throw new RuntimeException("Mocked Path does not implement toAbsolutePath");
+ }
+
+ @Override
+ public Path toRealPath(LinkOption... options) throws IOException {
+ throw new RuntimeException("Mocked Path does not implement toRealPath");
+ }
+
+ @Override
+ public int compareTo(Path other) {
+ throw new RuntimeException("Mocked Path does not implement compareTo");
+ }
+
+ @Override
+ public String toString() {
+ return wrappedFile.toString();
+ }
+
+ @Override
+ public File toFile() {
+ return wrappedFile;
+ }
+
+ // Compatibility with Files.
+
+ public byte[] getAllBytes() throws IOException {
+ FileInputStream fileInputStream = new FileInputStream(wrappedFile);
+ // In android the result of file.length() is long
+ // byte count of the file-content
+ long byteLength = wrappedFile.length();
+ byte[] filecontent = new byte[(int) byteLength];
+ fileInputStream.read(filecontent, 0, (int) byteLength);
+ return filecontent;
+ }
+
+ public OutputStream newOutputStream(boolean append) throws IOException {
+ return new FileOutputStream(wrappedFile, append);
+ }
+}
diff --git a/src/test/r8OnArtBackport/NoSuchFileException.java b/src/test/r8OnArtBackport/NoSuchFileException.java
new file mode 100644
index 0000000..9c8e9cf
--- /dev/null
+++ b/src/test/r8OnArtBackport/NoSuchFileException.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+import java.io.IOException;
+
+public class NoSuchFileException extends IOException {
+ public NoSuchFileException(String file) {
+ super(file);
+ }
+}
diff --git a/src/test/r8OnArtBackport/OpenOption.java b/src/test/r8OnArtBackport/OpenOption.java
new file mode 100644
index 0000000..21b5fb6
--- /dev/null
+++ b/src/test/r8OnArtBackport/OpenOption.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+public interface OpenOption {}
diff --git a/src/test/r8OnArtBackport/Path.java b/src/test/r8OnArtBackport/Path.java
new file mode 100644
index 0000000..474725f
--- /dev/null
+++ b/src/test/r8OnArtBackport/Path.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Iterator;
+
+// Removed Watchable.
+public interface Path extends Comparable<Path>, Iterable<Path> {
+ public static Path of(String first, String... more) {
+ throw new RuntimeException("Path does not implement of, use MockedPath.of");
+ }
+
+ public static Path of(URI uri) {
+ throw new RuntimeException("Path does not implement of, use MockedPath.of");
+ }
+
+ FileSystem getFileSystem();
+
+ boolean isAbsolute();
+
+ Path getRoot();
+
+ Path getFileName();
+
+ Path getParent();
+
+ int getNameCount();
+
+ Path getName(int index);
+
+ Path subpath(int beginIndex, int endIndex);
+
+ boolean startsWith(Path other);
+
+ default boolean startsWith(String other) {
+ throw new RuntimeException("Path does not implement startsWith");
+ }
+
+ boolean endsWith(Path other);
+
+ default boolean endsWith(String other) {
+ throw new RuntimeException("Path does not implement endsWith");
+ }
+
+ Path normalize();
+
+ Path resolve(Path other);
+
+ default Path resolve(String other) {
+ throw new RuntimeException("Path does not implement resolve");
+ }
+
+ default Path resolveSibling(Path other) {
+ throw new RuntimeException("Path does not implement resolveSibling");
+ }
+
+ default Path resolveSibling(String other) {
+ throw new RuntimeException("Path does not implement resolveSibling");
+ }
+
+ Path relativize(Path other);
+
+ URI toUri();
+
+ Path toAbsolutePath();
+
+ Path toRealPath(LinkOption... options) throws IOException;
+
+ default File toFile() {
+ throw new RuntimeException("Path does not implement toFile");
+ }
+
+ @Override
+ default Iterator<Path> iterator() {
+ throw new RuntimeException("Path does not implement iterator");
+ }
+
+ @Override
+ int compareTo(Path other);
+
+ boolean equals(Object other);
+
+ int hashCode();
+
+ String toString();
+}
diff --git a/src/test/r8OnArtBackport/Paths.java b/src/test/r8OnArtBackport/Paths.java
new file mode 100644
index 0000000..06d044f
--- /dev/null
+++ b/src/test/r8OnArtBackport/Paths.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+import com.android.tools.r8.MockedPath;
+
+public final class Paths {
+
+ private Paths() {}
+
+ public static Path get(String first, String... more) {
+ return MockedPath.of(first, more);
+ }
+}
diff --git a/src/test/r8OnArtBackport/StandardOpenOption.java b/src/test/r8OnArtBackport/StandardOpenOption.java
new file mode 100644
index 0000000..0e4d208
--- /dev/null
+++ b/src/test/r8OnArtBackport/StandardOpenOption.java
@@ -0,0 +1,18 @@
+// Copyright (c) 2019, 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 java.nio.file;
+
+public enum StandardOpenOption implements OpenOption {
+ READ,
+ WRITE,
+ APPEND,
+ TRUNCATE_EXISTING,
+ CREATE,
+ CREATE_NEW,
+ DELETE_ON_CLOSE,
+ SPARSE,
+ SYNC,
+ DSYNC;
+}
diff --git a/tools/gradle.py b/tools/gradle.py
index 842816e..0e926e6 100755
--- a/tools/gradle.py
+++ b/tools/gradle.py
@@ -31,6 +31,11 @@
default=False, action='store_true')
parser.add_argument('--java-home', '--java_home',
help='Use a custom java version to run gradle.')
+ parser.add_argument('--worktree',
+ help='Gradle is running in a worktree and may lock up '
+ 'the gradle caches.',
+ action='store_true',
+ default=False)
return parser.parse_known_args()
def GetJavaEnv(env):
@@ -101,6 +106,8 @@
args.append('-Dorg.gradle.java.home=' + options.java_home)
if options.no_internal:
args.append('-Pno_internal')
+ if options.worktree:
+ args.append('-g=' + os.path.join(utils.REPO_ROOT, ".gradle_user_home"))
return RunGradle(args)
if __name__ == '__main__':
diff --git a/tools/internal_test.py b/tools/internal_test.py
index 9654b4b..c85942b 100755
--- a/tools/internal_test.py
+++ b/tools/internal_test.py
@@ -77,7 +77,7 @@
'find-xmx-min': 800,
'find-xmx-max': 1200,
'find-xmx-range': 32,
- 'oom-threshold': 1000,
+ 'oom-threshold': 1037,
},
{
'app': 'iosched',
@@ -90,6 +90,8 @@
]
def find_min_xmx_command(record):
+ assert record['find-xmx-min'] < record['find-xmx-max']
+ assert record['find-xmx-range'] < record['find-xmx-max'] - record['find-xmx-min']
return [
'tools/run_on_app.py',
'--compiler=r8',
diff --git a/tools/test.py b/tools/test.py
index 2d45d1c..5091f61 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -128,6 +128,9 @@
result.add_option('--fail-fast', '--fail_fast',
default=False, action='store_true',
help='Stop on first failure. Passes --fail-fast to gradle test runner.')
+ result.add_option('--worktree',
+ default=False, action='store_true',
+ help='Tests are run in worktree and should not use gradle user home.')
return result.parse_args()
def archive_failures():
@@ -215,6 +218,8 @@
gradle_args.append('R8LibNoDeps')
if options.r8lib_no_deps:
gradle_args.append('-Pr8lib_no_deps')
+ if options.worktree:
+ gradle_args.append('-g=' + os.path.join(utils.REPO_ROOT, ".gradle_user_home"))
# Build an R8 with dependencies for bootstrapping tests before adding test sources.
gradle_args.append('r8WithRelocatedDeps')
