Merge commit '52275f13b7965a7380c28c2449b662e3def10df4' into dev-release
diff --git a/.gitignore b/.gitignore
index ec03160..0629bac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -98,6 +98,8 @@
third_party/kotlin/kotlin-compiler-1.3.41
third_party/kotlin/kotlin-compiler-1.3.72.tar.gz
third_party/kotlin/kotlin-compiler-1.3.72
+third_party/kotlinx-coroutines-1.3.6.tar.gz
+third_party/kotlinx-coroutines-1.3.6
third_party/nest/*
third_party/openjdk/desugar_jdk_libs
third_party/openjdk/desugar_jdk_libs.tar.gz
diff --git a/build.gradle b/build.gradle
index 90ad4ab..338df88 100644
--- a/build.gradle
+++ b/build.gradle
@@ -327,6 +327,7 @@
"kotlin/kotlin-compiler-1.3.11",
"kotlin/kotlin-compiler-1.3.41",
"kotlin/kotlin-compiler-1.3.72",
+ "kotlinx-coroutines-1.3.6",
"openjdk/openjdk-rt-1.8",
"openjdk/desugar_jdk_libs",
"openjdk/jdk-11-test",
diff --git a/src/main/java/com/android/tools/r8/BaseCommand.java b/src/main/java/com/android/tools/r8/BaseCommand.java
index 50e5be1..9bfdfcd 100644
--- a/src/main/java/com/android/tools/r8/BaseCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCommand.java
@@ -8,7 +8,9 @@
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.utils.AbortException;
import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.ExceptionDiagnostic;
+import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringDiagnostic;
@@ -134,14 +136,15 @@
* associated diagnostics handler and a {@link CompilationFailedException} exception is thrown.
*/
public final C build() throws CompilationFailedException {
- try {
- validate();
- C c = makeCommand();
- reporter.failIfPendingErrors();
- return c;
- } catch (AbortException e) {
- throw new CompilationFailedException(e);
- }
+ Box<C> box = new Box<>(null);
+ ExceptionUtils.withCompilationHandler(
+ reporter,
+ () -> {
+ validate();
+ box.set(makeCommand());
+ reporter.failIfPendingErrors();
+ });
+ return box.get();
}
// Helper to construct the actual command. Called as part of {@link build()}.
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index d3a291f..8406706 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -684,7 +684,8 @@
appView,
new SubtypingInfo(application.allClasses(), application),
keptGraphConsumer,
- missingClasses);
+ missingClasses,
+ prunedTypes);
appView.setAppInfo(
enqueuer
.traceApplication(
diff --git a/src/main/java/com/android/tools/r8/R8CommandParser.java b/src/main/java/com/android/tools/r8/R8CommandParser.java
index d31606d..6220eb4 100644
--- a/src/main/java/com/android/tools/r8/R8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/R8CommandParser.java
@@ -11,7 +11,11 @@
import com.google.common.collect.Iterables;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
import java.util.Set;
public class R8CommandParser extends BaseCompilerCommandParser<R8Command, R8Command.Builder> {
@@ -24,12 +28,15 @@
MIN_API_FLAG,
"--main-dex-rules",
"--main-dex-list",
+ "--feature",
"--main-dex-list-output",
"--pg-conf",
"--pg-map-output",
"--desugared-lib",
THREAD_COUNT_FLAG);
+ private static final Set<String> OPTIONS_WITH_TWO_PARAMETERS = ImmutableSet.of("--feature");
+
public static void main(String[] args) throws CompilationFailedException {
R8Command command = parse(args, Origin.root()).build();
if (command.isPrintHelp()) {
@@ -83,6 +90,9 @@
" --main-dex-rules <file> # Proguard keep rules for classes to place in the",
" # primary dex file.",
" --main-dex-list <file> # List of classes to place in the primary dex file.",
+ " --feature <input> <output> ",
+ " # Add feature <input> file to <output> file. Several ",
+ " # occurrences can map to the same output.",
" --main-dex-list-output <file> ",
" # Output the full main-dex list in <file>."),
ASSERTIONS_USAGE_MESSAGE,
@@ -131,9 +141,11 @@
private void parse(
String[] args, Origin argsOrigin, R8Command.Builder builder, ParseState state) {
String[] expandedArgs = FlagFile.expandFlagFiles(args, builder::error);
+ Map<Path, List<Path>> featureSplitJars = new HashMap<>();
for (int i = 0; i < expandedArgs.length; i++) {
String arg = expandedArgs[i].trim();
String nextArg = null;
+ String nextNextArg = null;
if (OPTIONS_WITH_PARAMETER.contains(arg)) {
if (++i < expandedArgs.length) {
nextArg = expandedArgs[i];
@@ -143,6 +155,16 @@
"Missing parameter for " + expandedArgs[i - 1] + ".", argsOrigin));
break;
}
+ if (OPTIONS_WITH_TWO_PARAMETERS.contains(arg)) {
+ if (++i < expandedArgs.length) {
+ nextNextArg = expandedArgs[i];
+ } else {
+ builder.error(
+ new StringDiagnostic(
+ "Missing parameter for " + expandedArgs[i - 2] + ".", argsOrigin));
+ break;
+ }
+ }
}
if (arg.length() == 0) {
continue;
@@ -214,6 +236,10 @@
builder.setDisableDesugaring(true);
} else if (arg.equals("--main-dex-rules")) {
builder.addMainDexRulesFiles(Paths.get(nextArg));
+ } else if (arg.equals("--feature")) {
+ featureSplitJars
+ .computeIfAbsent(Paths.get(nextNextArg), k -> new ArrayList<>())
+ .add(Paths.get(nextArg));
} else if (arg.equals("--main-dex-list")) {
builder.addMainDexListFiles(Paths.get(nextArg));
} else if (arg.equals("--main-dex-list-output")) {
@@ -239,5 +265,20 @@
builder.addProgramFiles(Paths.get(arg));
}
}
+ featureSplitJars.forEach(
+ (outputPath, inputJars) -> addFeatureJar(builder, outputPath, inputJars));
+ }
+
+ public void addFeatureJar(R8Command.Builder builder, Path outputPath, List<Path> inputJarPaths) {
+ builder.addFeatureSplit(
+ featureSplitGenerator -> {
+ featureSplitGenerator.setProgramConsumer(
+ builder.createProgramOutputConsumer(outputPath, OutputMode.DexIndexed, true));
+ for (Path inputPath : inputJarPaths) {
+ featureSplitGenerator.addProgramResourceProvider(
+ ArchiveProgramResourceProvider.fromArchive(inputPath));
+ }
+ return featureSplitGenerator.build();
+ });
}
}
diff --git a/src/main/java/com/android/tools/r8/graph/AccessControl.java b/src/main/java/com/android/tools/r8/graph/AccessControl.java
index 854c5e7..788b358 100644
--- a/src/main/java/com/android/tools/r8/graph/AccessControl.java
+++ b/src/main/java/com/android/tools/r8/graph/AccessControl.java
@@ -38,6 +38,14 @@
public static OptionalBool isMethodAccessible(
DexEncodedMethod method,
DexClass holder,
+ ProgramMethod context,
+ AppView<? extends AppInfoWithClassHierarchy> appView) {
+ return isMethodAccessible(method, holder, context.getHolder(), appView.appInfo());
+ }
+
+ public static OptionalBool isMethodAccessible(
+ DexEncodedMethod method,
+ DexClass holder,
DexProgramClass context,
AppInfoWithClassHierarchy appInfo) {
return isMemberAccessible(method.accessFlags, holder, context, appInfo);
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index 73395b2..7a85dc8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -42,6 +42,10 @@
this.staticValue = staticValue;
}
+ public DexType type() {
+ return field.type;
+ }
+
public boolean isProgramField(DexDefinitionSupplier definitions) {
if (field.holder.isClassType()) {
DexClass clazz = definitions.definitionFor(field.holder);
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 3b635e6..1a318c0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -1268,6 +1268,7 @@
public final DexMethod name;
public final DexMethod toString;
public final DexMethod compareTo;
+ public final DexMethod equals;
public final DexMethod constructor =
createMethod(enumType, createProto(voidType, stringType, intType), constructorMethodName);
@@ -1301,10 +1302,13 @@
DexString.EMPTY_ARRAY);
compareTo =
createMethod(
+ enumDescriptor, compareToMethodName, intDescriptor, new DexString[] {enumDescriptor});
+ equals =
+ createMethod(
enumDescriptor,
- compareToMethodName,
- stringDescriptor,
- new DexString[] {enumDescriptor});
+ equalsMethodName,
+ booleanDescriptor,
+ new DexString[] {objectDescriptor});
}
public boolean isValuesMethod(DexMethod method, DexClass enumClass) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
index 978646c..41f5dc8 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
@@ -388,7 +388,7 @@
return false;
}
ResolutionResult resolutionResult =
- appView.appInfo().resolveMethodOn(superType, method, instruction.itf);
+ appView.appInfo().resolveMethodOn(superType, method, instruction.isInterface);
if (!resolutionResult.isSingleResolution()) {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
index 0e3f404..8b63913 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/type/TypeAnalysis.java
@@ -162,10 +162,16 @@
public static DexType getRefinedReceiverType(
AppView<? extends AppInfoWithClassHierarchy> appView, DexMethod method, Value receiver) {
- TypeElement lattice = receiver.getDynamicUpperBoundType(appView);
+ return toRefinedReceiverType(receiver.getDynamicUpperBoundType(appView), method, appView);
+ }
+
+ public static DexType toRefinedReceiverType(
+ TypeElement receiverUpperBoundType,
+ DexMethod method,
+ AppView<? extends AppInfoWithClassHierarchy> appView) {
DexType staticReceiverType = method.holder;
- if (lattice.isClassType()) {
- ClassTypeElement classType = lattice.asClassType();
+ if (receiverUpperBoundType.isClassType()) {
+ ClassTypeElement classType = receiverUpperBoundType.asClassType();
DexType refinedType = classType.getClassType();
if (refinedType == appView.dexItemFactory().objectType) {
Set<DexType> interfaces = classType.getInterfaces();
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 c6012bd..117af7b 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
@@ -12,50 +12,60 @@
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.Assume.Assumption;
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;
import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.utils.BooleanUtils;
import java.util.Objects;
import java.util.Set;
-public class Assume<An extends Assumption> extends Instruction {
+public class Assume extends Instruction {
private static final String ERROR_MESSAGE =
"Expected Assume instructions to be removed after IR processing.";
- private final An assumption;
+ private final DynamicTypeAssumption dynamicTypeAssumption;
+ private final NonNullAssumption nonNullAssumption;
private final Instruction origin;
- private Assume(An assumption, Value dest, Value src, Instruction origin, AppView<?> appView) {
+ private Assume(
+ DynamicTypeAssumption dynamicTypeAssumption,
+ NonNullAssumption nonNullAssumption,
+ Value dest,
+ Value src,
+ Instruction origin,
+ AppView<?> appView) {
super(dest, src);
- assert assumption != null;
- assert assumption.verifyCorrectnessOfValues(dest, src, appView);
+ assert dynamicTypeAssumption != null || nonNullAssumption != null;
+ assert BooleanUtils.intValue(dynamicTypeAssumption != null)
+ + BooleanUtils.intValue(nonNullAssumption != null)
+ == 1;
+ assert dynamicTypeAssumption == null
+ || dynamicTypeAssumption.verifyCorrectnessOfValues(dest, src, appView);
+ assert nonNullAssumption == null
+ || nonNullAssumption.verifyCorrectnessOfValues(dest, src, appView);
assert dest != null;
- this.assumption = assumption;
+ this.dynamicTypeAssumption = dynamicTypeAssumption;
+ this.nonNullAssumption = nonNullAssumption;
this.origin = origin;
}
- public static Assume<NoAssumption> createAssumeNoneInstruction(
+ public static Assume createAssumeNonNullInstruction(
Value dest, Value src, Instruction origin, AppView<?> appView) {
- return new Assume<>(NoAssumption.get(), dest, src, origin, appView);
+ return new Assume(null, NonNullAssumption.get(), dest, src, origin, appView);
}
- public static Assume<NonNullAssumption> createAssumeNonNullInstruction(
- Value dest, Value src, Instruction origin, AppView<?> appView) {
- return new Assume<>(NonNullAssumption.get(), dest, src, origin, appView);
- }
-
- public static Assume<DynamicTypeAssumption> createAssumeDynamicTypeInstruction(
+ public static Assume createAssumeDynamicTypeInstruction(
TypeElement dynamicUpperBoundType,
ClassTypeElement dynamicLowerBoundType,
Value dest,
Value src,
Instruction origin,
AppView<?> appView) {
- return new Assume<>(
+ return new Assume(
new DynamicTypeAssumption(dynamicUpperBoundType, dynamicLowerBoundType),
+ null,
dest,
src,
origin,
@@ -69,7 +79,7 @@
public boolean verifyInstructionIsNeeded(AppView<?> appView) {
if (isAssumeDynamicType()) {
- assert assumption.verifyCorrectnessOfValues(outValue(), src(), appView);
+ assert dynamicTypeAssumption.verifyCorrectnessOfValues(outValue(), src(), appView);
}
return true;
}
@@ -79,8 +89,12 @@
return visitor.visit(this);
}
- public An getAssumption() {
- return assumption;
+ public DynamicTypeAssumption getDynamicTypeAssumption() {
+ return dynamicTypeAssumption;
+ }
+
+ public NonNullAssumption getNonNullAssumption() {
+ return nonNullAssumption;
}
public Value src() {
@@ -98,9 +112,6 @@
@Override
public String getInstructionName() {
- if (isAssumeNone()) {
- return "AssumeNone";
- }
if (isAssumeDynamicType()) {
return "AssumeDynamicType";
}
@@ -116,51 +127,18 @@
}
@Override
- public Assume<An> asAssume() {
+ public Assume asAssume() {
return this;
}
@Override
- public boolean isAssumeNone() {
- return assumption.isAssumeNone();
- }
-
- @Override
- public Assume<NoAssumption> asAssumeNone() {
- assert isAssumeNone();
- @SuppressWarnings("unchecked")
- Assume<NoAssumption> self = (Assume<NoAssumption>) this;
- return self;
- }
-
- @Override
public boolean isAssumeDynamicType() {
- return assumption.isAssumeDynamicType();
- }
-
- @Override
- public Assume<DynamicTypeAssumption> asAssumeDynamicType() {
- assert isAssumeDynamicType();
- @SuppressWarnings("unchecked")
- Assume<DynamicTypeAssumption> self = (Assume<DynamicTypeAssumption>) this;
- return self;
+ return dynamicTypeAssumption != null;
}
@Override
public boolean isAssumeNonNull() {
- return assumption.isAssumeNonNull();
- }
-
- @Override
- public Assume<NonNullAssumption> asAssumeNonNull() {
- assert isAssumeNonNull();
- @SuppressWarnings("unchecked")
- Assume<NonNullAssumption> self = (Assume<NonNullAssumption>) this;
- return self;
- }
-
- public boolean mayAffectStaticType() {
- return isAssumeNonNull();
+ return nonNullAssumption != null;
}
@Override
@@ -171,12 +149,8 @@
if (outType.isPrimitiveType()) {
return false;
}
- if (assumption.isAssumeNone()) {
- // The main purpose of AssumeNone is to test local alias tracking.
- return true;
- }
- if (assumption.isAssumeDynamicType()) {
- outType = asAssumeDynamicType().assumption.getDynamicUpperBoundType();
+ if (isAssumeDynamicType()) {
+ outType = dynamicTypeAssumption.getDynamicUpperBoundType();
}
if (appView.appInfo().hasLiveness()) {
if (outType.isClassType()
@@ -233,8 +207,9 @@
if (!other.isAssume()) {
return false;
}
- Assume<?> assumeInstruction = other.asAssume();
- return assumption.equals(assumeInstruction.assumption);
+ Assume assumeInstruction = other.asAssume();
+ return Objects.equals(dynamicTypeAssumption, assumeInstruction.dynamicTypeAssumption)
+ && Objects.equals(nonNullAssumption, assumeInstruction.nonNullAssumption);
}
@Override
@@ -245,10 +220,10 @@
@Override
public TypeElement evaluate(AppView<?> appView) {
- if (assumption.isAssumeNone() || assumption.isAssumeDynamicType()) {
+ if (isAssumeDynamicType()) {
return src().getType();
}
- if (assumption.isAssumeNonNull()) {
+ if (isAssumeNonNull()) {
assert src().getType().isReferenceType();
return src().getType().asReferenceType().asMeetWithNotNull();
}
@@ -281,7 +256,7 @@
TypeElement inType = src().getType();
TypeElement outType = getOutType();
- if (isAssumeNone() || isAssumeDynamicType()) {
+ if (isAssumeDynamicType()) {
assert inType.isReferenceType() : inType;
assert outType.equals(inType)
: "At " + this + System.lineSeparator() + outType + " != " + inType;
@@ -303,63 +278,22 @@
// are still valid.
String originString =
origin.hasBlock() ? " (origin: `" + origin.toString() + "`)" : " (obsolete origin)";
- if (isAssumeNone() || isAssumeNonNull()) {
+ if (isAssumeNonNull()) {
return super.toString() + originString;
}
if (isAssumeDynamicType()) {
- DynamicTypeAssumption assumption = asAssumeDynamicType().getAssumption();
return super.toString()
+ "; upper bound: "
- + assumption.dynamicUpperBoundType
- + (assumption.dynamicLowerBoundType != null
- ? "; lower bound: " + assumption.dynamicLowerBoundType
+ + dynamicTypeAssumption.dynamicUpperBoundType
+ + (dynamicTypeAssumption.dynamicLowerBoundType != null
+ ? "; lower bound: " + dynamicTypeAssumption.dynamicLowerBoundType
: "")
+ originString;
}
return super.toString();
}
- abstract static class Assumption {
-
- public boolean isAssumeNone() {
- return false;
- }
-
- public boolean isAssumeDynamicType() {
- return false;
- }
-
- public boolean isAssumeNonNull() {
- return false;
- }
-
- public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
- return true;
- }
- }
-
- public static class NoAssumption extends Assumption {
- private static final NoAssumption instance = new NoAssumption();
-
- private NoAssumption() {}
-
- static NoAssumption get() {
- return instance;
- }
-
- @Override
- public boolean isAssumeNone() {
- return true;
- }
-
- @Override
- public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
- assert dest.getType() == src.getType();
- return true;
- }
- }
-
- public static class DynamicTypeAssumption extends Assumption {
+ public static class DynamicTypeAssumption {
private final TypeElement dynamicUpperBoundType;
private final ClassTypeElement dynamicLowerBoundType;
@@ -378,12 +312,6 @@
return dynamicLowerBoundType;
}
- @Override
- public boolean isAssumeDynamicType() {
- return true;
- }
-
- @Override
public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
assert dynamicUpperBoundType.lessThanOrEqualUpToNullability(src.getType(), appView);
return true;
@@ -408,7 +336,7 @@
}
}
- public static class NonNullAssumption extends Assumption {
+ public static class NonNullAssumption {
private static final NonNullAssumption instance = new NonNullAssumption();
@@ -418,12 +346,6 @@
return instance;
}
- @Override
- public boolean isAssumeNonNull() {
- return true;
- }
-
- @Override
public boolean verifyCorrectnessOfValues(Value dest, Value src, AppView<?> appView) {
assert !src.isNeverNull();
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java b/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
index fdfbe61..f8793ab 100644
--- a/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/DefaultInstructionVisitor.java
@@ -35,7 +35,7 @@
}
@Override
- public T visit(Assume<?> instruction) {
+ public T visit(Assume instruction) {
return null;
}
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 4a6a082..a0af5e2 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
@@ -620,7 +620,7 @@
for (BasicBlock block : blocks) {
for (Instruction instruction : block.getInstructions()) {
if (instruction.isAssumeDynamicType()) {
- assert instruction.asAssumeDynamicType().verifyInstructionIsNeeded(appView);
+ assert instruction.asAssume().verifyInstructionIsNeeded(appView);
}
}
}
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 115afec..b8a5787 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
@@ -128,6 +128,11 @@
DexEncodedField encodedField =
appInfoWithLiveness.resolveField(getField()).getResolvedField();
assert encodedField != null : "NoSuchFieldError (resolution failure) should be caught.";
+
+ if (encodedField.type().isAlwaysNull(appViewWithLiveness)) {
+ return false;
+ }
+
return appInfoWithLiveness.isFieldRead(encodedField)
|| isStoringObjectWithFinalizer(appViewWithLiveness, encodedField);
}
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 6d298df..1400455 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
@@ -22,9 +22,6 @@
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.UnknownValue;
-import com.android.tools.r8.ir.code.Assume.DynamicTypeAssumption;
-import com.android.tools.r8.ir.code.Assume.NoAssumption;
-import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
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;
@@ -716,15 +713,7 @@
return false;
}
- public Assume<?> asAssume() {
- return null;
- }
-
- public boolean isAssumeNone() {
- return false;
- }
-
- public Assume<NoAssumption> asAssumeNone() {
+ public Assume asAssume() {
return null;
}
@@ -732,18 +721,10 @@
return false;
}
- public Assume<DynamicTypeAssumption> asAssumeDynamicType() {
- return null;
- }
-
public boolean isAssumeNonNull() {
return false;
}
- public Assume<NonNullAssumption> asAssumeNonNull() {
- return null;
- }
-
public boolean isBinop() {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java b/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
index 4bb29bb..a374439 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionVisitor.java
@@ -24,7 +24,7 @@
T visit(ArrayPut instruction);
- T visit(Assume<?> instruction);
+ T visit(Assume instruction);
T visit(CheckCast instruction);
diff --git a/src/main/java/com/android/tools/r8/ir/code/Invoke.java b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
index 8fad9af..1c19488 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Invoke.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
@@ -61,6 +61,7 @@
super(result, arguments);
}
+ @Deprecated
public static Invoke create(
Type type, DexItem target, DexProto proto, Value result, List<Value> arguments) {
return create(type, target, proto, result, arguments, false);
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 1bc6ba6..0f736a0 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
@@ -16,6 +16,8 @@
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
import com.android.tools.r8.ir.analysis.modeling.LibraryMethodReadSetModeling;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
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;
@@ -27,15 +29,15 @@
public class InvokeDirect extends InvokeMethodWithReceiver {
- private final boolean itf;
+ private final boolean isInterface;
public InvokeDirect(DexMethod target, Value result, List<Value> arguments) {
this(target, result, arguments, false);
}
- public InvokeDirect(DexMethod target, Value result, List<Value> arguments, boolean itf) {
+ public InvokeDirect(DexMethod target, Value result, List<Value> arguments, boolean isInterface) {
super(target, result, arguments);
- this.itf = itf;
+ this.isInterface = isInterface;
// invoke-direct <init> should have no out value.
assert !target.name.toString().equals(Constants.INSTANCE_INITIALIZER_NAME)
|| result == null;
@@ -46,8 +48,9 @@
return Opcodes.INVOKE_DIRECT;
}
- public boolean isInterface() {
- return itf;
+ @Override
+ public boolean getInterfaceBit() {
+ return isInterface;
}
@Override
@@ -118,7 +121,10 @@
@Override
public DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver) {
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType) {
DexMethod invokedMethod = getInvokedMethod();
if (appView.appInfo().hasLiveness()) {
AppInfoWithLiveness appInfo = appView.appInfo().withLiveness();
@@ -140,7 +146,8 @@
@Override
public void buildCf(CfBuilder builder) {
- builder.add(new CfInvoke(org.objectweb.asm.Opcodes.INVOKESPECIAL, getInvokedMethod(), itf));
+ builder.add(
+ new CfInvoke(org.objectweb.asm.Opcodes.INVOKESPECIAL, getInvokedMethod(), isInterface));
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
index f998009..e95be77 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.code;
+import static com.android.tools.r8.ir.analysis.type.TypeAnalysis.toRefinedReceiverType;
+
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.InvokeInterfaceRange;
import com.android.tools.r8.graph.AppView;
@@ -13,7 +15,8 @@
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.TypeAnalysis;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
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;
@@ -28,6 +31,11 @@
}
@Override
+ public boolean getInterfaceBit() {
+ return true;
+ }
+
+ @Override
public int opcode() {
return Opcodes.INVOKE_INTERFACE;
}
@@ -88,7 +96,10 @@
@Override
public DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver) {
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType) {
if (appView.appInfo().hasLiveness()) {
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
return appViewWithLiveness
@@ -98,9 +109,9 @@
context,
true,
appView,
- TypeAnalysis.getRefinedReceiverType(
- appViewWithLiveness, getInvokedMethod(), receiver),
- receiver.getDynamicLowerBoundType(appViewWithLiveness));
+ toRefinedReceiverType(
+ receiverUpperBoundType, getInvokedMethod(), appViewWithLiveness),
+ receiverLowerBoundType);
}
return null;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
index 8c059d9..c8dd6ec 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
@@ -41,6 +41,8 @@
this.method = target;
}
+ public abstract boolean getInterfaceBit();
+
@Override
public DexType getReturnType() {
return method.proto.returnType;
@@ -109,8 +111,7 @@
refinedReceiverLowerBound = null;
}
}
- ResolutionResult resolutionResult =
- appView.appInfo().resolveMethod(method, isInvokeInterface());
+ ResolutionResult resolutionResult = appView.appInfo().resolveMethod(method, getInterfaceBit());
LookupResult lookupResult;
if (refinedReceiverUpperBound != null) {
lookupResult =
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
index 496f869..a2aa502 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
@@ -73,15 +73,30 @@
@Override
public final DexEncodedMethod lookupSingleTarget(AppView<?> appView, ProgramMethod context) {
- return lookupSingleTarget(appView, context, getReceiver());
+ TypeElement receiverUpperBoundType = null;
+ ClassTypeElement receiverLowerBoundType = null;
+ if (appView.enableWholeProgramOptimizations()) {
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+ receiverUpperBoundType = getReceiver().getDynamicUpperBoundType(appViewWithLiveness);
+ receiverLowerBoundType = getReceiver().getDynamicLowerBoundType(appViewWithLiveness);
+ }
+ return lookupSingleTarget(appView, context, receiverUpperBoundType, receiverLowerBoundType);
}
public abstract DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver);
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType);
public final ProgramMethod lookupSingleProgramTarget(
- AppView<?> appView, ProgramMethod context, Value receiver) {
- return asProgramMethodOrNull(lookupSingleTarget(appView, context, receiver), appView);
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType) {
+ return asProgramMethodOrNull(
+ lookupSingleTarget(appView, context, receiverUpperBoundType, receiverLowerBoundType),
+ appView);
}
@Override
@@ -194,7 +209,7 @@
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
ResolutionResult resolutionResult =
- appViewWithLiveness.appInfo().resolveMethod(getInvokedMethod(), isInvokeInterface());
+ appViewWithLiveness.appInfo().resolveMethod(getInvokedMethod(), getInterfaceBit());
if (resolutionResult.isFailedResolution()) {
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
index 6a1e8a2..824a283 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
@@ -36,6 +36,11 @@
}
@Override
+ public boolean getInterfaceBit() {
+ return false;
+ }
+
+ @Override
public int opcode() {
return Opcodes.INVOKE_POLYMORPHIC;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
index 7cd9b1e..7f5836a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
@@ -43,6 +43,11 @@
}
@Override
+ public boolean getInterfaceBit() {
+ return isInterface;
+ }
+
+ @Override
public int opcode() {
return Opcodes.INVOKE_STATIC;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
index e2b2e3a..4815431 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
@@ -13,6 +13,8 @@
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.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
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;
@@ -22,11 +24,16 @@
public class InvokeSuper extends InvokeMethodWithReceiver {
- public final boolean itf;
+ public final boolean isInterface;
- public InvokeSuper(DexMethod target, Value result, List<Value> arguments, boolean itf) {
+ public InvokeSuper(DexMethod target, Value result, List<Value> arguments, boolean isInterface) {
super(target, result, arguments);
- this.itf = itf;
+ this.isInterface = isInterface;
+ }
+
+ @Override
+ public boolean getInterfaceBit() {
+ return isInterface;
}
@Override
@@ -75,7 +82,8 @@
@Override
public void buildCf(CfBuilder builder) {
- builder.add(new CfInvoke(org.objectweb.asm.Opcodes.INVOKESPECIAL, getInvokedMethod(), itf));
+ builder.add(
+ new CfInvoke(org.objectweb.asm.Opcodes.INVOKESPECIAL, getInvokedMethod(), isInterface));
}
@Override
@@ -95,7 +103,10 @@
@Override
public DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver) {
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType) {
if (appView.appInfo().hasLiveness() && context != null) {
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
AppInfoWithLiveness appInfo = appViewWithLiveness.appInfo();
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
index 4739d83..2d95115 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.code;
+import static com.android.tools.r8.ir.analysis.type.TypeAnalysis.toRefinedReceiverType;
+
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.InvokeVirtualRange;
import com.android.tools.r8.graph.AppView;
@@ -14,7 +16,8 @@
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.TypeAnalysis;
+import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
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;
@@ -29,6 +32,11 @@
}
@Override
+ public boolean getInterfaceBit() {
+ return false;
+ }
+
+ @Override
public int opcode() {
return Opcodes.INVOKE_VIRTUAL;
}
@@ -89,12 +97,20 @@
@Override
public DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver) {
- return lookupSingleTarget(appView, context, receiver, getInvokedMethod());
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType) {
+ return lookupSingleTarget(
+ appView, context, receiverUpperBoundType, receiverLowerBoundType, getInvokedMethod());
}
public static DexEncodedMethod lookupSingleTarget(
- AppView<?> appView, ProgramMethod context, Value receiver, DexMethod method) {
+ AppView<?> appView,
+ ProgramMethod context,
+ TypeElement receiverUpperBoundType,
+ ClassTypeElement receiverLowerBoundType,
+ DexMethod method) {
if (appView.appInfo().hasLiveness()) {
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
return appViewWithLiveness
@@ -104,8 +120,8 @@
context,
false,
appView,
- TypeAnalysis.getRefinedReceiverType(appViewWithLiveness, method, receiver),
- receiver.getDynamicLowerBoundType(appViewWithLiveness));
+ toRefinedReceiverType(receiverUpperBoundType, method, appViewWithLiveness),
+ receiverLowerBoundType);
}
// In D8, allow lookupSingleTarget() to be used for finding final library methods. This is used
// for library modeling.
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 678a569..36b6520 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
@@ -125,6 +125,10 @@
return false;
}
+ if (encodedField.type().isAlwaysNull(appViewWithLiveness)) {
+ return false;
+ }
+
return appInfoWithLiveness.isFieldRead(encodedField)
|| isStoringObjectWithFinalizer(appViewWithLiveness, encodedField);
}
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 b79a063..53af0fc 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
@@ -1173,16 +1173,15 @@
return root.getDynamicUpperBoundType(appView);
}
- // Try to find an alias of the receiver, which is defined by an instruction of the type
- // Assume<DynamicTypeAssumption>.
+ // Try to find an alias of the receiver, which is defined by an instruction of the type Assume.
Value aliasedValue =
getSpecificAliasedValue(value -> !value.isPhi() && value.definition.isAssumeDynamicType());
TypeElement lattice;
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.
+ // If there is an alias of the receiver, which is defined by an Assume instruction that
+ // carries a dynamic type, then use the dynamic type as the refined receiver type.
lattice =
- aliasedValue.definition.asAssumeDynamicType().getAssumption().getDynamicUpperBoundType();
+ aliasedValue.definition.asAssume().getDynamicTypeAssumption().getDynamicUpperBoundType();
// For precision, verify that the dynamic type is at least as precise as the static type.
assert lattice.lessThanOrEqualUpToNullability(type, appView) : type + " < " + lattice;
@@ -1228,12 +1227,11 @@
return null;
}
- // Try to find an alias of the receiver, which is defined by an instruction of the type
- // Assume<DynamicTypeAssumption>.
+ // Try to find an alias of the receiver, which is defined by an instruction of the type Assume.
Value aliasedValue = getSpecificAliasedValue(value -> value.definition.isAssumeDynamicType());
if (aliasedValue != null) {
ClassTypeElement lattice =
- aliasedValue.definition.asAssumeDynamicType().getAssumption().getDynamicLowerBoundType();
+ aliasedValue.definition.asAssume().getDynamicTypeAssumption().getDynamicLowerBoundType();
return lattice != null && type.isDefinitelyNotNull() && lattice.isNullable()
? lattice.asMeetWithNotNull()
: lattice;
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 dba65f7..844ccce 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
@@ -52,6 +52,7 @@
import com.android.tools.r8.ir.desugar.StringConcatRewriter;
import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
+import com.android.tools.r8.ir.optimize.AssumeInserter;
import com.android.tools.r8.ir.optimize.Assumer;
import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization;
import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
@@ -64,7 +65,6 @@
import com.android.tools.r8.ir.optimize.Inliner;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.MemberValuePropagation;
-import com.android.tools.r8.ir.optimize.NonNullTracker;
import com.android.tools.r8.ir.optimize.Outliner;
import com.android.tools.r8.ir.optimize.PeepholeOptimizer;
import com.android.tools.r8.ir.optimize.RedundantFieldLoadElimination;
@@ -292,7 +292,7 @@
assert appView.rootSet() != null;
AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
if (options.enableNonNullTracking) {
- assumers.add(new NonNullTracker(appViewWithLiveness));
+ assumers.add(new AssumeInserter(appViewWithLiveness));
}
this.classInliner =
options.enableClassInlining && options.enableInlining ? new ClassInliner() : null;
@@ -797,8 +797,10 @@
if (outliner != null) {
printPhase("Outlining");
timing.begin("IR conversion phase 3");
- if (outliner.selectMethodsForOutlining()) {
+ ProgramMethodSet methodsSelectedForOutlining = outliner.selectMethodsForOutlining();
+ if (!methodsSelectedForOutlining.isEmpty()) {
forEachSelectedOutliningMethod(
+ methodsSelectedForOutlining,
code -> {
printMethod(code, "IR before outlining (SSA)", null);
outliner.identifyOutlineSites(code);
@@ -808,6 +810,7 @@
appView.appInfo().addSynthesizedClass(outlineClass);
optimizeSynthesizedClass(outlineClass, executorService);
forEachSelectedOutliningMethod(
+ methodsSelectedForOutlining,
code -> {
outliner.applyOutliningCandidate(code);
printMethod(code, "IR after outlining (SSA)", null);
@@ -839,9 +842,6 @@
if (libraryMethodOverrideAnalysis != null) {
libraryMethodOverrideAnalysis.logResults();
}
- if (uninstantiatedTypeOptimization != null) {
- uninstantiatedTypeOptimization.logResults();
- }
if (stringOptimizer != null) {
stringOptimizer.logResult();
}
@@ -898,11 +898,13 @@
}
private void forEachSelectedOutliningMethod(
- Consumer<IRCode> consumer, ExecutorService executorService)
+ ProgramMethodSet methodsSelectedForOutlining,
+ Consumer<IRCode> consumer,
+ ExecutorService executorService)
throws ExecutionException {
assert !options.skipIR;
ThreadUtils.processItems(
- outliner.buildMethodsSelectedForOutlining(),
+ methodsSelectedForOutlining,
method -> {
IRCode code = method.buildIR(appView);
assert code != null;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index e94d07e..f83952c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -29,6 +29,7 @@
import static com.android.tools.r8.ir.code.Opcodes.RETURN;
import static com.android.tools.r8.ir.code.Opcodes.STATIC_GET;
import static com.android.tools.r8.ir.code.Opcodes.STATIC_PUT;
+import static com.android.tools.r8.utils.ObjectUtils.getBooleanOrElse;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
@@ -293,8 +294,18 @@
assert newInValues.size()
== actualTarget.proto.parameters.size() + (actualInvokeType == STATIC ? 0 : 1);
+ // TODO(b/157111832): This bit should be part of the graph lens lookup result.
+ boolean isInterface =
+ getBooleanOrElse(
+ appView.definitionFor(actualTarget.holder), DexClass::isInterface, false);
Invoke newInvoke =
- Invoke.create(actualInvokeType, actualTarget, null, newOutValue, newInValues);
+ Invoke.create(
+ actualInvokeType,
+ actualTarget,
+ null,
+ newOutValue,
+ newInValues,
+ isInterface);
iterator.replaceCurrentInstruction(newInvoke);
if (newOutValue != null && newOutValue.getType() != current.getOutType()) {
affectedPhis.addAll(newOutValue.uniquePhiUsers());
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
index 250737f..53ff67e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
@@ -114,7 +114,7 @@
ResolutionResult resolutionResult =
appView
.appInfoForDesugaring()
- .resolveMethod(invoke.getInvokedMethod(), invoke.isInvokeInterface());
+ .resolveMethod(invoke.getInvokedMethod(), invoke.getInterfaceBit());
if (resolutionResult.isFailedResolution()) {
continue;
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index f41bdce..d203a12 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -540,16 +540,6 @@
boolean holderIsInterface() {
InternalOptions options = appView.options();
- if (!options.isGeneratingClassFiles()) {
- // When generating dex the value of this flag on invokes does not matter (unused).
- // We cannot know if definitionFor(implMethod.holder) is null or not in that case,
- // so we cannot set the flag and just return false.
- return false;
- }
- // The only case where we do Lambda desugaring with Cf to Cf is in L8.
- // If the compilation is not coreLibraryCompilation, then the assertion
- // implMethodHolder != null may fail, hence the assertion.
- assert options.cfToCfDesugar;
DexMethod implMethod = descriptor.implHandle.asMethod();
DexClass implMethodHolder = appView.definitionFor(implMethod.holder);
if (implMethodHolder == 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 9102f53..7f45db3 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
@@ -7,7 +7,6 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.Assume;
-import com.android.tools.r8.ir.code.Assume.DynamicTypeAssumption;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -34,8 +33,7 @@
private final IRCode code;
private final Set<Value> affectedValues = Sets.newIdentityHashSet();
- private final Set<Assume<DynamicTypeAssumption>> assumeDynamicTypeInstructionsToRemove =
- Sets.newIdentityHashSet();
+ private final Set<Assume> assumeDynamicTypeInstructionsToRemove = Sets.newIdentityHashSet();
private boolean mayHaveIntroducedTrivialPhi = false;
@@ -48,21 +46,20 @@
return mayHaveIntroducedTrivialPhi;
}
- public void markForRemoval(Assume<DynamicTypeAssumption> assumeDynamicTypeInstruction) {
+ public void markForRemoval(Assume assumeDynamicTypeInstruction) {
assumeDynamicTypeInstructionsToRemove.add(assumeDynamicTypeInstruction);
}
public void markUsersForRemoval(Value value) {
for (Instruction user : value.aliasedUsers()) {
if (user.isAssumeDynamicType()) {
- markForRemoval(user.asAssumeDynamicType());
+ markForRemoval(user.asAssume());
}
}
}
public void removeIfMarked(
- Assume<DynamicTypeAssumption> assumeDynamicTypeInstruction,
- InstructionListIterator instructionIterator) {
+ Assume assumeDynamicTypeInstruction, InstructionListIterator instructionIterator) {
if (assumeDynamicTypeInstructionsToRemove.remove(assumeDynamicTypeInstruction)) {
Value inValue = assumeDynamicTypeInstruction.src();
Value outValue = assumeDynamicTypeInstruction.outValue();
@@ -91,7 +88,7 @@
while (instructionIterator.hasNext()) {
Instruction instruction = instructionIterator.next();
if (instruction.isAssumeDynamicType()) {
- removeIfMarked(instruction.asAssumeDynamicType(), instructionIterator);
+ removeIfMarked(instruction.asAssume(), instructionIterator);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
similarity index 66%
rename from src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
rename to src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
index e08aeae..611a0a1 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssumeInserter.java
@@ -48,11 +48,11 @@
import java.util.function.BiPredicate;
import java.util.function.Predicate;
-public class NonNullTracker implements Assumer {
+public class AssumeInserter implements Assumer {
private final AppView<? extends AppInfoWithClassHierarchy> appView;
- public NonNullTracker(AppView<? extends AppInfoWithClassHierarchy> appView) {
+ public AssumeInserter(AppView<? extends AppInfoWithClassHierarchy> appView) {
this.appView = appView;
}
@@ -67,7 +67,7 @@
BasicBlockIterator blockIterator,
Predicate<BasicBlock> blockTester,
Timing timing) {
- timing.begin("Insert assume not null instructions");
+ timing.begin("Insert assume instructions");
internalInsertAssumeInstructionsInBlocks(code, blockIterator, blockTester, timing);
timing.end();
}
@@ -77,54 +77,54 @@
BasicBlockIterator blockIterator,
Predicate<BasicBlock> blockTester,
Timing timing) {
- timing.begin("Part 1: Compute non null values");
- NonNullValues nonNullValues = computeNonNullValues(code, blockIterator, blockTester);
+ timing.begin("Part 1: Compute assumed values");
+ AssumedValues assumedValues = computeAssumedValues(code, blockIterator, blockTester);
timing.end();
- if (nonNullValues.isEmpty()) {
+ if (assumedValues.isEmpty()) {
return;
}
timing.begin("Part 2: Remove redundant assume instructions");
- removeRedundantAssumeInstructions(nonNullValues);
+ removeRedundantAssumeInstructions(assumedValues);
timing.end();
timing.begin("Part 3: Compute dominated users");
Map<Instruction, Set<Value>> redundantKeys =
- computeDominanceForNonNullValues(code, nonNullValues);
+ computeDominanceForAssumedValues(code, assumedValues);
timing.end();
- if (nonNullValues.isEmpty()) {
+ if (assumedValues.isEmpty()) {
return;
}
timing.begin("Part 4: Remove redundant dominated assume instructions");
- removeRedundantDominatedAssumeInstructions(nonNullValues, redundantKeys);
+ removeRedundantDominatedAssumeInstructions(assumedValues, redundantKeys);
timing.end();
- if (nonNullValues.isEmpty()) {
+ if (assumedValues.isEmpty()) {
return;
}
timing.begin("Part 5: Materialize assume instructions");
- materializeAssumeInstructions(code, nonNullValues);
+ materializeAssumeInstructions(code, assumedValues);
timing.end();
}
- private NonNullValues computeNonNullValues(
+ private AssumedValues computeAssumedValues(
IRCode code, BasicBlockIterator blockIterator, Predicate<BasicBlock> blockTester) {
- NonNullValues.Builder nonNullValuesBuilder = new NonNullValues.Builder();
+ AssumedValues.Builder assumedValuesBuilder = new AssumedValues.Builder();
while (blockIterator.hasNext()) {
BasicBlock block = blockIterator.next();
if (blockTester.test(block)) {
- computeNonNullValuesInBlock(code, blockIterator, block, nonNullValuesBuilder);
+ computeAssumedValuesInBlock(code, blockIterator, block, assumedValuesBuilder);
}
}
- return nonNullValuesBuilder.build();
+ return assumedValuesBuilder.build();
}
- private void computeNonNullValuesInBlock(
+ private void computeAssumedValuesInBlock(
IRCode code,
BasicBlockIterator blockIterator,
BasicBlock block,
- NonNullValues.Builder nonNullValuesBuilder) {
+ AssumedValues.Builder assumedValuesBuilder) {
// Add non-null after
// 1) instructions that implicitly indicate receiver/array is not null.
// 2) invocations that are guaranteed to return a non-null value.
@@ -138,9 +138,9 @@
// Case (1), instructions that implicitly indicate receiver/array is not null.
if (current.throwsOnNullInput()) {
Value inValue = current.getNonNullInput();
- if (nonNullValuesBuilder.isMaybeNull(inValue)
+ if (assumedValuesBuilder.isMaybeNull(inValue)
&& isNullableReferenceTypeWithOtherNonDebugUsers(inValue, current)) {
- nonNullValuesBuilder.addNonNullValueWithUnknownDominance(current, inValue);
+ assumedValuesBuilder.addNonNullValueWithUnknownDominance(current, inValue);
needsAssumeInstruction = true;
}
}
@@ -151,7 +151,7 @@
if (invoke.hasOutValue() || !invoke.getInvokedMethod().proto.parameters.isEmpty()) {
// Case (2) and (3).
needsAssumeInstruction |=
- computeNonNullValuesFromSingleTarget(code, invoke, nonNullValuesBuilder);
+ computeAssumedValuesFromSingleTarget(code, invoke, assumedValuesBuilder);
}
} else if (current.isFieldGet()) {
// Case (4), field-get instructions that are guaranteed to read a non-null value.
@@ -163,7 +163,7 @@
FieldOptimizationInfo optimizationInfo = encodedField.getOptimizationInfo();
if (optimizationInfo.getDynamicUpperBoundType() != null
&& optimizationInfo.getDynamicUpperBoundType().isDefinitelyNotNull()) {
- nonNullValuesBuilder.addNonNullValueKnownToDominateAllUsers(current, outValue);
+ assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(current, outValue);
needsAssumeInstruction = true;
}
}
@@ -182,7 +182,7 @@
assert !instructionIterator.hasNext();
assert instructionIterator.peekPrevious().isGoto();
assert blockIterator.peekPrevious() == insertionBlock;
- computeNonNullValuesInBlock(code, blockIterator, insertionBlock, nonNullValuesBuilder);
+ computeAssumedValuesInBlock(code, blockIterator, insertionBlock, assumedValuesBuilder);
return;
}
if (current.instructionTypeCanThrow()) {
@@ -194,16 +194,16 @@
If ifInstruction = block.exit().asIf();
if (ifInstruction != null && ifInstruction.isNonTrivialNullTest()) {
Value lhs = ifInstruction.lhs();
- if (nonNullValuesBuilder.isMaybeNull(lhs)
+ if (assumedValuesBuilder.isMaybeNull(lhs)
&& isNullableReferenceTypeWithOtherNonDebugUsers(lhs, ifInstruction)
&& ifInstruction.targetFromNonNullObject().getPredecessors().size() == 1) {
- nonNullValuesBuilder.addNonNullValueWithUnknownDominance(ifInstruction, lhs);
+ assumedValuesBuilder.addNonNullValueWithUnknownDominance(ifInstruction, lhs);
}
}
}
- private boolean computeNonNullValuesFromSingleTarget(
- IRCode code, InvokeMethod invoke, NonNullValues.Builder nonNullValuesBuilder) {
+ private boolean computeAssumedValuesFromSingleTarget(
+ IRCode code, InvokeMethod invoke, AssumedValues.Builder assumedValuesBuilder) {
DexEncodedMethod singleTarget = invoke.lookupSingleTarget(appView, code.context());
if (singleTarget == null) {
return false;
@@ -217,7 +217,7 @@
if (outValue != null
&& optimizationInfo.neverReturnsNull()
&& isNullableReferenceTypeWithNonDebugUsers(outValue)) {
- nonNullValuesBuilder.addNonNullValueKnownToDominateAllUsers(invoke, outValue);
+ assumedValuesBuilder.addNonNullValueKnownToDominateAllUsers(invoke, outValue);
needsAssumeInstruction = true;
}
@@ -228,9 +228,9 @@
for (int i = start; i < invoke.arguments().size(); i++) {
if (nonNullParamOnNormalExits.get(i)) {
Value argument = invoke.getArgument(i);
- if (nonNullValuesBuilder.isMaybeNull(argument)
+ if (assumedValuesBuilder.isMaybeNull(argument)
&& isNullableReferenceTypeWithOtherNonDebugUsers(argument, invoke)) {
- nonNullValuesBuilder.addNonNullValueWithUnknownDominance(invoke, argument);
+ assumedValuesBuilder.addNonNullValueWithUnknownDominance(invoke, argument);
needsAssumeInstruction = true;
}
}
@@ -239,33 +239,33 @@
return needsAssumeInstruction;
}
- private void removeRedundantAssumeInstructions(NonNullValues nonNullValues) {
- nonNullValues.removeIf(
- (instruction, nonNullValue) -> {
- if (nonNullValue.isPhi()) {
+ private void removeRedundantAssumeInstructions(AssumedValues assumedValues) {
+ assumedValues.removeIf(
+ (instruction, assumedValue) -> {
+ if (assumedValue.isPhi()) {
return false;
}
- Instruction definition = nonNullValue.definition;
- return definition != instruction && nonNullValues.contains(definition, nonNullValue);
+ Instruction definition = assumedValue.definition;
+ return definition != instruction && assumedValues.contains(definition, assumedValue);
});
}
- private Map<Instruction, Set<Value>> computeDominanceForNonNullValues(
- IRCode code, NonNullValues nonNullValues) {
+ private Map<Instruction, Set<Value>> computeDominanceForAssumedValues(
+ IRCode code, AssumedValues assumedValues) {
Map<Instruction, Set<Value>> redundantKeys = new IdentityHashMap<>();
LazyDominatorTree lazyDominatorTree = new LazyDominatorTree(code);
Map<BasicBlock, Set<BasicBlock>> dominatedBlocksCache = new IdentityHashMap<>();
- nonNullValues.computeDominance(
- (instruction, nonNullValue) -> {
- Set<Value> alreadyNonNullValues = redundantKeys.get(instruction);
- if (alreadyNonNullValues != null && alreadyNonNullValues.contains(nonNullValue)) {
- // Returning redundant() will cause the entry (instruction, nonNullValue) to be removed.
- return NonNullDominance.redundant();
+ assumedValues.computeDominance(
+ (instruction, assumedValue) -> {
+ Set<Value> alreadyAssumedValues = redundantKeys.get(instruction);
+ if (alreadyAssumedValues != null && alreadyAssumedValues.contains(assumedValue)) {
+ // Returning redundant() will cause the entry (instruction, assumedValue) to be removed.
+ return AssumedDominance.redundant();
}
// If this value is non-null since its definition, then it is known to dominate all users.
- if (nonNullValue == instruction.outValue()) {
- return NonNullDominance.everything();
+ if (assumedValue == instruction.outValue()) {
+ return AssumedDominance.everything();
}
// If we learn that this value is known to be non-null in the same block as it is defined,
@@ -273,12 +273,12 @@
// check, then the non-null-value is known to dominate all other users than the null check
// itself.
BasicBlock block = instruction.getBlock();
- if (nonNullValue.getBlock() == block
+ if (assumedValue.getBlock() == block
&& block.exit().isGoto()
&& !instruction.getBlock().hasCatchHandlers()) {
InstructionIterator iterator = instruction.getBlock().iterator();
- if (!nonNullValue.isPhi()) {
- iterator.nextUntil(x -> x != nonNullValue.definition);
+ if (!assumedValue.isPhi()) {
+ iterator.nextUntil(x -> x != assumedValue.definition);
iterator.previous();
}
boolean isUsedBeforeInstruction = false;
@@ -287,23 +287,23 @@
if (current == instruction) {
break;
}
- if (current.inValues().contains(nonNullValue)
- || current.getDebugValues().contains(nonNullValue)) {
+ if (current.inValues().contains(assumedValue)
+ || current.getDebugValues().contains(assumedValue)) {
isUsedBeforeInstruction = true;
break;
}
}
if (!isUsedBeforeInstruction) {
- return NonNullDominance.everythingElse();
+ return AssumedDominance.everythingElse();
}
}
// Otherwise, we need a dominator tree to determine which users are dominated.
BasicBlock insertionBlock = getInsertionBlock(instruction);
- assert nonNullValue.hasPhiUsers()
- || nonNullValue.uniqueUsers().stream().anyMatch(user -> user != instruction)
- || nonNullValue.isArgument();
+ assert assumedValue.hasPhiUsers()
+ || assumedValue.uniqueUsers().stream().anyMatch(user -> user != instruction)
+ || assumedValue.isArgument();
// Find all users of the original value that are dominated by either the current block
// or the new split-off block. Since NPE can be explicitly caught, nullness should be
@@ -313,8 +313,8 @@
dominatedBlocksCache.computeIfAbsent(
insertionBlock, x -> dominatorTree.dominatedBlocks(x, Sets.newIdentityHashSet()));
- NonNullDominance.Builder dominance = NonNullDominance.builder(nonNullValue);
- for (Instruction user : nonNullValue.uniqueUsers()) {
+ AssumedDominance.Builder dominance = AssumedDominance.builder(assumedValue);
+ for (Instruction user : assumedValue.uniqueUsers()) {
if (user != instruction && dominatedBlocks.contains(user.getBlock())) {
if (user.getBlock() == insertionBlock && insertionBlock == block) {
Instruction first = block.iterator().nextUntil(x -> x == instruction || x == user);
@@ -329,12 +329,12 @@
// after the given user in case the user is also a null check for the non-null-value.
redundantKeys
.computeIfAbsent(user, ignore -> Sets.newIdentityHashSet())
- .add(nonNullValue);
+ .add(assumedValue);
}
}
- for (Phi user : nonNullValue.uniquePhiUsers()) {
+ for (Phi user : assumedValue.uniquePhiUsers()) {
IntList dominatedPredecessorIndices =
- findDominatedPredecessorIndexesInPhi(user, nonNullValue, dominatedBlocks);
+ findDominatedPredecessorIndexesInPhi(user, assumedValue, dominatedBlocks);
if (!dominatedPredecessorIndices.isEmpty()) {
dominance.addDominatedPhiUser(user, dominatedPredecessorIndices);
}
@@ -345,30 +345,31 @@
}
private void removeRedundantDominatedAssumeInstructions(
- NonNullValues nonNullValues, Map<Instruction, Set<Value>> redundantKeys) {
- nonNullValues.removeAll(redundantKeys);
+ AssumedValues assumedValues, Map<Instruction, Set<Value>> redundantKeys) {
+ assumedValues.removeAll(redundantKeys);
}
- private void materializeAssumeInstructions(IRCode code, NonNullValues nonNullValues) {
+ private void materializeAssumeInstructions(IRCode code, AssumedValues assumedValues) {
Set<Value> affectedValues = Sets.newIdentityHashSet();
Map<BasicBlock, Map<Instruction, List<Instruction>>> pendingInsertions =
new IdentityHashMap<>();
- nonNullValues.forEach(
- (instruction, nonNullValue, dominance) -> {
+ assumedValues.forEach(
+ (instruction, assumedValue, assumedValueInfo) -> {
BasicBlock block = instruction.getBlock();
BasicBlock insertionBlock = getInsertionBlock(instruction);
+ AssumedDominance dominance = assumedValueInfo.getDominance();
Value newValue =
code.createValue(
- nonNullValue.getType().asReferenceType().asMeetWithNotNull(),
- nonNullValue.getLocalInfo());
+ assumedValue.getType().asReferenceType().asMeetWithNotNull(),
+ assumedValue.getLocalInfo());
if (dominance.isEverything()) {
- nonNullValue.replaceUsers(newValue);
+ assumedValue.replaceUsers(newValue);
} else if (dominance.isEverythingElse()) {
- nonNullValue.replaceSelectiveInstructionUsers(newValue, user -> user != instruction);
- nonNullValue.replacePhiUsers(newValue);
+ assumedValue.replaceSelectiveInstructionUsers(newValue, user -> user != instruction);
+ assumedValue.replacePhiUsers(newValue);
} else if (dominance.isSomething()) {
- SomethingNonNullDominance somethingDominance = dominance.asSomething();
+ SomethingAssumedDominance somethingDominance = dominance.asSomething();
somethingDominance
.getDominatedPhiUsers()
.forEach(
@@ -376,22 +377,22 @@
IntListIterator iterator = indices.iterator();
while (iterator.hasNext()) {
Value operand = user.getOperand(iterator.nextInt());
- if (operand != nonNullValue) {
+ if (operand != assumedValue) {
assert operand.isDefinedByInstructionSatisfying(
Instruction::isAssumeNonNull);
iterator.remove();
}
}
});
- nonNullValue.replaceSelectiveUsers(
+ assumedValue.replaceSelectiveUsers(
newValue,
somethingDominance.getDominatedUsers(),
somethingDominance.getDominatedPhiUsers());
}
affectedValues.addAll(newValue.affectedValues());
- Assume<NonNullAssumption> assumeInstruction =
- Assume.createAssumeNonNullInstruction(newValue, nonNullValue, instruction, appView);
+ Assume assumeInstruction =
+ Assume.createAssumeNonNullInstruction(newValue, assumedValue, instruction, appView);
assumeInstruction.setPosition(instruction.getPosition());
if (insertionBlock != block) {
insertionBlock.listIterator(code).add(assumeInstruction);
@@ -431,8 +432,8 @@
}
private IntList findDominatedPredecessorIndexesInPhi(
- Phi user, Value knownToBeNonNullValue, Set<BasicBlock> dominatedBlocks) {
- assert user.getOperands().contains(knownToBeNonNullValue);
+ Phi user, Value assumedValue, Set<BasicBlock> dominatedBlocks) {
+ assert user.getOperands().contains(assumedValue);
List<Value> operands = user.getOperands();
List<BasicBlock> predecessors = user.getBlock().getPredecessors();
assert operands.size() == predecessors.size();
@@ -446,7 +447,7 @@
BasicBlock predecessor = predecessorIterator.next();
// When this phi is chosen to be known-to-be-non-null value,
// check if the corresponding predecessor is dominated by the block where non-null is added.
- if (operand == knownToBeNonNullValue && dominatedBlocks.contains(predecessor)) {
+ if (operand == assumedValue && dominatedBlocks.contains(predecessor)) {
predecessorIndexes.add(index);
}
@@ -479,47 +480,70 @@
return false;
}
- static class NonNullValues {
+ static class AssumedValueInfo {
+
+ AssumedDominance dominance;
+ NonNullAssumption nonNullAssumption;
+
+ AssumedValueInfo(AssumedDominance dominance) {
+ this.dominance = dominance;
+ }
+
+ AssumedDominance getDominance() {
+ return dominance;
+ }
+
+ void setDominance(AssumedDominance dominance) {
+ this.dominance = dominance;
+ }
+
+ void setNotNull() {
+ nonNullAssumption = NonNullAssumption.get();
+ }
+ }
+
+ static class AssumedValues {
/**
* A mapping from each instruction to the (in and out) values that are guaranteed to be non-null
* by the instruction. Each non-null value is subsequently mapped to the set of users that it
* dominates.
*/
- Map<Instruction, Map<Value, NonNullDominance>> nonNullValues;
+ Map<Instruction, Map<Value, AssumedValueInfo>> assumedValues;
- public NonNullValues(Map<Instruction, Map<Value, NonNullDominance>> nonNullValues) {
- this.nonNullValues = nonNullValues;
+ public AssumedValues(Map<Instruction, Map<Value, AssumedValueInfo>> assumedValues) {
+ this.assumedValues = assumedValues;
}
public static Builder builder() {
return new Builder();
}
- void computeDominance(BiFunction<Instruction, Value, NonNullDominance> function) {
- Iterator<Entry<Instruction, Map<Value, NonNullDominance>>> outerIterator =
- nonNullValues.entrySet().iterator();
+ void computeDominance(BiFunction<Instruction, Value, AssumedDominance> function) {
+ Iterator<Entry<Instruction, Map<Value, AssumedValueInfo>>> outerIterator =
+ assumedValues.entrySet().iterator();
while (outerIterator.hasNext()) {
- Entry<Instruction, Map<Value, NonNullDominance>> outerEntry = outerIterator.next();
+ Entry<Instruction, Map<Value, AssumedValueInfo>> outerEntry = outerIterator.next();
Instruction instruction = outerEntry.getKey();
- Map<Value, NonNullDominance> dominancePerValue = outerEntry.getValue();
- Iterator<Entry<Value, NonNullDominance>> innerIterator =
+ Map<Value, AssumedValueInfo> dominancePerValue = outerEntry.getValue();
+ Iterator<Entry<Value, AssumedValueInfo>> innerIterator =
dominancePerValue.entrySet().iterator();
while (innerIterator.hasNext()) {
- Entry<Value, NonNullDominance> innerEntry = innerIterator.next();
- Value nonNullValue = innerEntry.getKey();
- NonNullDominance dominance = innerEntry.getValue();
+ Entry<Value, AssumedValueInfo> innerEntry = innerIterator.next();
+ Value assumedValue = innerEntry.getKey();
+ AssumedValueInfo assumedValueInfo = innerEntry.getValue();
+ AssumedDominance dominance = assumedValueInfo.dominance;
if (dominance.isEverything()) {
- assert nonNullValue.isDefinedByInstructionSatisfying(
- definition -> definition.outValue() == nonNullValue);
+ assert assumedValue.isDefinedByInstructionSatisfying(
+ definition -> definition.outValue() == assumedValue);
continue;
}
assert dominance.isUnknown();
- dominance = function.apply(instruction, nonNullValue);
- if ((dominance.isNothing() && !nonNullValue.isArgument()) || dominance.isUnknown()) {
+ dominance = function.apply(instruction, assumedValue);
+ if ((dominance.isNothing() && !assumedValue.isArgument()) || dominance.isUnknown()) {
innerIterator.remove();
} else {
- innerEntry.setValue(dominance);
+ assumedValueInfo.setDominance(dominance);
}
}
if (dominancePerValue.isEmpty()) {
@@ -528,48 +552,48 @@
}
}
- boolean contains(Instruction instruction, Value nonNullValue) {
- Map<Value, NonNullDominance> dominancePerValue = nonNullValues.get(instruction);
- return dominancePerValue != null && dominancePerValue.containsKey(nonNullValue);
+ boolean contains(Instruction instruction, Value assumedValue) {
+ Map<Value, AssumedValueInfo> dominancePerValue = assumedValues.get(instruction);
+ return dominancePerValue != null && dominancePerValue.containsKey(assumedValue);
}
boolean isEmpty() {
- return nonNullValues.isEmpty();
+ return assumedValues.isEmpty();
}
- void forEach(TriConsumer<Instruction, Value, NonNullDominance> consumer) {
- nonNullValues.forEach(
+ void forEach(TriConsumer<Instruction, Value, AssumedValueInfo> consumer) {
+ assumedValues.forEach(
(instruction, dominancePerValue) ->
dominancePerValue.forEach(
- (nonNullValue, dominance) ->
- consumer.accept(instruction, nonNullValue, dominance)));
+ (assumedValue, assumedValueInfo) ->
+ consumer.accept(instruction, assumedValue, assumedValueInfo)));
}
void removeAll(Map<Instruction, Set<Value>> keys) {
keys.forEach(
(instruction, values) -> {
- Map<Value, NonNullDominance> dominancePerValue = nonNullValues.get(instruction);
+ Map<Value, AssumedValueInfo> dominancePerValue = assumedValues.get(instruction);
if (dominancePerValue != null) {
values.forEach(dominancePerValue::remove);
if (dominancePerValue.isEmpty()) {
- nonNullValues.remove(instruction);
+ assumedValues.remove(instruction);
}
}
});
}
void removeIf(BiPredicate<Instruction, Value> predicate) {
- Iterator<Entry<Instruction, Map<Value, NonNullDominance>>> outerIterator =
- nonNullValues.entrySet().iterator();
+ Iterator<Entry<Instruction, Map<Value, AssumedValueInfo>>> outerIterator =
+ assumedValues.entrySet().iterator();
while (outerIterator.hasNext()) {
- Entry<Instruction, Map<Value, NonNullDominance>> outerEntry = outerIterator.next();
+ Entry<Instruction, Map<Value, AssumedValueInfo>> outerEntry = outerIterator.next();
Instruction instruction = outerEntry.getKey();
- Map<Value, NonNullDominance> dominancePerValue = outerEntry.getValue();
- Iterator<Entry<Value, NonNullDominance>> innerIterator =
+ Map<Value, AssumedValueInfo> dominancePerValue = outerEntry.getValue();
+ Iterator<Entry<Value, AssumedValueInfo>> innerIterator =
dominancePerValue.entrySet().iterator();
while (innerIterator.hasNext()) {
- Value nonNullValue = innerIterator.next().getKey();
- if (predicate.test(instruction, nonNullValue)) {
+ Value assumedValue = innerIterator.next().getKey();
+ if (predicate.test(instruction, assumedValue)) {
innerIterator.remove();
}
}
@@ -581,40 +605,42 @@
static class Builder {
- private final Map<Instruction, Map<Value, NonNullDominance>> nonNullValues =
+ private final Map<Instruction, Map<Value, AssumedValueInfo>> assumedValues =
new LinkedHashMap<>();
// Used to avoid unnecessary block splitting during phase 1.
- private final Set<Value> nonNullValuesKnownToDominateAllUsers = Sets.newIdentityHashSet();
+ private final Set<Value> assumedValuesKnownToDominateAllUsers = Sets.newIdentityHashSet();
- private void add(Instruction instruction, Value nonNullValue, NonNullDominance dominance) {
- nonNullValues
+ private void addNonNullValue(
+ Instruction instruction, Value nonNullValue, AssumedDominance dominance) {
+ assumedValues
.computeIfAbsent(instruction, ignore -> new LinkedHashMap<>())
- .put(nonNullValue, dominance);
+ .computeIfAbsent(nonNullValue, ignore -> new AssumedValueInfo(dominance))
+ .setNotNull();
if (dominance.isEverything()) {
- nonNullValuesKnownToDominateAllUsers.add(nonNullValue);
+ assumedValuesKnownToDominateAllUsers.add(nonNullValue);
}
}
void addNonNullValueKnownToDominateAllUsers(Instruction instruction, Value nonNullValue) {
- add(instruction, nonNullValue, NonNullDominance.everything());
+ addNonNullValue(instruction, nonNullValue, AssumedDominance.everything());
}
void addNonNullValueWithUnknownDominance(Instruction instruction, Value nonNullValue) {
- add(instruction, nonNullValue, NonNullDominance.unknown());
+ addNonNullValue(instruction, nonNullValue, AssumedDominance.unknown());
}
public boolean isMaybeNull(Value value) {
- return !nonNullValuesKnownToDominateAllUsers.contains(value);
+ return !assumedValuesKnownToDominateAllUsers.contains(value);
}
- public NonNullValues build() {
- return new NonNullValues(nonNullValues);
+ public AssumedValues build() {
+ return new AssumedValues(assumedValues);
}
}
}
- abstract static class NonNullDominance {
+ abstract static class AssumedDominance {
boolean isEverything() {
return false;
@@ -632,7 +658,7 @@
return false;
}
- SomethingNonNullDominance asSomething() {
+ SomethingAssumedDominance asSomething() {
return null;
}
@@ -640,76 +666,76 @@
return false;
}
- public static Builder builder(Value nonNullValue) {
- return new Builder(nonNullValue);
+ public static Builder builder(Value assumedValue) {
+ return new Builder(assumedValue);
}
- public static EverythingNonNullDominance everything() {
- return EverythingNonNullDominance.getInstance();
+ public static EverythingAssumedDominance everything() {
+ return EverythingAssumedDominance.getInstance();
}
- public static EverythingElseNonNullDominance everythingElse() {
- return EverythingElseNonNullDominance.getInstance();
+ public static EverythingElseAssumedDominance everythingElse() {
+ return EverythingElseAssumedDominance.getInstance();
}
- public static NothingNonNullDominance nothing() {
- return NothingNonNullDominance.getInstance();
+ public static NothingAssumedDominance nothing() {
+ return NothingAssumedDominance.getInstance();
}
- public static UnknownNonNullDominance redundant() {
+ public static UnknownAssumedDominance redundant() {
return unknown();
}
- public static SomethingNonNullDominance something(
+ public static SomethingAssumedDominance something(
Set<Instruction> dominatedUsers, Map<Phi, IntList> dominatedPhiUsers) {
- return new SomethingNonNullDominance(dominatedUsers, dominatedPhiUsers);
+ return new SomethingAssumedDominance(dominatedUsers, dominatedPhiUsers);
}
- public static UnknownNonNullDominance unknown() {
- return UnknownNonNullDominance.getInstance();
+ public static UnknownAssumedDominance unknown() {
+ return UnknownAssumedDominance.getInstance();
}
static class Builder {
- private final Value nonNullValue;
+ private final Value assumedValue;
private final Set<Instruction> dominatedUsers = Sets.newIdentityHashSet();
private final Map<Phi, IntList> dominatedPhiUsers = new IdentityHashMap<>();
- private Builder(Value nonNullValue) {
- this.nonNullValue = nonNullValue;
+ private Builder(Value assumedValue) {
+ this.assumedValue = assumedValue;
}
void addDominatedUser(Instruction user) {
- assert nonNullValue.uniqueUsers().contains(user);
+ assert assumedValue.uniqueUsers().contains(user);
assert !dominatedUsers.contains(user);
dominatedUsers.add(user);
}
void addDominatedPhiUser(Phi user, IntList dominatedPredecessorIndices) {
- assert nonNullValue.uniquePhiUsers().contains(user);
+ assert assumedValue.uniquePhiUsers().contains(user);
assert !dominatedPhiUsers.containsKey(user);
dominatedPhiUsers.put(user, dominatedPredecessorIndices);
}
- NonNullDominance build() {
+ AssumedDominance build() {
if (dominatedUsers.isEmpty() && dominatedPhiUsers.isEmpty()) {
return nothing();
}
- assert dominatedUsers.size() < nonNullValue.uniqueUsers().size()
- || dominatedPhiUsers.size() < nonNullValue.uniquePhiUsers().size();
+ assert dominatedUsers.size() < assumedValue.uniqueUsers().size()
+ || dominatedPhiUsers.size() < assumedValue.uniquePhiUsers().size();
return something(dominatedUsers, dominatedPhiUsers);
}
}
}
- static class EverythingNonNullDominance extends NonNullDominance {
+ static class EverythingAssumedDominance extends AssumedDominance {
- private static final EverythingNonNullDominance INSTANCE = new EverythingNonNullDominance();
+ private static final EverythingAssumedDominance INSTANCE = new EverythingAssumedDominance();
- private EverythingNonNullDominance() {}
+ private EverythingAssumedDominance() {}
- public static EverythingNonNullDominance getInstance() {
+ public static EverythingAssumedDominance getInstance() {
return INSTANCE;
}
@@ -719,14 +745,14 @@
}
}
- static class EverythingElseNonNullDominance extends NonNullDominance {
+ static class EverythingElseAssumedDominance extends AssumedDominance {
- private static final EverythingElseNonNullDominance INSTANCE =
- new EverythingElseNonNullDominance();
+ private static final EverythingElseAssumedDominance INSTANCE =
+ new EverythingElseAssumedDominance();
- private EverythingElseNonNullDominance() {}
+ private EverythingElseAssumedDominance() {}
- public static EverythingElseNonNullDominance getInstance() {
+ public static EverythingElseAssumedDominance getInstance() {
return INSTANCE;
}
@@ -736,13 +762,13 @@
}
}
- static class NothingNonNullDominance extends NonNullDominance {
+ static class NothingAssumedDominance extends AssumedDominance {
- private static final NothingNonNullDominance INSTANCE = new NothingNonNullDominance();
+ private static final NothingAssumedDominance INSTANCE = new NothingAssumedDominance();
- private NothingNonNullDominance() {}
+ private NothingAssumedDominance() {}
- public static NothingNonNullDominance getInstance() {
+ public static NothingAssumedDominance getInstance() {
return INSTANCE;
}
@@ -752,12 +778,12 @@
}
}
- static class SomethingNonNullDominance extends NonNullDominance {
+ static class SomethingAssumedDominance extends AssumedDominance {
private final Set<Instruction> dominatedUsers;
private final Map<Phi, IntList> dominatedPhiUsers;
- SomethingNonNullDominance(
+ SomethingAssumedDominance(
Set<Instruction> dominatedUsers, Map<Phi, IntList> dominatedPhiUsers) {
this.dominatedUsers = dominatedUsers;
this.dominatedPhiUsers = dominatedPhiUsers;
@@ -777,18 +803,18 @@
}
@Override
- SomethingNonNullDominance asSomething() {
+ SomethingAssumedDominance asSomething() {
return this;
}
}
- static class UnknownNonNullDominance extends NonNullDominance {
+ static class UnknownAssumedDominance extends AssumedDominance {
- private static final UnknownNonNullDominance INSTANCE = new UnknownNonNullDominance();
+ private static final UnknownAssumedDominance INSTANCE = new UnknownAssumedDominance();
- private UnknownNonNullDominance() {}
+ private UnknownAssumedDominance() {}
- public static UnknownNonNullDominance getInstance() {
+ public static UnknownAssumedDominance getInstance() {
return INSTANCE;
}
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 d05d64e..9708120 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
@@ -19,8 +19,6 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.SingleValue;
import com.android.tools.r8.ir.code.Assume;
-import com.android.tools.r8.ir.code.Assume.DynamicTypeAssumption;
-import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
import com.android.tools.r8.ir.code.ConstNumber;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -112,7 +110,7 @@
SingleResolutionResult resolutionResult =
appView
.appInfo()
- .resolveMethod(invokedMethod, invoke.isInvokeInterface())
+ .resolveMethod(invokedMethod, invoke.getInterfaceBit())
.asSingleResolution();
if (resolutionResult == null) {
return;
@@ -309,7 +307,7 @@
return;
}
Set<Value> affectedValues = Sets.newIdentityHashSet();
- List<Assume<?>> assumeInstructions = new LinkedList<>();
+ List<Assume> assumeInstructions = new LinkedList<>();
List<Instruction> constants = new LinkedList<>();
int argumentsSeen = 0;
InstructionListIterator iterator = code.entryBlock().listIterator(code);
@@ -356,7 +354,7 @@
specializedArg = code.createValue(originalArg.getType());
affectedValues.addAll(originalArg.affectedValues());
originalArg.replaceUsers(specializedArg);
- Assume<DynamicTypeAssumption> assumeType =
+ Assume assumeType =
Assume.createAssumeDynamicTypeInstruction(
dynamicUpperBoundType, null, specializedArg, originalArg, instr, appView);
assumeType.setPosition(instr.getPosition());
@@ -372,7 +370,7 @@
code.createValue(specializedArg.getType().asReferenceType().asMeetWithNotNull());
affectedValues.addAll(specializedArg.affectedValues());
specializedArg.replaceUsers(nonNullArg);
- Assume<NonNullAssumption> assumeNotNull =
+ Assume assumeNotNull =
Assume.createAssumeNonNullInstruction(nonNullArg, specializedArg, instr, appView);
assumeNotNull.setPosition(instr.getPosition());
assumeInstructions.add(assumeNotNull);
@@ -387,7 +385,7 @@
+ code.method().method.getArity()
+ ", static: "
+ code.method().isStatic();
- // After packed Argument instructions, add Assume<?> and constant instructions.
+ // After packed Argument instructions, add Assume and constant instructions.
assert !iterator.peekPrevious().isArgument();
iterator.previous();
assert iterator.peekPrevious().isArgument();
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 52844be..172a6b3 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
@@ -176,8 +176,8 @@
public static void removeAssumeInstructions(AppView<?> appView, IRCode code) {
// We need to update the types of all values whose definitions depend on a non-null value.
- // This is needed to preserve soundness of the types after the Assume<NonNullAssumption>
- // instructions have been removed.
+ // This is needed to preserve soundness of the types after the Assume instructions have been
+ // removed.
//
// As an example, consider a check-cast instruction on the form "z = (T) y". If y used to be
// defined by a NonNull instruction, then the type analysis could have used this information
@@ -201,7 +201,7 @@
//
// x.foo()
if (instruction.isAssume()) {
- Assume<?> assumeInstruction = instruction.asAssume();
+ Assume assumeInstruction = instruction.asAssume();
Value src = assumeInstruction.src();
Value dest = assumeInstruction.outValue();
@@ -1507,8 +1507,8 @@
TypeElement dynamicType =
aliasedValue
.definition
- .asAssumeDynamicType()
- .getAssumption()
+ .asAssume()
+ .getDynamicTypeAssumption()
.getDynamicUpperBoundType();
if (dynamicType.isDefinitelyNull()) {
result = InstanceOfResult.FALSE;
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 5893a3b..c4bf62f 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
@@ -15,6 +15,7 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
@@ -113,6 +114,7 @@
@Override
public boolean passesInliningConstraints(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod singleTarget,
Reason reason,
WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
@@ -167,7 +169,7 @@
}
// Abort inlining attempt if method -> target access is not right.
- if (!inliner.hasInliningAccess(method, singleTarget)) {
+ if (resolutionResult.isAccessibleFrom(method, appView.appInfo()).isPossiblyFalse()) {
whyAreYouNotInliningReporter.reportInaccessible();
return false;
}
@@ -254,6 +256,7 @@
@Override
public InlineAction computeInlining(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod singleTarget,
ProgramMethod context,
ClassInitializationAnalysis classInitializationAnalysis,
@@ -277,7 +280,8 @@
return null;
}
- if (!passesInliningConstraints(invoke, singleTarget, reason, whyAreYouNotInliningReporter)) {
+ if (!passesInliningConstraints(
+ invoke, resolutionResult, singleTarget, reason, whyAreYouNotInliningReporter)) {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
index 8117d6c..7752d6c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Assume;
-import com.android.tools.r8.ir.code.Assume.NonNullAssumption;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.CheckCast;
import com.android.tools.r8.ir.code.DominatorTree;
@@ -78,7 +77,7 @@
// ...
// non_null_rcv <- non-null rcv_c // <- Update the input rcv to the non-null, too.
if (current.isAssumeNonNull()) {
- Assume<NonNullAssumption> nonNull = current.asAssumeNonNull();
+ Assume nonNull = current.asAssume();
Instruction origin = nonNull.origin();
if (origin.isInvokeInterface()
&& !origin.asInvokeInterface().getReceiver().hasLocalInfo()
@@ -126,7 +125,11 @@
DexMethod invokedMethod = invoke.getInvokedMethod();
DexEncodedMethod newSingleTarget =
InvokeVirtual.lookupSingleTarget(
- appView, context, invoke.getReceiver(), invokedMethod);
+ appView,
+ context,
+ invoke.getReceiver().getDynamicUpperBoundType(appView),
+ invoke.getReceiver().getDynamicLowerBoundType(appView),
+ invokedMethod);
if (newSingleTarget == singleTarget) {
it.replaceCurrentInstruction(
new InvokeVirtual(invokedMethod, invoke.outValue(), invoke.arguments()));
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 4aabc5b..6e2d9c7 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
@@ -15,7 +15,6 @@
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Assume;
-import com.android.tools.r8.ir.code.Assume.DynamicTypeAssumption;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.BasicBlockIterator;
import com.android.tools.r8.ir.code.IRCode;
@@ -143,7 +142,7 @@
outValue.replaceUsers(specializedOutValue);
// Insert AssumeDynamicType instruction.
- Assume<DynamicTypeAssumption> assumeInstruction =
+ Assume assumeInstruction =
Assume.createAssumeDynamicTypeInstruction(
dynamicUpperBoundType,
dynamicLowerBoundType,
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 a48dece..eea6b7c 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
@@ -7,6 +7,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
@@ -42,6 +43,7 @@
@Override
public boolean passesInliningConstraints(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod candidate,
Reason reason,
WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
@@ -60,15 +62,18 @@
@Override
public InlineAction computeInlining(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod singleTarget,
ProgramMethod context,
ClassInitializationAnalysis classInitializationAnalysis,
WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
- return computeForInvoke(invoke, whyAreYouNotInliningReporter);
+ return computeForInvoke(invoke, resolutionResult, whyAreYouNotInliningReporter);
}
private InlineAction computeForInvoke(
- InvokeMethod invoke, WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
+ InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
+ WhyAreYouNotInliningReporter whyAreYouNotInliningReporter) {
Inliner.InliningInfo info = invokesToInline.get(invoke);
if (info == null) {
return null;
@@ -80,7 +85,7 @@
// with neverInline() flag.
assert !info.target.getDefinition().getOptimizationInfo().neverInline();
assert passesInliningConstraints(
- invoke, info.target, Reason.FORCE, whyAreYouNotInliningReporter);
+ invoke, resolutionResult, info.target, Reason.FORCE, whyAreYouNotInliningReporter);
return new InlineAction(info.target, invoke, Reason.FORCE);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/IdempotentFunctionCallCanonicalizer.java b/src/main/java/com/android/tools/r8/ir/optimize/IdempotentFunctionCallCanonicalizer.java
index abf12f7..10d17e7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/IdempotentFunctionCallCanonicalizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/IdempotentFunctionCallCanonicalizer.java
@@ -139,7 +139,7 @@
SingleResolutionResult resolutionResult =
appInfoWithLiveness
- .resolveMethod(invoke.getInvokedMethod(), invoke.isInvokeInterface())
+ .resolveMethod(invoke.getInvokedMethod(), invoke.getInterfaceBit())
.asSingleResolution();
if (resolutionResult == null
|| resolutionResult
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 fe6cbb4..17cea8b 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
@@ -20,6 +20,7 @@
import com.android.tools.r8.graph.GraphLense;
import com.android.tools.r8.graph.NestMemberClassAttribute;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.proto.ProtoInliningReasonStrategy;
import com.android.tools.r8.ir.analysis.type.Nullability;
@@ -199,29 +200,6 @@
return false;
}
- boolean hasInliningAccess(ProgramMethod context, ProgramMethod target) {
- if (!isVisibleWithFlags(target.getHolderType(), context, target.getDefinition().accessFlags)) {
- return false;
- }
- // The class needs also to be visible for us to have access.
- return isVisibleWithFlags(target.getHolderType(), context, target.getHolder().accessFlags);
- }
-
- private boolean isVisibleWithFlags(DexType target, ProgramMethod context, AccessFlags<?> flags) {
- if (flags.isPublic()) {
- return true;
- }
- if (flags.isPrivate()) {
- return NestUtils.sameNest(target, context.getHolderType(), appView);
- }
- if (flags.isProtected()) {
- return appView.appInfo().isSubtype(context.getHolderType(), target)
- || target.isSamePackage(context.getHolderType());
- }
- // package-private
- return target.isSamePackage(context.getHolderType());
- }
-
public synchronized boolean isDoubleInlineSelectedTarget(ProgramMethod method) {
return doubleInlineSelectedTargets.contains(method);
}
@@ -975,6 +953,17 @@
if (current.isInvokeMethod()) {
InvokeMethod invoke = current.asInvokeMethod();
// TODO(b/142116551): This should be equivalent to invoke.lookupSingleTarget()!
+
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .resolveMethod(invoke.getInvokedMethod(), invoke.getInterfaceBit())
+ .asSingleResolution();
+ if (resolutionResult == null) {
+ continue;
+ }
+
+ // TODO(b/156853206): Should not duplicate resolution.
ProgramMethod singleTarget = oracle.lookupSingleTarget(invoke, context);
if (singleTarget == null) {
WhyAreYouNotInliningReporter.handleInvokeWithUnknownTarget(invoke, appView, context);
@@ -989,6 +978,7 @@
InlineAction action =
oracle.computeInlining(
invoke,
+ resolutionResult,
singleTarget,
context,
classInitializationAnalysis,
@@ -1084,7 +1074,7 @@
blockIterator.next();
}
} else if (current.isAssumeDynamicType()) {
- assumeDynamicTypeRemover.removeIfMarked(current.asAssumeDynamicType(), iterator);
+ assumeDynamicTypeRemover.removeIfMarked(current.asAssume(), iterator);
}
}
}
@@ -1160,7 +1150,7 @@
// Add non-null IRs only to the inlinee blocks.
if (options.enableNonNullTracking) {
- Assumer nonNullTracker = new NonNullTracker(appView);
+ Assumer nonNullTracker = new AssumeInserter(appView);
applyAssumerToInlinee(nonNullTracker, code, blockIterator, block, inlineeBlocks, timing);
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
index a9e4736..5518ab7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.optimize;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
@@ -23,12 +24,14 @@
boolean passesInliningConstraints(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod candidate,
Reason reason,
WhyAreYouNotInliningReporter whyAreYouNotInliningReporter);
InlineAction computeInlining(
InvokeMethod invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod singleTarget,
ProgramMethod context,
ClassInitializationAnalysis classInitializationAnalysis,
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 8222958..51c1c01 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
@@ -357,13 +357,10 @@
return;
}
- // Check if the field is pinned. In that case, it could be written by reflection.
- if (appView.appInfo().isPinned(target.field)) {
- return;
- }
-
AbstractValue abstractValue;
- if (appView.appInfo().isFieldWrittenByFieldPutInstruction(target)) {
+ if (field.type.isAlwaysNull(appView)) {
+ abstractValue = appView.abstractValueFactory().createSingleNumberValue(0);
+ } else if (appView.appInfo().isFieldWrittenByFieldPutInstruction(target)) {
abstractValue = target.getOptimizationInfo().getAbstractValue();
if (abstractValue.isUnknown() && !target.isStatic()) {
AbstractValue abstractReceiverValue =
@@ -485,12 +482,15 @@
private void replaceInstancePutByNullCheckIfNeverRead(
IRCode code, InstructionListIterator iterator, InstancePut current) {
- DexEncodedField target = appView.appInfo().resolveField(current.getField()).getResolvedField();
- if (target == null || appView.appInfo().isFieldRead(target)) {
+ DexEncodedField field = appView.appInfo().resolveField(current.getField()).getResolvedField();
+ if (field == null || field.isStatic()) {
return;
}
- if (target.isStatic()) {
+ // If the field is read, we can't remove the instance-put unless the value of the field is known
+ // to be null (in which case the instance-put is a no-op because it assigns the field the same
+ // value as its default value).
+ if (!field.type().isAlwaysNull(appView) && appView.appInfo().isFieldRead(field)) {
return;
}
@@ -500,11 +500,14 @@
private void replaceStaticPutByInitClassIfNeverRead(
IRCode code, InstructionListIterator iterator, StaticPut current) {
DexEncodedField field = appView.appInfo().resolveField(current.getField()).getResolvedField();
- if (field == null || appView.appInfo().isFieldRead(field)) {
+ if (field == null || !field.isStatic()) {
return;
}
- if (!field.isStatic()) {
+ // If the field is read, we can't remove the static-put unless the value of the field is known
+ // to be null (in which case the static-put is a no-op because it assigns the field the same
+ // value as its default value).
+ if (!field.type().isAlwaysNull(appView) && appView.appInfo().isFieldRead(field)) {
return;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NestUtils.java b/src/main/java/com/android/tools/r8/ir/optimize/NestUtils.java
index 3cd05c5..9db947a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NestUtils.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NestUtils.java
@@ -57,7 +57,7 @@
assert encodedMethod.isPrivateMethod();
// Call to private method which has now to be interface/virtual
// (Now call to nest member private method).
- if (invoke.isInterface()) {
+ if (invoke.getInterfaceBit()) {
iterator.replaceCurrentInstruction(
new InvokeInterface(method, invoke.outValue(), invoke.inValues()));
} else {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 0ac7f7b..d9eb7f2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -66,14 +66,11 @@
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.ProgramMethodEquivalence;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.StringUtils.BraceType;
-import com.android.tools.r8.utils.collections.LongLivedProgramMethodSetBuilder;
+import com.android.tools.r8.utils.collections.LongLivedProgramMethodMultisetBuilder;
+import com.android.tools.r8.utils.collections.ProgramMethodMultiset;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.HashMultiset;
-import com.google.common.collect.Multiset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@@ -98,10 +95,9 @@
* where each list of methods corresponds to methods containing an outlining candidate.
* <li>Second, {@link Outliner#selectMethodsForOutlining()} is called to retain the lists of
* methods found in the first step that are large enough (see {@link InternalOptions#outline}
- * {@link OutlineOptions#threshold}), and the methods to be further analyzed for outlining is
- * returned by {@link Outliner#buildMethodsSelectedForOutlining}. Each selected method is then
- * converted back to IR and passed to {@link Outliner#identifyOutlineSites(IRCode)}, which
- * then stores concrete outlining candidates in {@link Outliner#outlineSites}.
+ * {@link OutlineOptions#threshold}). Each selected method is then converted back to IR and
+ * passed to {@link Outliner#identifyOutlineSites(IRCode)}, which then stores concrete
+ * outlining candidates in {@link Outliner#outlineSites}.
* <li>Third, {@link Outliner#buildOutlinerClass(DexType)} is called to construct the <em>outline
* support class</em> containing a static helper method for each outline candidate that occurs
* frequently enough. Each selected method is then converted to IR, passed to {@link
@@ -112,10 +108,8 @@
public class Outliner {
/** Result of first step (see {@link Outliner#createOutlineMethodIdentifierGenerator()}. */
- private final List<Multiset<Wrapper<ProgramMethod>>> candidateMethodLists = new ArrayList<>();
- /** Result of second step (see {@link Outliner#selectMethodsForOutlining()}. */
- private final LongLivedProgramMethodSetBuilder<?> methodsSelectedForOutlining =
- LongLivedProgramMethodSetBuilder.create();
+ private final List<LongLivedProgramMethodMultisetBuilder> candidateMethodLists =
+ new ArrayList<>();
/** Result of second step (see {@link Outliner#selectMethodsForOutlining()}. */
private final Map<Outline, List<ProgramMethod>> outlineSites = new HashMap<>();
/** Result of third step (see {@link Outliner#buildOutlinerClass(DexType)}. */
@@ -1138,12 +1132,12 @@
// TODO(sgjesse): This does not take several usages in the same method into account.
private class OutlineMethodIdentifier extends OutlineSpotter {
- private final Map<Outline, Multiset<Wrapper<ProgramMethod>>> candidateMap;
+ private final Map<Outline, LongLivedProgramMethodMultisetBuilder> candidateMap;
OutlineMethodIdentifier(
ProgramMethod method,
BasicBlock block,
- Map<Outline, Multiset<Wrapper<ProgramMethod>>> candidateMap) {
+ Map<Outline, LongLivedProgramMethodMultisetBuilder> candidateMap) {
super(method, block);
this.candidateMap = candidateMap;
}
@@ -1151,14 +1145,12 @@
@Override
protected void handle(int start, int end, Outline outline) {
synchronized (candidateMap) {
- candidateMap
- .computeIfAbsent(outline, this::addOutlineMethodList)
- .add(ProgramMethodEquivalence.get().wrap(method));
+ candidateMap.computeIfAbsent(outline, this::addOutlineMethodList).add(method);
}
}
- private Multiset<Wrapper<ProgramMethod>> addOutlineMethodList(Outline outline) {
- Multiset<Wrapper<ProgramMethod>> result = HashMultiset.create();
+ private LongLivedProgramMethodMultisetBuilder addOutlineMethodList(Outline outline) {
+ LongLivedProgramMethodMultisetBuilder result = LongLivedProgramMethodMultisetBuilder.create();
candidateMethodLists.add(result);
return result;
}
@@ -1284,14 +1276,19 @@
// out-value of invokes to null), this map must not be used except for identifying methods
// potentially relevant to outlining. OutlineMethodIdentifier will add method lists to
// candidateMethodLists whenever it adds an entry to candidateMap.
- Map<Outline, Multiset<Wrapper<ProgramMethod>>> candidateMap = new HashMap<>();
+ Map<Outline, LongLivedProgramMethodMultisetBuilder> candidateMap = new HashMap<>();
assert candidateMethodLists.isEmpty();
assert outlineMethodIdentifierGenerator == null;
outlineMethodIdentifierGenerator =
code -> {
- assert !code.method().getCode().isOutlineCode();
+ ProgramMethod context = code.context();
+ assert !context.getDefinition().getCode().isOutlineCode();
+ if (appView.options().featureSplitConfiguration != null
+ && appView.options().featureSplitConfiguration.isInFeature(context.getHolder())) {
+ return;
+ }
for (BasicBlock block : code.blocks) {
- new OutlineMethodIdentifier(code.context(), block, candidateMap).process();
+ new OutlineMethodIdentifier(context, block, candidateMap).process();
}
};
}
@@ -1304,31 +1301,26 @@
}
public void identifyOutlineSites(IRCode code) {
- assert !code.method().getCode().isOutlineCode();
- DexProgramClass clazz = code.context().getHolder();
- if (appView.options().featureSplitConfiguration != null
- && appView.options().featureSplitConfiguration.isInFeature(clazz)) {
- return;
- }
+ ProgramMethod context = code.context();
+ assert !context.getDefinition().getCode().isOutlineCode();
+ assert appView.options().featureSplitConfiguration == null
+ || !appView.options().featureSplitConfiguration.isInFeature(context.getHolder());
for (BasicBlock block : code.blocks) {
- new OutlineSiteIdentifier(code.context(), block).process();
+ new OutlineSiteIdentifier(context, block).process();
}
}
- public boolean selectMethodsForOutlining() {
- assert methodsSelectedForOutlining.isEmpty();
+ public ProgramMethodSet selectMethodsForOutlining() {
+ ProgramMethodSet methodsSelectedForOutlining = ProgramMethodSet.create();
assert outlineSites.isEmpty();
- for (Multiset<Wrapper<ProgramMethod>> outlineMethods : candidateMethodLists) {
+ for (LongLivedProgramMethodMultisetBuilder outlineMethods : candidateMethodLists) {
if (outlineMethods.size() >= appView.options().outline.threshold) {
- outlineMethods.forEach(wrapper -> methodsSelectedForOutlining.add(wrapper.get()));
+ ProgramMethodMultiset multiset = outlineMethods.build(appView);
+ multiset.forEachEntry((method, ignore) -> methodsSelectedForOutlining.add(method));
}
}
candidateMethodLists.clear();
- return !methodsSelectedForOutlining.isEmpty();
- }
-
- public ProgramMethodSet buildMethodsSelectedForOutlining() {
- return methodsSelectedForOutlining.build(appView);
+ return methodsSelectedForOutlining;
}
public DexProgramClass buildOutlinerClass(DexType type) {
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 6077882..85f0274 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
@@ -9,9 +9,7 @@
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
-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.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
@@ -23,7 +21,6 @@
import com.android.tools.r8.graph.RewrittenPrototypeDescription.ArgumentInfoCollection;
import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
-import com.android.tools.r8.ir.analysis.TypeChecker;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.FieldInstruction;
@@ -34,7 +31,6 @@
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.MemberPoolCollection.MemberPool;
-import com.android.tools.r8.logging.Log;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
import com.android.tools.r8.utils.Timing;
@@ -103,17 +99,9 @@
private static final MethodSignatureEquivalence equivalence = MethodSignatureEquivalence.get();
private final AppView<AppInfoWithLiveness> appView;
- private final TypeChecker typeChecker;
-
- private int numberOfInstanceGetOrInstancePutWithNullReceiver = 0;
- private int numberOfArrayInstructionsWithNullArray = 0;
- private int numberOfInvokesWithNullArgument = 0;
- private int numberOfInvokesWithNullReceiver = 0;
- private int numberOfMonitorWithNullReceiver = 0;
public UninstantiatedTypeOptimization(AppView<AppInfoWithLiveness> appView) {
this.appView = appView;
- this.typeChecker = new TypeChecker(appView);
}
public UninstantiatedTypeOptimizationGraphLense run(
@@ -353,32 +341,12 @@
if (instruction.throwsOnNullInput()) {
Value couldBeNullValue = instruction.getNonNullInput();
if (isThrowNullCandidate(couldBeNullValue, instruction, appView, code.context())) {
- if (instruction.isInstanceGet() || instruction.isInstancePut()) {
- ++numberOfInstanceGetOrInstancePutWithNullReceiver;
- } else if (instruction.isInvokeMethodWithReceiver()) {
- ++numberOfInvokesWithNullReceiver;
- } else if (instruction.isArrayGet()
- || instruction.isArrayPut()
- || instruction.isArrayLength()) {
- ++numberOfArrayInstructionsWithNullArray;
- } else if (instruction.isMonitor()) {
- ++numberOfMonitorWithNullReceiver;
- } else {
- assert false;
- }
instructionIterator.replaceCurrentInstructionWithThrowNull(
appView, code, blockIterator, blocksToBeRemoved, valuesToNarrow);
continue;
}
}
- if (instruction.isFieldInstruction()) {
- rewriteFieldInstruction(
- instruction.asFieldInstruction(),
- instructionIterator,
- code,
- assumeDynamicTypeRemover,
- valuesToNarrow);
- } else if (instruction.isInvokeMethod()) {
+ if (instruction.isInvokeMethod()) {
rewriteInvoke(
instruction.asInvokeMethod(),
blockIterator,
@@ -421,75 +389,6 @@
return true;
}
- public void logResults() {
- assert Log.ENABLED;
- Log.info(
- getClass(),
- "Number of instance-get/instance-put with null receiver: %s",
- numberOfInstanceGetOrInstancePutWithNullReceiver);
- Log.info(
- getClass(),
- "Number of array instructions with null reference: %s",
- numberOfArrayInstructionsWithNullArray);
- Log.info(
- getClass(), "Number of invokes with null argument: %s", numberOfInvokesWithNullArgument);
- Log.info(
- getClass(), "Number of invokes with null receiver: %s", numberOfInvokesWithNullReceiver);
- Log.info(
- getClass(), "Number of monitor with null receiver: %s", numberOfMonitorWithNullReceiver);
- }
-
- // instance-{get|put} with a null receiver has already been rewritten to `throw null`.
- // At this point, field-instruction whose target field type is uninstantiated will be handled.
- private void rewriteFieldInstruction(
- FieldInstruction instruction,
- InstructionListIterator instructionIterator,
- IRCode code,
- AssumeDynamicTypeRemover assumeDynamicTypeRemover,
- Set<Value> affectedValues) {
- ProgramMethod context = code.context();
- DexField field = instruction.getField();
- DexType fieldType = field.type;
- if (fieldType.isAlwaysNull(appView)) {
- // TODO(b/123857022): Should be possible to use definitionFor().
- DexEncodedField encodedField = appView.appInfo().resolveField(field).getResolvedField();
- if (encodedField == null) {
- return;
- }
-
- boolean instructionCanBeRemoved = !instruction.instructionInstanceCanThrow(appView, context);
-
- BasicBlock block = instruction.getBlock();
- if (instruction.isFieldPut()) {
- if (!typeChecker.checkFieldPut(instruction)) {
- // Broken type hierarchy. See FieldTypeTest#test_brokenTypeHierarchy.
- assert appView.options().testing.allowTypeErrors;
- return;
- }
-
- // We know that the right-hand side must be null, so this is a no-op.
- if (instructionCanBeRemoved) {
- instructionIterator.removeOrReplaceByDebugLocalRead();
- }
- } else {
- if (instructionCanBeRemoved) {
- // Replace the field read by the constant null.
- assumeDynamicTypeRemover.markUsersForRemoval(instruction.outValue());
- affectedValues.addAll(instruction.outValue().affectedValues());
- instructionIterator.replaceCurrentInstruction(code.createConstNull());
- } else {
- replaceOutValueByNull(
- instruction, instructionIterator, code, assumeDynamicTypeRemover, affectedValues);
- }
- }
-
- if (block.hasCatchHandlers()) {
- // This block can no longer throw.
- block.getCatchHandlers().getUniqueTargets().forEach(BasicBlock::unlinkCatchHandler);
- }
- }
- }
-
// invoke instructions with a null receiver has already been rewritten to `throw null`.
// At this point, we attempt to explore non-null-param-or-throw optimization info and replace
// the invocation with `throw null` if an argument is known to be null and the method is going to
@@ -514,7 +413,6 @@
if (argument.isAlwaysNull(appView) && facts.get(i)) {
instructionIterator.replaceCurrentInstructionWithThrowNull(
appView, code, blockIterator, blocksToBeRemoved, affectedValues);
- ++numberOfInvokesWithNullArgument;
return;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 5e378c2..da8c4cc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -19,8 +19,10 @@
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
+import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.AliasedValueConfiguration;
import com.android.tools.r8.ir.code.AssumeAndCheckCastAliasedValueConfiguration;
@@ -281,6 +283,16 @@
if (user.isInvokeMethod()) {
InvokeMethod invokeMethod = user.asInvokeMethod();
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .resolveMethod(invokeMethod.getInvokedMethod(), invokeMethod.getInterfaceBit())
+ .asSingleResolution();
+ if (resolutionResult == null) {
+ return user; // Not eligible.
+ }
+
+ // TODO(b/156853206): Avoid duplicating resolution.
DexEncodedMethod singleTargetMethod = invokeMethod.lookupSingleTarget(appView, method);
if (singleTargetMethod == null) {
return user; // Not eligible.
@@ -320,7 +332,7 @@
InvokeMethodWithReceiver invoke = user.asInvokeMethodWithReceiver();
InliningInfo inliningInfo =
isEligibleDirectVirtualMethodCall(
- invoke, singleTarget, indirectUsers, defaultOracle);
+ invoke, resolutionResult, singleTarget, indirectUsers, defaultOracle);
if (inliningInfo != null) {
methodCallsOnInstance.put(invoke, inliningInfo);
continue;
@@ -529,8 +541,11 @@
continue;
}
+ ClassTypeElement exactReceiverType =
+ ClassTypeElement.create(eligibleClass.type, Nullability.definitelyNotNull(), appView);
ProgramMethod singleTarget =
- invoke.lookupSingleProgramTarget(appView, method, eligibleInstance);
+ invoke.lookupSingleProgramTarget(
+ appView, method, exactReceiverType, exactReceiverType);
if (singleTarget == null || !indirectMethodCallsOnInstance.contains(singleTarget)) {
throw new IllegalClassInlinerStateException();
}
@@ -875,6 +890,7 @@
private InliningInfo isEligibleDirectVirtualMethodCall(
InvokeMethodWithReceiver invoke,
+ SingleResolutionResult resolutionResult,
ProgramMethod singleTarget,
Set<Instruction> indirectUsers,
Supplier<InliningOracle> defaultOracle) {
@@ -892,7 +908,11 @@
if (singleTarget.getDefinition().isLibraryMethodOverride().isTrue()) {
InliningOracle inliningOracle = defaultOracle.get();
if (!inliningOracle.passesInliningConstraints(
- invoke, singleTarget, Reason.SIMPLE, NopWhyAreYouNotInliningReporter.getInstance())) {
+ invoke,
+ resolutionResult,
+ singleTarget,
+ Reason.SIMPLE,
+ NopWhyAreYouNotInliningReporter.getInstance())) {
return null;
}
}
@@ -916,13 +936,16 @@
Pair<Type, DexMethod> invokeInfo = eligibility.callsReceiver.get(0);
Type invokeType = invokeInfo.getFirst();
DexMethod indirectlyInvokedMethod = invokeInfo.getSecond();
- ResolutionResult resolutionResult =
- appView.appInfo().resolveMethodOn(eligibleClass, indirectlyInvokedMethod);
- if (!resolutionResult.isSingleResolution()) {
+ SingleResolutionResult indirectResolutionResult =
+ appView
+ .appInfo()
+ .resolveMethodOn(eligibleClass, indirectlyInvokedMethod)
+ .asSingleResolution();
+ if (indirectResolutionResult == null) {
return null;
}
ProgramMethod indirectSingleTarget =
- resolutionResult.asSingleResolution().getResolutionPair().asProgramMethod();
+ indirectResolutionResult.getResolutionPair().asProgramMethod();
if (!isEligibleIndirectVirtualMethodCall(
indirectlyInvokedMethod, invokeType, indirectSingleTarget)) {
return null;
@@ -1191,24 +1214,28 @@
return false;
}
+ SingleResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .resolveMethod(invoke.getInvokedMethod(), invoke.getInterfaceBit())
+ .asSingleResolution();
+ if (resolutionResult == null) {
+ return false;
+ }
+
// Check if the method is inline-able by standard inliner.
- DexEncodedMethod singleTarget = invoke.lookupSingleTarget(appView, method);
+ // TODO(b/156853206): Should not duplicate resolution.
+ ProgramMethod singleTarget = invoke.lookupSingleProgramTarget(appView, method);
if (singleTarget == null) {
return false;
}
- DexProgramClass holder = asProgramClassOrNull(appView.definitionForHolder(singleTarget));
- if (holder == null) {
- return false;
- }
-
- ProgramMethod singleTargetMethod = new ProgramMethod(holder, singleTarget);
-
InliningOracle oracle = defaultOracle.get();
InlineAction inlineAction =
oracle.computeInlining(
invoke,
- singleTargetMethod,
+ resolutionResult,
+ singleTarget,
method,
ClassInitializationAnalysis.trivial(),
NopWhyAreYouNotInliningReporter.getInstance());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index c179446..379fc28 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -446,20 +446,16 @@
if (dexClass.type != factory.enumType) {
return Reason.UNSUPPORTED_LIBRARY_CALL;
}
- // TODO(b/147860220): Methods toString(), name(), compareTo(), EnumSet and EnumMap may
- // be interesting to model. A the moment rewrite only Enum#ordinal() and Enum#valueOf.
- if (debugLogEnabled) {
- if (singleTarget == factory.enumMethods.compareTo) {
- return Reason.COMPARE_TO_INVOKE;
- }
- if (singleTarget == factory.enumMethods.name) {
- return Reason.NAME_INVOKE;
- }
- if (singleTarget == factory.enumMethods.toString) {
- return Reason.TO_STRING_INVOKE;
- }
- }
- if (singleTarget == factory.enumMethods.ordinal) {
+ // TODO(b/147860220): EnumSet and EnumMap may be interesting to model.
+ if (singleTarget == factory.enumMethods.compareTo) {
+ return Reason.ELIGIBLE;
+ } else if (singleTarget == factory.enumMethods.equals) {
+ return Reason.ELIGIBLE;
+ } else if (singleTarget == factory.enumMethods.name) {
+ return Reason.ELIGIBLE;
+ } else if (singleTarget == factory.enumMethods.toString) {
+ return Reason.ELIGIBLE;
+ } else if (singleTarget == factory.enumMethods.ordinal) {
return Reason.ELIGIBLE;
} else if (singleTarget == factory.enumMethods.constructor) {
// Enum constructor call is allowed only if first call of an enum initializer.
@@ -664,8 +660,6 @@
VALUE_OF_INVOKE,
VALUES_INVOKE,
COMPARE_TO_INVOKE,
- TO_STRING_INVOKE,
- NAME_INVOKE,
UNSUPPORTED_LIBRARY_CALL,
MISSING_INFO_MAP,
INVALID_FIELD_PUT,
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index 6f6fba1..541cd92 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -29,6 +29,7 @@
import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.ArrayAccess;
+import com.android.tools.r8.ir.code.ConstNumber;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
@@ -46,32 +47,32 @@
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.IdentityHashMap;
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.Function;
public class EnumUnboxingRewriter {
public static final String ENUM_UNBOXING_UTILITY_CLASS_NAME = "$r8$EnumUnboxingUtility";
- public static final String ENUM_UNBOXING_UTILITY_ORDINAL = "$enumboxing$ordinal";
- private static final String ENUM_UNBOXING_UTILITY_VALUES = "$enumboxing$values";
+ public static final String ENUM_UNBOXING_UTILITY_METHOD_PREFIX = "$enumboxing$";
private static final int REQUIRED_CLASS_FILE_VERSION = 52;
private final AppView<AppInfoWithLiveness> appView;
private final DexItemFactory factory;
private final EnumValueInfoMapCollection enumsToUnbox;
- private final Map<DexMethod, DexEncodedMethod> extraUtilityMethods = new ConcurrentHashMap<>();
+ private final Map<DexMethod, DexEncodedMethod> utilityMethods = new ConcurrentHashMap<>();
private final Map<DexField, DexEncodedField> extraUtilityFields = new ConcurrentHashMap<>();
private final DexMethod ordinalUtilityMethod;
+ private final DexMethod equalsUtilityMethod;
+ private final DexMethod compareToUtilityMethod;
private final DexMethod valuesUtilityMethod;
- private boolean requiresOrdinalUtilityMethod = false;
- private boolean requiresValuesUtilityMethod = false;
-
EnumUnboxingRewriter(AppView<AppInfoWithLiveness> appView, Set<DexType> enumsToUnbox) {
this.appView = appView;
this.factory = appView.dexItemFactory();
@@ -81,16 +82,28 @@
}
this.enumsToUnbox = builder.build();
+ // Custom methods for java.lang.Enum methods ordinal, equals and compareTo.
this.ordinalUtilityMethod =
factory.createMethod(
factory.enumUnboxingUtilityType,
factory.createProto(factory.intType, factory.intType),
- ENUM_UNBOXING_UTILITY_ORDINAL);
+ ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "ordinal");
+ this.equalsUtilityMethod =
+ factory.createMethod(
+ factory.enumUnboxingUtilityType,
+ factory.createProto(factory.booleanType, factory.intType, factory.intType),
+ ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "equals");
+ this.compareToUtilityMethod =
+ factory.createMethod(
+ factory.enumUnboxingUtilityType,
+ factory.createProto(factory.intType, factory.intType, factory.intType),
+ ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "compareTo");
+ // Custom methods for generated field $VALUES initialization.
this.valuesUtilityMethod =
factory.createMethod(
factory.enumUnboxingUtilityType,
factory.createProto(factory.intArrayType, factory.intType),
- ENUM_UNBOXING_UTILITY_VALUES);
+ ENUM_UNBOXING_UTILITY_METHOD_PREFIX + "values");
}
public EnumValueInfoMapCollection getEnumsToUnbox() {
@@ -104,6 +117,7 @@
return Sets.newIdentityHashSet();
}
assert code.isConsistentSSABeforeTypesAreCorrect();
+ Map<Instruction, DexType> convertedEnums = new IdentityHashMap<>();
Set<Phi> affectedPhis = Sets.newIdentityHashSet();
InstructionListIterator iterator = code.instructionListIterator();
while (iterator.hasNext()) {
@@ -113,14 +127,28 @@
if (instruction.isInvokeMethodWithReceiver()) {
InvokeMethodWithReceiver invokeMethod = instruction.asInvokeMethodWithReceiver();
DexMethod invokedMethod = invokeMethod.getInvokedMethod();
- if (invokedMethod == factory.enumMethods.ordinal
- && isEnumToUnboxOrInt(invokeMethod.getReceiver().getType())) {
- instruction =
- new InvokeStatic(
- ordinalUtilityMethod, invokeMethod.outValue(), invokeMethod.inValues());
- iterator.replaceCurrentInstruction(instruction);
- requiresOrdinalUtilityMethod = true;
- continue;
+ DexType enumType = getEnumTypeOrNull(invokeMethod.getReceiver(), convertedEnums);
+ if (enumType != null) {
+ if (invokedMethod == factory.enumMethods.ordinal) {
+ replaceEnumInvoke(
+ iterator, invokeMethod, ordinalUtilityMethod, m -> synthesizeOrdinalMethod());
+ continue;
+ } else if (invokedMethod == factory.enumMethods.equals) {
+ replaceEnumInvoke(
+ iterator, invokeMethod, equalsUtilityMethod, m -> synthesizeEqualsMethod());
+ continue;
+ } else if (invokedMethod == factory.enumMethods.compareTo) {
+ replaceEnumInvoke(
+ iterator, invokeMethod, compareToUtilityMethod, m -> synthesizeCompareToMethod());
+ continue;
+ } else if (invokedMethod == factory.enumMethods.name
+ || invokedMethod == factory.enumMethods.toString) {
+ DexMethod toStringMethod = computeDefaultToStringUtilityMethod(enumType);
+ iterator.replaceCurrentInstruction(
+ new InvokeStatic(
+ toStringMethod, invokeMethod.outValue(), invokeMethod.arguments()));
+ continue;
+ }
}
// TODO(b/147860220): rewrite also other enum methods.
} else if (instruction.isInvokeStatic()) {
@@ -138,11 +166,13 @@
rewrittenOutValue = code.createValue(TypeElement.getInt());
affectedPhis.addAll(outValue.uniquePhiUsers());
}
- iterator.replaceCurrentInstruction(
+ InvokeStatic invoke =
new InvokeStatic(
valueOfMethod,
rewrittenOutValue,
- Collections.singletonList(invokeStatic.inValues().get(1))));
+ Collections.singletonList(invokeStatic.inValues().get(1)));
+ iterator.replaceCurrentInstruction(invoke);
+ convertedEnums.put(invoke, enumType);
continue;
}
}
@@ -162,33 +192,39 @@
affectedPhis.addAll(staticGet.outValue().uniquePhiUsers());
EnumValueInfo enumValueInfo = enumValueInfoMap.getEnumValueInfo(staticGet.getField());
if (enumValueInfo == null && staticGet.getField().name == factory.enumValuesFieldName) {
- requiresValuesUtilityMethod = true;
+ utilityMethods.computeIfAbsent(
+ valuesUtilityMethod, m -> synthesizeValuesUtilityMethod());
DexField fieldValues = createValuesField(holder);
extraUtilityFields.computeIfAbsent(fieldValues, this::computeValuesEncodedField);
DexMethod methodValues = createValuesMethod(holder);
- extraUtilityMethods.computeIfAbsent(
+ utilityMethods.computeIfAbsent(
methodValues,
m -> computeValuesEncodedMethod(m, fieldValues, enumValueInfoMap.size()));
Value rewrittenOutValue =
code.createValue(
ArrayTypeElement.create(TypeElement.getInt(), definitelyNotNull()));
- iterator.replaceCurrentInstruction(
- new InvokeStatic(methodValues, rewrittenOutValue, ImmutableList.of()));
+ InvokeStatic invoke =
+ new InvokeStatic(methodValues, rewrittenOutValue, ImmutableList.of());
+ iterator.replaceCurrentInstruction(invoke);
+ convertedEnums.put(invoke, holder);
} else {
// Replace by ordinal + 1 for null check (null is 0).
assert enumValueInfo != null
: "Invalid read to " + staticGet.getField().name + ", error during enum analysis";
- iterator.replaceCurrentInstruction(
- code.createIntConstant(enumValueInfo.convertToInt()));
+ ConstNumber intConstant = code.createIntConstant(enumValueInfo.convertToInt());
+ iterator.replaceCurrentInstruction(intConstant);
+ convertedEnums.put(intConstant, holder);
}
}
}
// Rewrite array accesses from MyEnum[] (OBJECT) to int[] (INT).
if (instruction.isArrayAccess()) {
ArrayAccess arrayAccess = instruction.asArrayAccess();
- if (shouldRewriteArrayAccess(arrayAccess)) {
+ DexType enumType = getEnumTypeOrNull(arrayAccess);
+ if (enumType != null) {
instruction = arrayAccess.withMemberType(MemberType.INT);
iterator.replaceCurrentInstruction(instruction);
+ convertedEnums.put(instruction, enumType);
}
assert validateArrayAccess(arrayAccess);
}
@@ -197,6 +233,17 @@
return affectedPhis;
}
+ private void replaceEnumInvoke(
+ InstructionListIterator iterator,
+ InvokeMethodWithReceiver invokeMethod,
+ DexMethod method,
+ Function<DexMethod, DexEncodedMethod> synthesizor) {
+ utilityMethods.computeIfAbsent(method, synthesizor);
+ Instruction instruction =
+ new InvokeStatic(method, invokeMethod.outValue(), invokeMethod.arguments());
+ iterator.replaceCurrentInstruction(instruction);
+ }
+
private boolean validateArrayAccess(ArrayAccess arrayAccess) {
ArrayTypeElement arrayType = arrayAccess.array().getType().asArrayType();
if (arrayType == null) {
@@ -209,14 +256,16 @@
return true;
}
- private boolean isEnumToUnboxOrInt(TypeElement type) {
+ private DexType getEnumTypeOrNull(Value receiver, Map<Instruction, DexType> convertedEnums) {
+ TypeElement type = receiver.getType();
if (type.isInt()) {
- return true;
+ return convertedEnums.get(receiver.definition);
}
if (!type.isClassType()) {
- return false;
+ return null;
}
- return enumsToUnbox.containsEnum(type.asClassType().getClassType());
+ DexType enumType = type.asClassType().getClassType();
+ return enumsToUnbox.containsEnum(enumType) ? enumType : null;
}
public String compatibleName(DexType type) {
@@ -266,22 +315,36 @@
factory.enumUnboxingUtilityType,
factory.createProto(factory.intType, factory.stringType),
"valueOf" + compatibleName(type));
- extraUtilityMethods.computeIfAbsent(valueOf, m -> synthesizeValueOfUtilityMethod(m, type));
+ utilityMethods.computeIfAbsent(valueOf, m -> synthesizeValueOfUtilityMethod(m, type));
return valueOf;
}
- private boolean shouldRewriteArrayAccess(ArrayAccess arrayAccess) {
+ private DexMethod computeDefaultToStringUtilityMethod(DexType type) {
+ assert enumsToUnbox.containsEnum(type);
+ DexMethod toString =
+ factory.createMethod(
+ factory.enumUnboxingUtilityType,
+ factory.createProto(factory.stringType, factory.intType),
+ "toString" + compatibleName(type));
+ utilityMethods.computeIfAbsent(toString, m -> synthesizeToStringUtilityMethod(m, type));
+ return toString;
+ }
+
+ private DexType getEnumTypeOrNull(ArrayAccess arrayAccess) {
ArrayTypeElement arrayType = arrayAccess.array().getType().asArrayType();
if (arrayType == null) {
assert arrayAccess.array().getType().isNullType();
- return false;
+ return null;
}
if (arrayType.getNesting() != 1) {
- return false;
+ return null;
}
TypeElement baseType = arrayType.getBaseType();
- return baseType.isClassType()
- && enumsToUnbox.containsEnum(baseType.asClassType().getClassType());
+ if (!baseType.isClassType()) {
+ return null;
+ }
+ DexType classType = baseType.asClassType().getClassType();
+ return enumsToUnbox.containsEnum(classType) ? classType : null;
}
void synthesizeEnumUnboxingUtilityMethods(
@@ -289,16 +352,9 @@
throws ExecutionException {
// Synthesize a class which holds various utility methods that may be called from the IR
// rewriting. If any of these methods are not used, they will be removed by the Enqueuer.
- List<DexEncodedMethod> requiredMethods = new ArrayList<>(extraUtilityMethods.values());
+ List<DexEncodedMethod> requiredMethods = new ArrayList<>(utilityMethods.values());
// Sort for deterministic order.
requiredMethods.sort((m1, m2) -> m1.method.name.slowCompareTo(m2.method.name));
- if (requiresOrdinalUtilityMethod) {
- requiredMethods.add(synthesizeOrdinalMethod());
- }
- if (requiresValuesUtilityMethod) {
- requiredMethods.add(synthesizeValuesUtilityMethod());
- }
- // TODO(b/147860220): synthesize also other enum methods.
if (requiredMethods.isEmpty()) {
return;
}
@@ -340,6 +396,17 @@
DexProgramClass::checksumFromType);
}
+ private DexEncodedMethod synthesizeToStringUtilityMethod(DexMethod method, DexType enumType) {
+ CfCode cfCode =
+ new EnumUnboxingCfCodeProvider.EnumUnboxingDefaultToStringCfCodeProvider(
+ appView,
+ factory.enumUnboxingUtilityType,
+ enumType,
+ enumsToUnbox.getEnumValueInfoMap(enumType))
+ .generateCfCode();
+ return synthesizeUtilityMethod(cfCode, method, false);
+ }
+
private DexEncodedMethod synthesizeValueOfUtilityMethod(DexMethod method, DexType enumType) {
CfCode cfCode =
new EnumUnboxingCfCodeProvider.EnumUnboxingValueOfCfCodeProvider(
@@ -348,14 +415,7 @@
enumType,
enumsToUnbox.getEnumValueInfoMap(enumType))
.generateCfCode();
- return new DexEncodedMethod(
- method,
- synthesizedMethodAccessFlags(false),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- cfCode,
- REQUIRED_CLASS_FILE_VERSION,
- true);
+ return synthesizeUtilityMethod(cfCode, method, false);
}
// TODO(b/150178516): Add a test for this case.
@@ -374,6 +434,19 @@
return synthesizeUtilityMethod(cfCode, ordinalUtilityMethod, false);
}
+ private DexEncodedMethod synthesizeEqualsMethod() {
+ CfCode cfCode =
+ EnumUnboxingCfMethods.EnumUnboxingMethods_equals(appView.options(), equalsUtilityMethod);
+ return synthesizeUtilityMethod(cfCode, equalsUtilityMethod, false);
+ }
+
+ private DexEncodedMethod synthesizeCompareToMethod() {
+ CfCode cfCode =
+ EnumUnboxingCfMethods.EnumUnboxingMethods_compareTo(
+ appView.options(), compareToUtilityMethod);
+ return synthesizeUtilityMethod(cfCode, compareToUtilityMethod, false);
+ }
+
private DexEncodedMethod synthesizeValuesUtilityMethod() {
CfCode cfCode =
EnumUnboxingCfMethods.EnumUnboxingMethods_values(appView.options(), valuesUtilityMethod);
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 a1a6638..cac5801 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
@@ -1157,7 +1157,7 @@
nullCheckedBlocks.clear();
for (Instruction user : argument.uniqueUsers()) {
if (user.isAssumeNonNull()) {
- nullCheckedBlocks.add(user.asAssumeNonNull().getBlock());
+ nullCheckedBlocks.add(user.asAssume().getBlock());
}
if (user.isIf()
&& user.asIf().isZeroTest()
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
index fa0e683..cdc1793 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Assume;
-import com.android.tools.r8.ir.code.Assume.DynamicTypeAssumption;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.InvokeMethod;
@@ -69,7 +68,7 @@
outValue.replaceUsers(specializedOutValue);
// Insert AssumeDynamicType instruction.
- Assume<DynamicTypeAssumption> assumeInstruction =
+ Assume assumeInstruction =
Assume.createAssumeDynamicTypeInstruction(
dynamicUpperBoundType, null, specializedOutValue, outValue, invoke, appView);
assumeInstruction.setPosition(appView.options().debug ? invoke.getPosition() : Position.none());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
index 499c975..323dd11 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
@@ -40,7 +40,6 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
-import java.util.IdentityHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
@@ -103,7 +102,7 @@
}
final Map<CandidateInfo, LongLivedProgramMethodSetBuilder<?>> referencedFrom =
- new IdentityHashMap<>();
+ new ConcurrentHashMap<>();
// The map storing all the potential candidates for staticizing.
final ConcurrentHashMap<DexType, CandidateInfo> candidates = new ConcurrentHashMap<>();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
index ac915a5..0e0e1c9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
@@ -43,6 +43,7 @@
import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.TraversalContinuation;
+import com.android.tools.r8.utils.collections.LongLivedProgramMethodSetBuilder;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.collect.BiMap;
@@ -228,7 +229,10 @@
ProgramMethodSet referencedFrom;
if (classStaticizer.referencedFrom.containsKey(info)) {
- referencedFrom = classStaticizer.referencedFrom.remove(info).build(appView);
+ LongLivedProgramMethodSetBuilder<?> referencedFromBuilder =
+ classStaticizer.referencedFrom.remove(info);
+ assert referencedFromBuilder != null;
+ referencedFrom = referencedFromBuilder.build(appView);
materializedReferencedFromCollections.put(info, referencedFrom);
} else {
referencedFrom = ProgramMethodSet.empty();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
index 53122b0..a01be35 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
@@ -767,7 +767,7 @@
}
// If there are aliasing instructions, they should be removed before new-instance.
if (instr.isAssume() && buildersToRemove.contains(instr.outValue().getAliasedValue())) {
- Assume<?> assumeInstruction = instr.asAssume();
+ Assume assumeInstruction = instr.asAssume();
Value src = assumeInstruction.src();
Value dest = assumeInstruction.outValue();
dest.replaceUsers(src);
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
index f9f66e8..61bdbbc 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.synthetic;
+import com.android.tools.r8.cf.code.CfConstNull;
import com.android.tools.r8.cf.code.CfConstNumber;
import com.android.tools.r8.cf.code.CfConstString;
import com.android.tools.r8.cf.code.CfFieldInstruction;
@@ -36,6 +37,49 @@
super(appView, holder);
}
+ public static class EnumUnboxingDefaultToStringCfCodeProvider extends EnumUnboxingCfCodeProvider {
+
+ private DexType enumType;
+ private EnumValueInfoMap map;
+
+ public EnumUnboxingDefaultToStringCfCodeProvider(
+ AppView<?> appView, DexType holder, DexType enumType, EnumValueInfoMap map) {
+ super(appView, holder);
+ this.enumType = enumType;
+ this.map = map;
+ }
+
+ @Override
+ public CfCode generateCfCode() {
+ // Generated static method, for class com.x.MyEnum {A,B} would look like:
+ // String UtilityClass#com.x.MyEnum_toString(int i) {
+ // if (i == 1) { return "A";}
+ // if (i == 2) { return "B";}
+ // throw null;
+ DexItemFactory factory = appView.dexItemFactory();
+ List<CfInstruction> instructions = new ArrayList<>();
+
+ // if (i == 1) { return "A";}
+ // if (i == 2) { return "B";}
+ map.forEach(
+ (field, enumValueInfo) -> {
+ CfLabel dest = new CfLabel();
+ instructions.add(new CfLoad(ValueType.fromDexType(factory.intType), 0));
+ instructions.add(new CfConstNumber(enumValueInfo.convertToInt(), ValueType.INT));
+ instructions.add(new CfIf(If.Type.EQ, ValueType.INT, dest));
+ instructions.add(new CfConstString(field.name));
+ instructions.add(new CfReturn(ValueType.OBJECT));
+ instructions.add(dest);
+ });
+
+ // throw null;
+ instructions.add(new CfConstNull());
+ instructions.add(new CfThrow());
+
+ return standardCfCodeFromInstructions(instructions);
+ }
+ }
+
public static class EnumUnboxingValueOfCfCodeProvider extends EnumUnboxingCfCodeProvider {
private DexType enumType;
diff --git a/src/main/java/com/android/tools/r8/relocator/RelocatorCommand.java b/src/main/java/com/android/tools/r8/relocator/RelocatorCommand.java
index e329c4d..b8355c3 100644
--- a/src/main/java/com/android/tools/r8/relocator/RelocatorCommand.java
+++ b/src/main/java/com/android/tools/r8/relocator/RelocatorCommand.java
@@ -21,7 +21,9 @@
import com.android.tools.r8.shaking.ProguardPathList;
import com.android.tools.r8.utils.AbortException;
import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.ExceptionDiagnostic;
+import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.FlagFile;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.Reporter;
@@ -292,19 +294,23 @@
}
public RelocatorCommand build() throws CompilationFailedException {
- try {
- if (printHelp || printVersion) {
- return new RelocatorCommand(printHelp, printVersion);
- }
- reporter.failIfPendingErrors();
- validate();
- reporter.failIfPendingErrors();
- DexItemFactory factory = new DexItemFactory();
- return new RelocatorCommand(
- mapping.build(), app.build(), reporter, factory, consumer, threadCount);
- } catch (AbortException e) {
- throw new CompilationFailedException(e);
- }
+ Box<RelocatorCommand> result = new Box<>();
+ ExceptionUtils.withCompilationHandler(
+ reporter,
+ () -> {
+ if (printHelp || printVersion) {
+ result.set(new RelocatorCommand(printHelp, printVersion));
+ return;
+ }
+ reporter.failIfPendingErrors();
+ validate();
+ reporter.failIfPendingErrors();
+ DexItemFactory factory = new DexItemFactory();
+ result.set(
+ new RelocatorCommand(
+ mapping.build(), app.build(), reporter, factory, consumer, threadCount));
+ });
+ return result.get();
}
// Helper to signify an error.
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 6e8f93b..8a54cca 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -242,6 +242,9 @@
/** Set of types that were found to be missing during the first round of tree shaking. */
private Set<DexType> initialMissingTypes;
+ /** Set of types that was pruned during the first round of tree shaking. */
+ private Set<DexType> initialPrunedTypes;
+
/** Mapping from each unused interface to the set of live types that implements the interface. */
private final Map<DexProgramClass, Set<DexProgramClass>> unusedInterfaceTypes =
new IdentityHashMap<>();
@@ -448,6 +451,11 @@
this.initialMissingTypes = initialMissingTypes;
}
+ public void setInitialPrunedTypes(Set<DexType> initialPrunedTypes) {
+ assert mode.isFinalTreeShaking();
+ this.initialPrunedTypes = initialPrunedTypes;
+ }
+
public void addDeadProtoTypeCandidate(DexType type) {
assert type.isProgramType(appView);
addDeadProtoTypeCandidate(appView.definitionFor(type).asProgramClass());
@@ -2878,13 +2886,12 @@
// Verify the references on the pruned application after type synthesis.
assert verifyReferences(app);
+ assert verifyMissingTypes();
AppInfoWithLiveness appInfoWithLiveness =
new AppInfoWithLiveness(
app,
SetUtils.mapIdentityHashSet(deadProtoTypeCandidates, DexProgramClass::getType),
- // TODO(b/155959821): We should be able to assert that missing types is a subset of
- // initialMissingTypes + synthesized types.
mode.isFinalTreeShaking()
? Sets.union(initialMissingTypes, missingTypes)
: missingTypes,
@@ -2959,6 +2966,22 @@
});
}
+ private boolean verifyMissingTypes() {
+ if (initialMissingTypes == null) {
+ assert !mode.isFinalTreeShaking();
+ return true;
+ }
+ missingTypes.forEach(
+ missingType -> {
+ assert initialMissingTypes.contains(missingType)
+ // TODO(b/157107464): See if we can clean this up.
+ || initialPrunedTypes.contains(missingType)
+ || missingType.isD8R8SynthesizedClassType()
+ : missingType;
+ });
+ return true;
+ }
+
private boolean verifyReferences(DexApplication app) {
WorkList<DexClass> worklist = WorkList.newIdentityWorkList();
for (DexProgramClass clazz : liveTypes.getItems()) {
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
index 743f0df..5ff9c97 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
@@ -23,12 +23,14 @@
AppView<? extends AppInfoWithClassHierarchy> appView,
SubtypingInfo subtypingInfo,
GraphConsumer keptGraphConsumer,
- Set<DexType> initialMissingTypes) {
+ Set<DexType> initialMissingTypes,
+ Set<DexType> initialPrunedTypes) {
Enqueuer enqueuer =
new Enqueuer(appView, subtypingInfo, keptGraphConsumer, Mode.FINAL_TREE_SHAKING);
appView.withProtoShrinker(
shrinker -> enqueuer.setInitialDeadProtoTypes(shrinker.getDeadProtoTypes()));
enqueuer.setInitialMissingTypes(initialMissingTypes);
+ enqueuer.setInitialPrunedTypes(initialPrunedTypes);
return enqueuer;
}
diff --git a/src/main/java/com/android/tools/r8/utils/CfLineToMethodMapper.java b/src/main/java/com/android/tools/r8/utils/CfLineToMethodMapper.java
index 2e34cd7..59a6a14 100644
--- a/src/main/java/com/android/tools/r8/utils/CfLineToMethodMapper.java
+++ b/src/main/java/com/android/tools/r8/utils/CfLineToMethodMapper.java
@@ -18,7 +18,7 @@
public class CfLineToMethodMapper {
- private final Map<String, Int2ReferenceOpenHashMap<String>> sourceMethodMapping = new HashMap<>();
+ private Map<String, Int2ReferenceOpenHashMap<String>> sourceMethodMapping = null;
private final AndroidApp inputApp;
private static final String NAME_DESCRIPTOR_SEPARATOR = ";;";
@@ -28,7 +28,8 @@
public String lookupNameAndDescriptor(String binaryName, int lineNumber)
throws ResourceException {
- if (sourceMethodMapping.isEmpty()) {
+ if (sourceMethodMapping == null) {
+ sourceMethodMapping = new HashMap<>();
readLineNumbersFromClassFiles();
}
Int2ReferenceOpenHashMap<String> lineMappings = sourceMethodMapping.get(binaryName);
diff --git a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
index e5ba3f1..28d1ed5 100644
--- a/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ExceptionUtils.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.position.Position;
+import com.google.common.collect.ObjectArrays;
import java.io.IOException;
import java.nio.file.FileSystemException;
import java.nio.file.Paths;
@@ -97,6 +98,10 @@
suppressed.add(innerMostCause);
innerMostCause = innerMostCause.getCause();
}
+ // Add the full stack as a suppressed stack on the inner cause.
+ if (topMostException != innerMostCause) {
+ innerMostCause.addSuppressed(topMostException);
+ }
// If no abort is seen, the exception is not reported, so report it now.
if (!hasBeenReported) {
@@ -116,10 +121,9 @@
new CompilationFailedException(message.toString(), innerMostCause);
// Replace its stack by the cause stack and insert version info at the top.
String filename = "Version_" + Version.LABEL + ".java";
- rethrow.setStackTrace(
- new StackTraceElement[] {
- new StackTraceElement(Version.class.getSimpleName(), "fakeStackEntry", filename, 0)
- });
+ StackTraceElement versionElement =
+ new StackTraceElement(Version.class.getSimpleName(), "fakeStackEntry", filename, 0);
+ rethrow.setStackTrace(ObjectArrays.concat(versionElement, rethrow.getStackTrace()));
return rethrow;
}
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 43a53c7..8c92acf 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1160,7 +1160,8 @@
|| System.getProperty("com.android.tools.r8.allowTypeErrors") != null;
public boolean allowInvokeErrors = false;
public boolean disableL8AnnotationRemoval = false;
- public boolean allowClassInlinerGracefulExit = true;
+ public boolean allowClassInlinerGracefulExit =
+ System.getProperty("com.android.tools.r8.disallowClassInlinerGracefulExit") == null;
public boolean reportUnusedProguardConfigurationRules = false;
public boolean alwaysUsePessimisticRegisterAllocation = false;
public boolean enableCheckCastAndInstanceOfRemoval = true;
diff --git a/src/main/java/com/android/tools/r8/utils/ObjectUtils.java b/src/main/java/com/android/tools/r8/utils/ObjectUtils.java
new file mode 100644
index 0000000..ac07151
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ObjectUtils.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2020, 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.utils;
+
+import java.util.function.Predicate;
+
+public class ObjectUtils {
+
+ public static <T> boolean getBooleanOrElse(T object, Predicate<T> fn, boolean orElse) {
+ if (object != null) {
+ return fn.test(object);
+ }
+ return orElse;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/Reporter.java b/src/main/java/com/android/tools/r8/utils/Reporter.java
index f7f9d1f..f251b0c 100644
--- a/src/main/java/com/android/tools/r8/utils/Reporter.java
+++ b/src/main/java/com/android/tools/r8/utils/Reporter.java
@@ -5,7 +5,6 @@
import com.android.tools.r8.Diagnostic;
import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.errors.Unreachable;
public class Reporter implements DiagnosticsHandler {
@@ -56,14 +55,13 @@
*/
public RuntimeException fatalError(Diagnostic error) {
error(error);
- failIfPendingErrors();
- throw new Unreachable();
+ throw abort;
}
/** @throws AbortException if any error was reported. */
public synchronized void failIfPendingErrors() {
if (abort != null) {
- throw abort;
+ throw new RuntimeException(abort);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/collections/LongLivedProgramMethodMultisetBuilder.java b/src/main/java/com/android/tools/r8/utils/collections/LongLivedProgramMethodMultisetBuilder.java
new file mode 100644
index 0000000..f3ba06b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/collections/LongLivedProgramMethodMultisetBuilder.java
@@ -0,0 +1,43 @@
+// Copyright (c) 2020, 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.utils.collections;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+
+public class LongLivedProgramMethodMultisetBuilder {
+
+ private final Multiset<DexMethod> backing = HashMultiset.create();
+
+ private LongLivedProgramMethodMultisetBuilder() {}
+
+ public static LongLivedProgramMethodMultisetBuilder create() {
+ return new LongLivedProgramMethodMultisetBuilder();
+ }
+
+ public void add(ProgramMethod method) {
+ backing.add(method.getReference());
+ }
+
+ public int size() {
+ return backing.size();
+ }
+
+ public ProgramMethodMultiset build(AppView<AppInfoWithLiveness> appView) {
+ ProgramMethodMultiset result = ProgramMethodMultiset.createHash();
+ backing.forEachEntry(
+ (oldMethod, occurrences) -> {
+ DexMethod method = appView.graphLense().getRenamedMethodSignature(oldMethod);
+ DexProgramClass holder = appView.definitionForHolder(method).asProgramClass();
+ result.createAndAdd(holder, holder.lookupMethod(method), occurrences);
+ });
+ return result;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodMultiset.java b/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodMultiset.java
new file mode 100644
index 0000000..ae8974c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodMultiset.java
@@ -0,0 +1,39 @@
+// Copyright (c) 2020, 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.utils.collections;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.utils.ProgramMethodEquivalence;
+import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+import java.util.function.ObjIntConsumer;
+
+public class ProgramMethodMultiset {
+
+ private final Multiset<Wrapper<ProgramMethod>> backing;
+
+ private ProgramMethodMultiset(Multiset<Wrapper<ProgramMethod>> backing) {
+ this.backing = backing;
+ }
+
+ public static ProgramMethodMultiset createHash() {
+ return new ProgramMethodMultiset(HashMultiset.create());
+ }
+
+ public void createAndAdd(DexProgramClass holder, DexEncodedMethod method, int occurrences) {
+ backing.add(wrap(new ProgramMethod(holder, method)), occurrences);
+ }
+
+ public void forEachEntry(ObjIntConsumer<ProgramMethod> consumer) {
+ backing.forEachEntry((wrapper, occurrences) -> consumer.accept(wrapper.get(), occurrences));
+ }
+
+ private static Wrapper<ProgramMethod> wrap(ProgramMethod method) {
+ return ProgramMethodEquivalence.get().wrap(method);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/DXTestBuilder.java b/src/test/java/com/android/tools/r8/DXTestBuilder.java
index e621784..9e26ecd 100644
--- a/src/test/java/com/android/tools/r8/DXTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/DXTestBuilder.java
@@ -29,6 +29,8 @@
// Ordered list of injar entries.
private List<Path> injars = new ArrayList<>();
+ private int minApiLevel = -1;
+
private DXTestBuilder(TestState state) {
super(state, D8Command.builder(), Backend.DEX);
}
@@ -51,6 +53,9 @@
Path outJar = dxOutputFolder.resolve("output.jar");
List<String> args = new ArrayList<>();
+ if (minApiLevel >= 0) {
+ args.add("--min-sdk-version=" + minApiLevel);
+ }
args.add("--output=" + outJar.toString());
args.addAll(injars.stream().map(Path::toString).collect(Collectors.toList()));
ProcessResult result =
@@ -118,4 +123,10 @@
injars.addAll(files);
return self();
}
+
+ @Override
+ public DXTestBuilder setMinApi(int minApiLevel) {
+ this.minApiLevel = minApiLevel;
+ return self();
+ }
}
diff --git a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
index ca9abd4..9a36a04 100644
--- a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
+++ b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
@@ -19,6 +19,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.rules.TemporaryFolder;
@@ -57,6 +58,7 @@
private final KotlinTargetVersion targetVersion;
private final List<Path> sources = new ArrayList<>();
private final List<Path> classpath = new ArrayList<>();
+ private final List<String> additionalArguments = new ArrayList<>();
private boolean useJvmAssertions;
private Path output = null;
@@ -84,6 +86,11 @@
return new KotlinCompilerTool(jdk, state, kotlinCompiler, kotlinTargetVersion);
}
+ public KotlinCompilerTool addArguments(String... arguments) {
+ Collections.addAll(additionalArguments, arguments);
+ return this;
+ }
+
public KotlinCompilerTool addSourceFiles(Path... files) {
return addSourceFiles(Arrays.asList(files));
}
@@ -181,6 +188,7 @@
.map(Path::toString)
.collect(Collectors.joining(isWindows() ? ";" : ":")));
}
+ cmdline.addAll(additionalArguments);
ProcessBuilder builder = new ProcessBuilder(cmdline);
return ToolHelper.runProcess(builder);
}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
index 9463a49..ba1d485 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -8,7 +8,6 @@
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.debug.DebugTestConfig;
import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -234,7 +233,7 @@
}
@Override
- public ProguardTestBuilder setMinApi(AndroidApiLevel minApiLevel) {
+ public ProguardTestBuilder setMinApi(int minApiLevel) {
if (backend == Backend.DEX) {
throw new Unimplemented("No support for setting min api");
}
diff --git a/src/test/java/com/android/tools/r8/R8CommandTest.java b/src/test/java/com/android/tools/r8/R8CommandTest.java
index 4f8806c..b5c518c 100644
--- a/src/test/java/com/android/tools/r8/R8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/R8CommandTest.java
@@ -120,6 +120,52 @@
}
@Test
+ public void passFeatureSplit() throws Throwable {
+ Path working = temp.getRoot().toPath();
+ Path input = Paths.get(EXAMPLES_BUILD_DIR, "arithmetic.jar").toAbsolutePath();
+ Path inputFeature = Paths.get(EXAMPLES_BUILD_DIR, "arrayaccess.jar").toAbsolutePath();
+ Path library = ToolHelper.getDefaultAndroidJar();
+ Path output = working.resolve("classes.dex");
+ Path featureOutput = working.resolve("feature.zip");
+ assertFalse(Files.exists(output));
+ assertFalse(Files.exists(featureOutput));
+ ProcessResult result =
+ ToolHelper.forkR8(
+ working,
+ input.toString(),
+ "--lib",
+ library.toAbsolutePath().toString(),
+ "--feature",
+ inputFeature.toAbsolutePath().toString(),
+ featureOutput.toAbsolutePath().toString(),
+ "--no-tree-shaking");
+ assertEquals("R8 run failed: " + result.stderr, 0, result.exitCode);
+ assertTrue(Files.exists(output));
+ assertTrue(Files.exists(featureOutput));
+ }
+
+ @Test
+ public void featureOnlyOneArgument() throws Throwable {
+ Path working = temp.getRoot().toPath();
+ Path input = Paths.get(EXAMPLES_BUILD_DIR, "arithmetic.jar").toAbsolutePath();
+ Path inputFeature = Paths.get(EXAMPLES_BUILD_DIR, "arrayaccess.jar").toAbsolutePath();
+ Path library = ToolHelper.getDefaultAndroidJar();
+ Path output = working.resolve("classes.dex");
+ assertFalse(Files.exists(output));
+ ProcessResult result =
+ ToolHelper.forkR8(
+ working,
+ input.toString(),
+ "--lib",
+ library.toAbsolutePath().toString(),
+ "--no-tree-shaking",
+ "--feature",
+ inputFeature.toAbsolutePath().toString());
+ assertNotEquals("R8 run failed: " + result.stderr, 0, result.exitCode);
+ assertTrue(result.stderr.contains("Missing parameter for"));
+ }
+
+ @Test
public void flagsFile() throws Throwable {
Path working = temp.getRoot().toPath();
Path library = ToolHelper.getDefaultAndroidJar();
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index 8ae9c0f..b7869e4 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -215,17 +215,16 @@
}
public T setMinApi(AndroidApiLevel minApiLevel) {
- assert builder.getMinApiLevel() > 0 || this.defaultMinApiLevel != null
- : "Tests must use this method to set min API level, and not"
- + " BaseCompilerCommand.Builder.setMinApiLevel()";
if (backend == Backend.DEX) {
- this.defaultMinApiLevel = null;
- builder.setMinApiLevel(minApiLevel.getLevel());
+ return setMinApi(minApiLevel.getLevel());
}
return self();
}
public T setMinApi(int minApiLevel) {
+ assert builder.getMinApiLevel() > 0 || this.defaultMinApiLevel != null
+ : "Tests must use this method to set min API level, and not"
+ + " BaseCompilerCommand.Builder.setMinApiLevel()";
if (backend == Backend.DEX) {
this.defaultMinApiLevel = null;
builder.setMinApiLevel(minApiLevel);
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
index 0cab77c..ac3ef82 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
@@ -7,6 +7,8 @@
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static org.hamcrest.CoreMatchers.not;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import org.hamcrest.Matcher;
@@ -34,13 +36,29 @@
// Match exact.
- TestDiagnosticMessages assertDiagnosticsMatch(Matcher<Diagnostic>... matchers);
+ default TestDiagnosticMessages assertDiagnosticsMatch(Matcher matcher) {
+ return assertDiagnosticsMatch(Collections.singletonList(matcher));
+ }
- TestDiagnosticMessages assertInfosMatch(Matcher<Diagnostic>... matchers);
+ TestDiagnosticMessages assertDiagnosticsMatch(Collection<Matcher<Diagnostic>> matchers);
- TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic>... matchers);
+ default TestDiagnosticMessages assertInfosMatch(Matcher<Diagnostic> matcher) {
+ return assertInfosMatch(Collections.singletonList(matcher));
+ }
- TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic>... matchers);
+ TestDiagnosticMessages assertInfosMatch(Collection<Matcher<Diagnostic>> matchers);
+
+ default TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic> matcher) {
+ return assertWarningsMatch(Collections.singletonList(matcher));
+ }
+
+ TestDiagnosticMessages assertWarningsMatch(Collection<Matcher<Diagnostic>> matchers);
+
+ default TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic> matcher) {
+ return assertErrorsMatch(Collections.singletonList(matcher));
+ }
+
+ TestDiagnosticMessages assertErrorsMatch(Collection<Matcher<Diagnostic>> matchers);
// Match one.
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
index 2635732..19a700d 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
@@ -12,7 +12,7 @@
import com.android.tools.r8.utils.ListUtils;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -174,7 +174,7 @@
}
private static void assertDiagnosticsMatch(
- Iterable<Diagnostic> diagnostics, String tag, List<Matcher<Diagnostic>> matchers) {
+ Iterable<Diagnostic> diagnostics, String tag, Collection<Matcher<Diagnostic>> matchers) {
// Match is unordered, but we make no attempts to find the maximum match.
int diagnosticsCount = 0;
Set<Diagnostic> matchedDiagnostics = new HashSet<>();
@@ -236,26 +236,26 @@
}
@Override
- public TestDiagnosticMessages assertDiagnosticsMatch(Matcher<Diagnostic>... matchers) {
- assertDiagnosticsMatch(getAllDiagnostics(), "diagnostics", Arrays.asList(matchers));
+ public TestDiagnosticMessages assertDiagnosticsMatch(Collection<Matcher<Diagnostic>> matchers) {
+ assertDiagnosticsMatch(getAllDiagnostics(), "diagnostics", matchers);
return this;
}
@Override
- public TestDiagnosticMessages assertInfosMatch(Matcher<Diagnostic>... matchers) {
- assertDiagnosticsMatch(getInfos(), "infos", Arrays.asList(matchers));
+ public TestDiagnosticMessages assertInfosMatch(Collection<Matcher<Diagnostic>> matchers) {
+ assertDiagnosticsMatch(getInfos(), "infos", matchers);
return this;
}
@Override
- public TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic>... matchers) {
- assertDiagnosticsMatch(getWarnings(), "warnings", Arrays.asList(matchers));
+ public TestDiagnosticMessages assertWarningsMatch(Collection<Matcher<Diagnostic>> matchers) {
+ assertDiagnosticsMatch(getWarnings(), "warnings", matchers);
return this;
}
@Override
- public TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic>... matchers) {
- assertDiagnosticsMatch(getErrors(), "errors", Arrays.asList(matchers));
+ public TestDiagnosticMessages assertErrorsMatch(Collection<Matcher<Diagnostic>> matchers) {
+ assertDiagnosticsMatch(getErrors(), "errors", matchers);
return this;
}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index f19c7ce..3d00718 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -229,17 +229,16 @@
ART_7_0_0_HOST(Version.V7_0_0, Kind.HOST),
ART_8_1_0_TARGET(Version.V8_1_0, Kind.TARGET),
ART_8_1_0_HOST(Version.V8_1_0, Kind.HOST),
+ ART_DEFAULT(Version.DEFAULT, Kind.HOST),
ART_9_0_0_TARGET(Version.V9_0_0, Kind.TARGET),
ART_9_0_0_HOST(Version.V9_0_0, Kind.HOST),
ART_10_0_0_TARGET(Version.V10_0_0, Kind.TARGET),
- ART_10_0_0_HOST(Version.V10_0_0, Kind.HOST),
- ART_DEFAULT(Version.DEFAULT, Kind.HOST);
+ ART_10_0_0_HOST(Version.V10_0_0, Kind.HOST);
private static final ImmutableMap<String, DexVm> SHORT_NAME_MAP =
Arrays.stream(DexVm.values()).collect(ImmutableMap.toImmutableMap(
DexVm::toString, Function.identity()));
-
public enum Version {
V4_0_4("4.0.4"),
V4_4_4("4.4.4"),
@@ -247,9 +246,9 @@
V6_0_1("6.0.1"),
V7_0_0("7.0.0"),
V8_1_0("8.1.0"),
+ DEFAULT("default"),
V9_0_0("9.0.0"),
- V10_0_0("10.0.0"),
- DEFAULT("default");
+ V10_0_0("10.0.0");
Version(String shortName) {
this.shortName = shortName;
@@ -260,7 +259,7 @@
}
public boolean isLatest() {
- return this == DEFAULT;
+ return this == V10_0_0;
}
public boolean isNewerThan(Version other) {
@@ -286,7 +285,7 @@
}
public static Version last() {
- return DEFAULT;
+ return V10_0_0;
}
static {
@@ -896,6 +895,7 @@
return dexVm == DexVm.ART_DEFAULT;
}
+ @Deprecated
public static DexVm getDexVm() {
String artVersion = System.getProperty("dex_vm");
if (artVersion == null) {
diff --git a/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java b/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
index eca0441..069a504 100644
--- a/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
+++ b/src/test/java/com/android/tools/r8/debug/ContinuousSteppingTest.java
@@ -90,10 +90,6 @@
return dexVmVersion.isAtLeast(Version.V7_0_0);
}
- public static boolean fromAndroidO(Version dexVmVersion) {
- return dexVmVersion.isAtLeast(Version.DEFAULT);
- }
-
private static List<Path> findAllJarsIn(Path root) {
try {
return Files.walk(root)
diff --git a/src/test/java/com/android/tools/r8/desugar/b72538146/B72538146.java b/src/test/java/com/android/tools/r8/desugar/b72538146/B72538146.java
index bfc400d..fbb29e8 100644
--- a/src/test/java/com/android/tools/r8/desugar/b72538146/B72538146.java
+++ b/src/test/java/com/android/tools/r8/desugar/b72538146/B72538146.java
@@ -4,47 +4,73 @@
package com.android.tools.r8.desugar.b72538146;
-import static org.junit.Assert.assertEquals;
-import com.android.tools.r8.OutputMode;
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 com.android.tools.r8.VmTestRunner;
-import com.android.tools.r8.VmTestRunner.IgnoreIfVmOlderOrEqualThan;
-import com.android.tools.r8.utils.AndroidApp;
+import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
-@RunWith(VmTestRunner.class)
+@RunWith(Parameterized.class)
public class B72538146 extends TestBase {
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
+ .withAllApiLevels()
+ .build();
+ }
+
+ public B72538146(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
@Test
- @IgnoreIfVmOlderOrEqualThan(Version.V6_0_1)
public void test() throws Exception {
- // Build the main app from source compiled separately using the Android API for classloading.
- AndroidApp.Builder builder = AndroidApp.builder();
- builder.addProgramFile(
- Paths.get("build/test/examplesAndroidApi/classes/classloader/Runner.class"));
- AndroidApp app = compileWithD8(builder.build());
-
// Compile the parent and child applications into separate dex applications.
- Path parent = temp.newFolder("parent").toPath().resolve("classes.zip");
- Path child = temp.newFolder("child").toPath().resolve("classes.zip");
- AndroidApp parentApp = readClasses(
- Parent.class,
- Parent.Inner1.class,
- Parent.Inner2.class,
- Parent.Inner3.class,
- Parent.Inner4.class);
- compileWithD8(parentApp).write(parent, OutputMode.DexIndexed);
+ List<Class<?>> parentClasses =
+ ImmutableList.of(
+ Parent.class,
+ Parent.Inner1.class,
+ Parent.Inner2.class,
+ Parent.Inner3.class,
+ Parent.Inner4.class);
- AndroidApp childApp = readClasses(Child.class);
- compileWithD8(childApp).write(child, OutputMode.DexIndexed);
+ Path parent =
+ testForD8()
+ .addProgramClasses(parentClasses)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .writeToZip();
+
+ Path child =
+ testForD8()
+ .addProgramClasses(Child.class)
+ .addClasspathClasses(parentClasses)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .writeToZip();
// Run the classloader test loading the two dex applications.
- String result = runOnArt(app, "classloader.Runner",
- parent.toString(), child.toString(), "com.android.tools.r8.desugar.b72538146.Child");
- assertEquals("SUCCESS", result);
+ testForD8()
+ .addProgramFiles(
+ Paths.get("build/test/examplesAndroidApi/classes/classloader/Runner.class"))
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(
+ parameters.getRuntime(),
+ "classloader.Runner",
+ parent.toString(),
+ child.toString(),
+ Child.class.getTypeName())
+ .assertSuccessWithOutput("SUCCESS");
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11D8CompilationTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11D8CompilationTest.java
index 6fdfe97..03e7f70 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11D8CompilationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11D8CompilationTest.java
@@ -40,6 +40,7 @@
public void testR8CompiledWithD8() throws Exception {
testForD8()
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_11_JAR)
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
.compile()
.inspect(Java11D8CompilationTest::assertNoNests);
}
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InterfaceMethodDesugaringTests.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InterfaceMethodDesugaringTests.java
index 7151dfa..32cfb18 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InterfaceMethodDesugaringTests.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/InterfaceMethodDesugaringTests.java
@@ -138,7 +138,7 @@
}
@Test(expected = CompilationFailedException.class)
- @IgnoreForRangeOfVmVersions(from = Version.V7_0_0, to = Version.DEFAULT) // No desugaring
+ @IgnoreForRangeOfVmVersions(from = Version.V7_0_0, to = Version.V10_0_0) // No desugaring
public void testInvokeDefault1() throws Exception {
ensureSameOutput(
TestMainDefault1.class.getCanonicalName(),
diff --git a/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java b/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
index 1f19d89..b9eabe6 100644
--- a/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
+++ b/src/test/java/com/android/tools/r8/diagnostics/ErrorDuringIrConversionTest.java
@@ -28,6 +28,7 @@
import java.io.StringWriter;
import java.util.concurrent.atomic.AtomicBoolean;
import org.hamcrest.Matcher;
+import org.hamcrest.core.IsAnything;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -35,8 +36,6 @@
@RunWith(Parameterized.class)
public class ErrorDuringIrConversionTest extends TestBase {
- static final String EXPECTED = StringUtils.lines("Hello, world");
-
static final Origin ORIGIN =
new Origin(Origin.root()) {
@Override
@@ -61,10 +60,21 @@
CompilationFailedException e, Matcher<String> messageMatcher, Matcher<String> stackMatcher) {
// Check that the failure exception exiting the compiler contains origin info in the message.
assertThat(e.getMessage(), messageMatcher);
- // Check that the stack trace has the version marker.
StringWriter writer = new StringWriter();
e.printStackTrace(new PrintWriter(writer));
- assertThat(writer.toString(), stackMatcher);
+ String fullStackTrace = writer.toString();
+ // Extract the top cause stack.
+ int topStackTraceEnd = fullStackTrace.indexOf("Caused by:");
+ String topStackTrace = fullStackTrace.substring(0, topStackTraceEnd);
+ String restStackTrace = fullStackTrace.substring(topStackTraceEnd);
+ // Check that top stack trace always has the version marker.
+ assertThat(topStackTrace, containsString("fakeStackEntry"));
+ // Check that top stack has the D8 entry (from tests the non-renamed entry is ToolHelper.runD8).
+ assertThat(topStackTrace, containsString("com.android.tools.r8.ToolHelper.runD8("));
+ // Check that the stack trace always has the suppressed info.
+ assertThat(restStackTrace, containsString(StringUtils.LINE_SEPARATOR + "\tSuppressed:"));
+ // Custom test checks.
+ assertThat(restStackTrace, stackMatcher);
}
private static void throwNPE() {
@@ -90,9 +100,7 @@
});
} catch (CompilationFailedException e) {
checkCompilationFailedException(
- e,
- containsString(ORIGIN.toString()),
- allOf(containsString("fakeStackEntry"), containsString("throwNPE")));
+ e, containsString(ORIGIN.toString()), containsString("throwNPE"));
return;
}
fail("Expected compilation to fail");
@@ -122,8 +130,7 @@
diagnosticOrigin(Origin.unknown())));
});
} catch (CompilationFailedException e) {
- checkCompilationFailedException(
- e, containsString(ORIGIN.toString()), containsString("fakeStackEntry"));
+ checkCompilationFailedException(e, containsString(ORIGIN.toString()), new IsAnything<>());
return;
}
fail("Expected compilation to fail");
@@ -173,10 +180,9 @@
// There may be no fail-if-error barrier inside any origin association, thus only the
// top level message can be expected here.
containsString("Compilation failed to complete"),
- // The stack trace must contain both the version, the frame for the hook above, and one
+ // The stack trace must contain the reportErrors frame for the hook above, and one
// of the error messages.
allOf(
- containsString("fakeStackEntry"),
containsString("reportErrors"),
anyOf(containsString("FOO!"), containsString("BAR!"), containsString("BAZ!"))));
return;
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java
new file mode 100644
index 0000000..de86bd7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2020, 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+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 EqualsCompareToEnumUnboxingTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final KeepRule enumKeepRules;
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public EqualsCompareToEnumUnboxingTest(
+ TestParameters parameters, boolean enumValueOptimization, KeepRule enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ Class<?> success = EnumEqualscompareTo.class;
+ R8TestRunResult run =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(EqualsCompareToEnumUnboxingTest.class)
+ .addKeepMainRule(EnumEqualscompareTo.class)
+ .enableNeverClassInliningAnnotations()
+ .addKeepRules(enumKeepRules.getKeepRule())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .allowDiagnosticInfoMessages()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspectDiagnosticMessages(
+ m ->
+ assertEnumIsUnboxed(
+ success.getDeclaredClasses()[0], success.getSimpleName(), m))
+ .run(parameters.getRuntime(), success)
+ .assertSuccess();
+ assertLines2By2Correct(run.getStdOut());
+ }
+
+ static class EnumEqualscompareTo {
+
+ @NeverClassInline
+ enum MyEnum {
+ A,
+ B
+ }
+
+ public static void main(String[] args) {
+ equalsTest();
+ compareToTest();
+ }
+
+ @SuppressWarnings({"ConstantConditions", "EqualsWithItself", "ResultOfMethodCallIgnored"})
+ private static void equalsTest() {
+ System.out.println(MyEnum.A.equals(MyEnum.B));
+ System.out.println(false);
+ System.out.println(MyEnum.A.equals(MyEnum.A));
+ System.out.println(true);
+ System.out.println(MyEnum.A.equals(null));
+ System.out.println(false);
+ try {
+ ((MyEnum) null).equals(null);
+ } catch (NullPointerException npe) {
+ System.out.println("npe " + npe.getMessage());
+ System.out.println("npe " + npe.getMessage());
+ }
+ }
+
+ @SuppressWarnings({"ConstantConditions", "EqualsWithItself", "ResultOfMethodCallIgnored"})
+ private static void compareToTest() {
+ System.out.println(MyEnum.B.compareTo(MyEnum.A) > 0);
+ System.out.println(true);
+ System.out.println(MyEnum.A.compareTo(MyEnum.B) < 0);
+ System.out.println(true);
+ System.out.println(MyEnum.A.compareTo(MyEnum.A) == 0);
+ System.out.println(true);
+ try {
+ ((MyEnum) null).equals(null);
+ } catch (NullPointerException npe) {
+ System.out.println("npe " + npe.getMessage());
+ System.out.println("npe " + npe.getMessage());
+ }
+ try {
+ MyEnum.A.compareTo(null);
+ } catch (NullPointerException npe) {
+ System.out.println("npe " + npe.getMessage());
+ System.out.println("npe " + npe.getMessage());
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java
new file mode 100644
index 0000000..d8d781e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2020, 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+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 ToStringEnumUnboxingTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final KeepRule enumKeepRules;
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public ToStringEnumUnboxingTest(
+ TestParameters parameters, boolean enumValueOptimization, KeepRule enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ Class<?> success = EnumNameToString.class;
+ R8TestRunResult run =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ToStringEnumUnboxingTest.class)
+ .addKeepMainRule(EnumNameToString.class)
+ .enableNeverClassInliningAnnotations()
+ .addKeepRules(enumKeepRules.getKeepRule())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .allowDiagnosticInfoMessages()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspectDiagnosticMessages(
+ m ->
+ assertEnumIsUnboxed(
+ success.getDeclaredClasses()[0], success.getSimpleName(), m))
+ .run(parameters.getRuntime(), success)
+ .assertSuccess();
+ assertLines2By2Correct(run.getStdOut());
+ }
+
+ static class EnumNameToString {
+
+ @NeverClassInline
+ enum MyEnum {
+ A,
+ B
+ }
+
+ @SuppressWarnings("ConstantConditions")
+ public static void main(String[] args) {
+ System.out.println(MyEnum.A.toString());
+ System.out.println(MyEnum.A.name());
+ System.out.println(MyEnum.B.toString());
+ System.out.println(MyEnum.B.name());
+ try {
+ System.out.println(((MyEnum) null).toString());
+ } catch (NullPointerException e) {
+ System.out.println("npeToString " + e.getMessage());
+ System.out.println("npeToString " + e.getMessage());
+ }
+ try {
+ System.out.println(((MyEnum) null).name());
+ } catch (NullPointerException e) {
+ System.out.println("npeName " + e.getMessage());
+ System.out.println("npeName " + e.getMessage());
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java
new file mode 100644
index 0000000..b7643a0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java
@@ -0,0 +1,90 @@
+// Copyright (c) 2020, 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+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 ToStringOverrideEnumUnboxingTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final KeepRule enumKeepRules;
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public ToStringOverrideEnumUnboxingTest(
+ TestParameters parameters, boolean enumValueOptimization, KeepRule enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ Class<?> success = EnumNameToString.class;
+ R8TestRunResult run =
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ToStringOverrideEnumUnboxingTest.class)
+ .addKeepMainRule(EnumNameToString.class)
+ .enableNeverClassInliningAnnotations()
+ .addKeepRules(enumKeepRules.getKeepRule())
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .allowDiagnosticInfoMessages()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspectDiagnosticMessages(
+ m -> assertEnumIsBoxed(success.getDeclaredClasses()[0], success.getSimpleName(), m))
+ .run(parameters.getRuntime(), success)
+ .assertSuccess();
+ assertLines2By2Correct(run.getStdOut());
+ }
+
+ static class EnumNameToString {
+
+ @NeverClassInline
+ enum MyEnum {
+ A,
+ B {
+ @Override
+ public String toString() {
+ return "bezinga";
+ }
+ }
+ }
+
+ @SuppressWarnings("ConstantConditions")
+ public static void main(String[] args) {
+ System.out.println(MyEnum.A.toString());
+ System.out.println(MyEnum.A.name());
+ System.out.println(MyEnum.B.toString());
+ System.out.println("bezinga");
+ System.out.println(MyEnum.B.name());
+ System.out.println("B");
+ try {
+ System.out.println(((MyEnum) null).toString());
+ } catch (NullPointerException e) {
+ System.out.println("npeToString " + e.getMessage());
+ System.out.println("npeToString " + e.getMessage());
+ }
+ try {
+ System.out.println(((MyEnum) null).name());
+ } catch (NullPointerException e) {
+ System.out.println("npeName " + e.getMessage());
+ System.out.println("npeName " + e.getMessage());
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/internal/D8Framework14082017VerificationTest.java b/src/test/java/com/android/tools/r8/internal/D8Framework14082017VerificationTest.java
index 6dbb356..c8ea9ec 100644
--- a/src/test/java/com/android/tools/r8/internal/D8Framework14082017VerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/D8Framework14082017VerificationTest.java
@@ -5,6 +5,7 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.D8Command;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm.Version;
import com.android.tools.r8.VmTestRunner;
import com.android.tools.r8.VmTestRunner.IgnoreIfVmOlderThan;
@@ -24,6 +25,7 @@
runAndCheckVerification(
D8Command.builder()
.addProgramFiles(Paths.get(JAR))
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
.setMode(CompilationMode.DEBUG)
.setMinApiLevel(MIN_SDK),
JAR);
@@ -35,6 +37,7 @@
runAndCheckVerification(
D8Command.builder()
.addProgramFiles(Paths.get(JAR))
+ .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
.setMode(CompilationMode.RELEASE)
.setMinApiLevel(MIN_SDK),
JAR);
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
index ce6df5c..06f2813 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
@@ -24,7 +24,7 @@
import com.android.tools.r8.ir.code.InvokeVirtual;
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.optimize.NonNullTracker;
+import com.android.tools.r8.ir.optimize.AssumeInserter;
import com.android.tools.r8.ir.optimize.NonNullTrackerTestBase;
import com.android.tools.r8.ir.optimize.nonnull.FieldAccessTest;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterArrayAccess;
@@ -51,7 +51,7 @@
CodeInspector codeInspector = new CodeInspector(appView.appInfo().app());
MethodSubject fooSubject = codeInspector.clazz(mainClass.getName()).method(signature);
IRCode irCode = fooSubject.buildIR();
- new NonNullTracker(appView).insertAssumeInstructions(irCode, Timing.empty());
+ new AssumeInserter(appView).insertAssumeInstructions(irCode, Timing.empty());
inspector.accept(appView, irCode);
verifyLastInvoke(irCode, npeCaught);
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
index 06305cf..dac8b92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
@@ -40,9 +40,9 @@
IRCode code = fooSubject.buildIR();
checkCountOfNonNull(code, 0);
- NonNullTracker nonNullTracker = new NonNullTracker(appView);
+ AssumeInserter assumeInserter = new AssumeInserter(appView);
- nonNullTracker.insertAssumeInstructions(code, Timing.empty());
+ assumeInserter.insertAssumeInstructions(code, Timing.empty());
assertTrue(code.isConsistentSSA());
checkCountOfNonNull(code, expectedNumberOfNonNull);
@@ -69,8 +69,7 @@
|| (prev.isIf() && prev.asIf().isZeroTest())
|| !curr.getBlock().getPredecessors().contains(prev.getBlock()));
// Make sure non-null is used or inserted for arguments.
- assertTrue(
- curr.outValue().numberOfAllUsers() > 0 || curr.asAssumeNonNull().src().isArgument());
+ assertTrue(curr.outValue().numberOfAllUsers() > 0 || curr.asAssume().src().isArgument());
count++;
}
}
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 8ff71b8..75c45d1 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
@@ -374,7 +374,7 @@
.getMethod()
.name
.toString()
- .equals(EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_ORDINAL)) {
+ .startsWith(EnumUnboxingRewriter.ENUM_UNBOXING_UTILITY_METHOD_PREFIX)) {
++invokeCount;
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
index d55906a..438aa81 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b149971007/B149971007.java
@@ -82,7 +82,7 @@
.compile()
.inspect(this::checkOutlineFromFeature);
- // Check that parts of method1 and method2 in FeatureClass was outlined.
+ // Check that parts of method1, ..., method4 in FeatureClass was outlined.
ClassSubject featureClass = compileResult.inspector().clazz(FeatureClass.class);
assertThat(featureClass, isPresent());
String outlineClassName =
@@ -92,8 +92,10 @@
.get(OutlineOptions.CLASS_NAME);
assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
+ assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
+ assertTrue(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
- compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("1234");
+ compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("123456");
}
private void checkNoOutlineFromFeature(CodeInspector inspector) {
@@ -106,6 +108,7 @@
@Test
public void testWithSplit() throws Exception {
Path featureCode = temp.newFile("feature.zip").toPath();
+
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, FeatureAPI.class)
@@ -118,7 +121,7 @@
.compile()
.inspect(this::checkNoOutlineFromFeature);
- // Check that parts of method1 and method2 in FeatureClass was not outlined.
+ // Check that parts of method1, ..., method4 in FeatureClass was not outlined.
CodeInspector featureInspector = new CodeInspector(featureCode);
ClassSubject featureClass = featureInspector.clazz(FeatureClass.class);
assertThat(featureClass, isPresent());
@@ -129,6 +132,8 @@
.get(OutlineOptions.CLASS_NAME);
assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method1"), outlineClassName));
assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method2"), outlineClassName));
+ assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method3"), outlineClassName));
+ assertFalse(invokesOutline(featureClass.uniqueMethodWithName("method4"), outlineClassName));
// Run the code without the feature code present.
compileResult.run(parameters.getRuntime(), TestClass.class).assertSuccessWithOutput("12");
@@ -137,7 +142,7 @@
compileResult
.addRunClasspathFiles(featureCode)
.run(parameters.getRuntime(), TestClass.class)
- .assertSuccessWithOutput("1234");
+ .assertSuccessWithOutput("123456");
}
public static class TestClass {
@@ -193,14 +198,23 @@
}
public static void feature(int i) {
- FeatureClass.method1(new FeatureClass(i), new FeatureClass(i + 1));
+ method1(i, i + 1);
+ method3(new FeatureClass(i + 2), new FeatureClass(i + 3));
}
- public static void method1(FeatureClass fc1, FeatureClass fc2) {
+ public static void method1(int i1, int i2) {
+ System.out.print(i1 + "" + i2);
+ }
+
+ public static void method2(int i1, int i2) {
+ System.out.print(i1 + "" + i2);
+ }
+
+ public static void method3(FeatureClass fc1, FeatureClass fc2) {
System.out.print(fc1.getI() + "" + fc2.getI());
}
- public static void method2(FeatureClass fc1, FeatureClass fc2) {
+ public static void method4(FeatureClass fc1, FeatureClass fc2) {
System.out.print(fc1.getI() + "" + fc2.getI());
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
new file mode 100644
index 0000000..904f69f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2020, 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.kotlin.coroutines;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KotlinxCoroutinesTestRunner extends KotlinTestBase {
+
+ private static final String PKG = "kotlinx-coroutines-1.3.6";
+ private static final Path BASE_LIBRARY =
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "deps_all-1.3.6-SNAPSHOT.jar");
+ private static final Path TEST_SOURCES =
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "kotlinx-coroutines-test-test-sources");
+ private static final List<Path> DEPENDENCIES =
+ ImmutableList.of(
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "atomicfu-0.14.3.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "hamcrest-core-1.3.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "junit-4.13.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "kotlin-test-1.3.72.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "kotlin-test-junit-1.3.71.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "kotlinx.coroutines.testbase.jar"),
+ Paths.get(ToolHelper.THIRD_PARTY_DIR, PKG, "kotlinx.coroutines.test.main.jar"));
+
+ // Tests that do not run correctly in general - that is these tests are expected to fail always.
+ private Set<String> notWorkingTests =
+ Sets.newHashSet("kotlinx.coroutines.test.TestDispatchersTest");
+
+ @Parameterized.Parameters(name = "{0} target: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+ }
+
+ private final TestParameters parameters;
+
+ public KotlinxCoroutinesTestRunner(TestParameters parameters, KotlinTargetVersion targetVersion) {
+ super(targetVersion);
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void runKotlinxCoroutinesTests_smoke() throws Exception {
+ Path baseJar =
+ kotlinc(KOTLINC, targetVersion)
+ .addArguments(
+ "-Xuse-experimental=kotlinx.coroutines.InternalCoroutinesApi",
+ "-Xuse-experimental=kotlinx.coroutines.ObsoleteCoroutinesApi",
+ "-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi")
+ .addClasspathFiles(DEPENDENCIES)
+ .addClasspathFiles(BASE_LIBRARY)
+ .addSourceFiles(TEST_SOURCES)
+ .compile();
+ runTestsInJar(baseJar, BASE_LIBRARY);
+ }
+
+ private void runTestsInJar(Path testJar, Path deps) throws Exception {
+ List<Path> dependencies = new ArrayList<>(DEPENDENCIES);
+ dependencies.add(deps);
+ dependencies.add(testJar);
+ ZipUtils.iter(
+ testJar.toString(),
+ (entry, input) -> {
+ if (!entry.isDirectory() && entry.getName().endsWith("Test.class")) {
+ runTest(dependencies, entry.getName());
+ }
+ });
+ }
+
+ private void runTest(List<Path> dependencies, String name) throws IOException {
+ String testName = name.replace("/", ".").replace(".class", "");
+ if (notWorkingTests.contains(testName)) {
+ return;
+ }
+ ProcessResult processResult =
+ ToolHelper.runJava(
+ parameters.getRuntime().asCf(), dependencies, "org.junit.runner.JUnitCore", testName);
+ assertEquals(0, processResult.exitCode);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java b/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
index eb670d6..d420618 100644
--- a/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
+++ b/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
@@ -52,7 +52,7 @@
try {
SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
fail("Should have thrown an error");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertEquals(1, testDiagnosticMessages.getErrors().size());
Diagnostic diagnostic = testDiagnosticMessages.getErrors().get(0);
assertEquals(
@@ -75,7 +75,7 @@
try {
SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
fail("Should have thrown an error");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertEquals(1, testDiagnosticMessages.getErrors().size());
Diagnostic diagnostic = testDiagnosticMessages.getErrors().get(0);
assertEquals(
@@ -98,7 +98,7 @@
try {
SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
fail("Should have thrown an error");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertEquals(1, testDiagnosticMessages.getErrors().size());
Diagnostic diagnostic = testDiagnosticMessages.getErrors().get(0);
assertEquals(
@@ -116,7 +116,7 @@
try {
SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
fail("Should have thrown an error");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertEquals(1, testDiagnosticMessages.getErrors().size());
Diagnostic diagnostic = testDiagnosticMessages.getErrors().get(0);
assertEquals(
diff --git a/src/test/java/com/android/tools/r8/reachabilitysensitive/ReachabilitySensitiveTest.java b/src/test/java/com/android/tools/r8/reachabilitysensitive/ReachabilitySensitiveTest.java
index 5d06942..cc558a1 100644
--- a/src/test/java/com/android/tools/r8/reachabilitysensitive/ReachabilitySensitiveTest.java
+++ b/src/test/java/com/android/tools/r8/reachabilitysensitive/ReachabilitySensitiveTest.java
@@ -11,13 +11,14 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
import com.android.tools.r8.code.AddIntLit8;
import com.android.tools.r8.code.Const4;
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.dex.Marker.Tool;
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.graph.DexDebugEvent.StartLocal;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
import dalvik.annotation.optimization.ReachabilitySensitive;
@@ -26,7 +27,6 @@
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -68,40 +68,48 @@
@RunWith(Parameterized.class)
public class ReachabilitySensitiveTest extends TestBase {
+ private final TestParameters parameters;
private final Tool tool;
- @Parameters(name = "{0}")
- public static List<Object> data() {
- return ImmutableList.of(Tool.D8, Tool. R8);
+ @Parameters(name = "{0} tool: {1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+ ImmutableList.of(Tool.D8, Tool.R8));
}
- public ReachabilitySensitiveTest(Tool tool) {
+ public ReachabilitySensitiveTest(TestParameters parameters, Tool tool) {
+ this.parameters = parameters;
this.tool = tool;
}
+ private int getNumRegisters() {
+ // With API level >= Q we are allowed to re-use the receiver's register.
+ // See also InternalOptions.canHaveThisJitCodeDebuggingBug().
+ assert parameters.isDexRuntime();
+ return parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.Q) ? 2 : 3;
+ }
+
@Test
public void testNoAnnotation()
throws IOException, CompilationFailedException, ExecutionException, NoSuchMethodException {
- CodeInspector inspector = tool == Tool.R8
- ? compileR8(TestClass.class)
- : compile(TestClass.class);
+ CodeInspector inspector =
+ tool == Tool.R8 ? compileR8(TestClass.class) : compile(TestClass.class);
DexCode code =
inspector.method(TestClass.class.getMethod("method")).getMethod().getCode().asDexCode();
// Computation of k is constant folded and the value takes up one register. System.out takes
- // up another register and the receiver is the last.
- Assume.assumeTrue(
- "TODO(b/144966342): Why 2 on Q?",
- ToolHelper.getDexVm().isOlderThanOrEqual(ToolHelper.DexVm.ART_9_0_0_HOST));
- assertEquals(3, code.registerSize);
+ // up another register and the receiver is the last, unless on Q+.
+ assertEquals(getNumRegisters(), code.registerSize);
checkNoLocals(code);
}
@Test
public void testFieldAnnotation()
throws IOException, CompilationFailedException, ExecutionException, NoSuchMethodException {
- CodeInspector inspector = tool == Tool.R8
- ? compileR8(TestClassWithAnnotatedField.class)
- : compile(TestClassWithAnnotatedField.class);
+ CodeInspector inspector =
+ tool == Tool.R8
+ ? compileR8(TestClassWithAnnotatedField.class)
+ : compile(TestClassWithAnnotatedField.class);
checkAnnotatedCode(
inspector
.method(TestClassWithAnnotatedField.class.getMethod("method"))
@@ -113,9 +121,10 @@
@Test
public void testMethodAnnotation()
throws IOException, CompilationFailedException, ExecutionException, NoSuchMethodException {
- CodeInspector inspector = tool == Tool.R8
- ? compileR8(TestClassWithAnnotatedMethod.class)
- : compile(TestClassWithAnnotatedMethod.class);
+ CodeInspector inspector =
+ tool == Tool.R8
+ ? compileR8(TestClassWithAnnotatedMethod.class)
+ : compile(TestClassWithAnnotatedMethod.class);
checkAnnotatedCode(
inspector
.method(TestClassWithAnnotatedMethod.class.getMethod("method"))
@@ -127,9 +136,10 @@
private void checkNoLocals(DexCode code) {
// Even if we preserve live range of locals, we do not output locals information
// as this is a release build.
- assertTrue((code.getDebugInfo() == null) ||
- Arrays.stream(code.getDebugInfo().events)
- .allMatch(event -> !(event instanceof StartLocal)));
+ assertTrue(
+ (code.getDebugInfo() == null)
+ || Arrays.stream(code.getDebugInfo().events)
+ .allMatch(event -> !(event instanceof StartLocal)));
}
private void checkAnnotatedCode(DexCode code) {
@@ -155,6 +165,7 @@
throws CompilationFailedException, IOException, ExecutionException {
return testForD8()
.addProgramClasses(classes)
+ .setMinApi(parameters.getApiLevel())
.setMode(CompilationMode.RELEASE)
.compile()
.inspector();
@@ -170,6 +181,7 @@
.addProgramClasses(classes)
// TODO(ager): This will be in android.jar over time. For now, make it part of the app.
.addProgramClasses(ReachabilitySensitive.class)
+ .setMinApi(parameters.getApiLevel())
.setMode(CompilationMode.RELEASE)
// Keep the input class and its methods.
.addKeepRules(keepRules)
diff --git a/src/test/java/com/android/tools/r8/regress/b120164595/B120164595.java b/src/test/java/com/android/tools/r8/regress/b120164595/B120164595.java
index 7e56259..e63bcbb 100644
--- a/src/test/java/com/android/tools/r8/regress/b120164595/B120164595.java
+++ b/src/test/java/com/android/tools/r8/regress/b120164595/B120164595.java
@@ -69,7 +69,7 @@
builder -> {
builder.appendArtOption("-Xusejit:true");
},
- DexVm.ART_10_0_0_HOST);
+ DexVm.fromVersion(DexVm.Version.last()));
assertEquals(0, artResult.exitCode);
assertFalse(artResult.stderr.contains("Expected NullPointerException"));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
index 2e123d7..ecb398a 100644
--- a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
@@ -16,20 +16,17 @@
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.jasmin.JasminBuilder;
import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
import com.android.tools.r8.jasmin.JasminTestBase;
-import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.util.Collection;
import org.hamcrest.Matcher;
-import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -48,25 +45,109 @@
}
private enum Mode {
- NO_INVOKE,
- INVOKE_UNVERIFIABLE_METHOD,
- INVOKE_VERIFIABLE_METHOD_ON_UNVERIFIABLE_CLASS;
+ NO_INVOKE {
- public String instruction() {
- switch (this) {
- case NO_INVOKE:
- return "";
-
- case INVOKE_UNVERIFIABLE_METHOD:
- return "invokestatic UnverifiableClass/unverifiableMethod()V";
-
- case INVOKE_VERIFIABLE_METHOD_ON_UNVERIFIABLE_CLASS:
- return "invokestatic UnverifiableClass/verifiableMethod()V";
-
- default:
- throw new Unreachable();
+ @Override
+ public String getExpectedOutput(
+ Compiler compiler, TestRuntime runtime, boolean useInterface) {
+ return StringUtils.joinLines("Hello!", "Goodbye!", "");
}
- }
+
+ @Override
+ public String instruction() {
+ return "";
+ }
+ },
+ INVOKE_UNVERIFIABLE_METHOD {
+
+ @Override
+ public String getExpectedOutput(
+ Compiler compiler, TestRuntime runtime, boolean useInterface) {
+ if (!useInterface) {
+ return StringUtils.joinLines("Hello!", "");
+ }
+
+ switch (compiler) {
+ case D8:
+ case DX:
+ switch (runtime.asDex().getVm().getVersion()) {
+ case V4_0_4:
+ case V4_4_4:
+ case V10_0_0:
+ return StringUtils.joinLines("Hello!", "Goodbye!", "");
+
+ case V7_0_0:
+ return StringUtils.joinLines(
+ "Hello!",
+ "Unexpected outcome of checkcast",
+ "Unexpected outcome of instanceof",
+ "Goodbye!",
+ "");
+
+ default:
+ // Fallthrough.
+ }
+
+ case R8:
+ case PROGUARD:
+ return StringUtils.joinLines(
+ "Hello!", "Unexpected outcome of checkcast", "Goodbye!", "");
+
+ case R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES:
+ return StringUtils.joinLines(
+ "Hello!",
+ "Unexpected outcome of getstatic",
+ "Unexpected outcome of checkcast",
+ "Goodbye!",
+ "");
+
+ case JAVAC:
+ return StringUtils.joinLines("Hello!", "Goodbye!", "");
+
+ default:
+ throw new Unreachable();
+ }
+ }
+
+ @Override
+ public String instruction() {
+ return "invokestatic UnverifiableClass/unverifiableMethod()V";
+ }
+ },
+ INVOKE_VERIFIABLE_METHOD_ON_UNVERIFIABLE_CLASS {
+
+ @Override
+ public String getExpectedOutput(
+ Compiler compiler, TestRuntime runtime, boolean useInterface) {
+ if (useInterface) {
+ return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
+ }
+
+ switch (compiler) {
+ case R8:
+ case R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES:
+ case PROGUARD:
+ // The unverifiable method has been removed as a result of tree shaking, so the code
+ // does not fail with a verification error when trying to load class UnverifiableClass.
+ return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
+
+ default:
+ // The code fails with a verification error because the verifiableMethod() is being
+ // called on UnverifiableClass, which does not verify due to unverifiableMethod().
+ return StringUtils.joinLines("Hello!", "");
+ }
+ }
+
+ @Override
+ public String instruction() {
+ return "invokestatic UnverifiableClass/verifiableMethod()V";
+ }
+ };
+
+ public abstract String getExpectedOutput(
+ Compiler compiler, TestRuntime runtime, boolean useInterface);
+
+ public abstract String instruction();
}
private final TestParameters parameters;
@@ -191,11 +272,17 @@
assert parameters.isDexRuntime();
DXTestRunResult dxResult =
- testForDX().addProgramFiles(inputJar).run(parameters.getRuntime(), mainClass.name);
+ testForDX()
+ .addProgramFiles(inputJar)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), mainClass.name);
checkTestRunResult(dxResult, Compiler.DX);
D8TestRunResult d8Result =
- testForD8().addProgramFiles(inputJar).run(parameters.getRuntime(), mainClass.name);
+ testForD8()
+ .addProgramFiles(inputJar)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), mainClass.name);
checkTestRunResult(d8Result, Compiler.D8);
}
@@ -254,14 +341,6 @@
}
private void checkTestRunResult(TestRunResult<?> result, Compiler compiler) {
- Assume.assumeFalse(
- "Triage (b/144966342)",
- parameters.getRuntime().isDex()
- && parameters
- .getRuntime()
- .asDex()
- .getMinApiLevel()
- .isGreaterThanOrEqualTo(AndroidApiLevel.Q));
switch (mode) {
case NO_INVOKE:
result.assertSuccessWithOutput(getExpectedOutput(compiler));
@@ -309,58 +388,7 @@
}
private String getExpectedOutput(Compiler compiler) {
- if (mode == Mode.NO_INVOKE) {
- return StringUtils.joinLines("Hello!", "Goodbye!", "");
- }
- if (mode == Mode.INVOKE_VERIFIABLE_METHOD_ON_UNVERIFIABLE_CLASS) {
- if (useInterface) {
- return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
- } else {
- if (compiler == Compiler.R8
- || compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES
- || compiler == Compiler.PROGUARD) {
- // The unverifiable method has been removed as a result of tree shaking, so the code does
- // not fail with a verification error when trying to load class `UnverifiableClass`.
- return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
- } else {
- // The code fails with a verification error because the verifiableMethod() is being called
- // on `UnverifiableClass`, which does not verify due to unverifiableMethod().
- return StringUtils.joinLines("Hello!", "");
- }
- }
- }
- assert mode == Mode.INVOKE_UNVERIFIABLE_METHOD;
- if (useInterface) {
- if (compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES) {
- return StringUtils.joinLines(
- "Hello!",
- "Unexpected outcome of getstatic",
- "Unexpected outcome of checkcast",
- "Goodbye!",
- "");
- } else if (compiler == Compiler.R8 || compiler == Compiler.PROGUARD) {
- return StringUtils.joinLines("Hello!", "Unexpected outcome of checkcast", "Goodbye!", "");
- } else if (compiler == Compiler.DX || compiler == Compiler.D8) {
- if (ToolHelper.getDexVm().getVersion() == Version.V4_0_4
- || ToolHelper.getDexVm().getVersion() == Version.V4_4_4) {
- return StringUtils.joinLines("Hello!", "Goodbye!", "");
- } else if (ToolHelper.getDexVm().getVersion() == Version.V7_0_0) {
- return StringUtils.joinLines(
- "Hello!",
- "Unexpected outcome of checkcast",
- "Unexpected outcome of instanceof",
- "Goodbye!",
- "");
- } else {
- return StringUtils.joinLines("Hello!", "Unexpected outcome of checkcast", "Goodbye!", "");
- }
- } else {
- assert compiler == Compiler.JAVAC;
- return StringUtils.joinLines("Hello!", "Goodbye!", "");
- }
- } else {
- return StringUtils.joinLines("Hello!", "");
- }
+ return mode.getExpectedOutput(compiler, parameters.getRuntime(), useInterface);
}
private Matcher<String> getMatcherForExpectedError() {
diff --git a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
index 3b39b815..4cada28 100644
--- a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
@@ -766,7 +766,7 @@
new ProguardConfigurationParser(new DexItemFactory(), reporter);
parser.parse(path);
fail("Expect to fail due to the lack of file name.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, path, 6, 14, "File name expected");
}
}
@@ -795,7 +795,7 @@
new ProguardConfigurationParser(new DexItemFactory(), reporter)
.parse(path);
fail();
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, path, 6, 10,"does-not-exist.flags");
}
}
@@ -807,7 +807,7 @@
new ProguardConfigurationParser(new DexItemFactory(), reporter)
.parse(path);
fail();
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, path, 6,2, "does-not-exist.flags");
}
}
@@ -832,7 +832,7 @@
parser.parse(createConfigurationForTesting(
Collections.singletonList("-injars abc.jar(*.zip;*.class)")));
fail();
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertEquals(1, handler.errors.size());
}
}
@@ -1026,7 +1026,7 @@
reset();
parser.parse(createConfigurationForTesting(ImmutableList.of(option)));
fail("Expect to fail due to unsupported option.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, null, 1, 1, "Unsupported option", option);
}
}
@@ -1427,7 +1427,7 @@
new ProguardConfigurationParser(new DexItemFactory(), reporter);
parser.parse(createConfigurationForTesting(ImmutableList.of("-keepattributes xxx,")));
fail();
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
assertTrue(
handler.errors.get(0).getDiagnosticMessage().contains("Expected list element at "));
}
@@ -1613,7 +1613,7 @@
reset();
parser.parse(createConfigurationForTesting(ImmutableList.of(option + " ,")));
fail("Expect to fail due to the lack of path filter.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, null, 1, option.length() + 2, "Path filter expected");
}
}
@@ -1628,7 +1628,7 @@
reset();
parser.parse(createConfigurationForTesting(ImmutableList.of(option + " xxx,,yyy")));
fail("Expect to fail due to the lack of path filter.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, null, 1, option.length() + 6, "Path filter expected");
}
}
@@ -1643,7 +1643,7 @@
reset();
parser.parse(createConfigurationForTesting(ImmutableList.of(option + " xxx,")));
fail("Expect to fail due to the lack of path filter.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, null, 1, option.length() + 6, "Path filter expected");
}
}
@@ -1819,7 +1819,7 @@
try {
parser.parse(proguardConfig);
fail("Expect to fail due to unsupported constructor name pattern.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(
handler.errors, proguardConfig, 5, 3, "Unexpected character", "method name");
}
@@ -2501,7 +2501,7 @@
try {
parser.parse(createConfigurationForTesting(ImmutableList.of("-printusage <>")));
fail("Expect to fail due to the lack of file name.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(handler.errors, null, 1, 15, "Value of system property '' not found");
}
}
@@ -2518,7 +2518,7 @@
parser.parse(
createConfigurationForTesting(ImmutableList.of("-printusage <" + property + ">")));
fail("Expect to fail due to the lack of file name.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(
handler.errors, null, 1, 16, "Value of system property '" + property + "' not found");
}
@@ -2539,7 +2539,7 @@
reset();
parser.parse(createConfigurationForTesting(ImmutableList.of(flag + " " + value)));
fail("Expect to fail due to un-closed quote.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checker.get();
}
}
@@ -2759,7 +2759,7 @@
new ProguardConfigurationParser(new DexItemFactory(), reporter)
.parse(proguardConfigurationFile);
fail("Expected to fail since the type name cannot be negated.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
checkDiagnostics(
handler.errors,
proguardConfigurationFile,
@@ -2794,7 +2794,7 @@
try {
parser.parse(proguardConfig);
fail("Expect to fail due to unsupported constructor name pattern.");
- } catch (AbortException e) {
+ } catch (RuntimeException e) {
int column = initName.contains("void") ? initName.indexOf("void") + 8
: (initName.contains("XYZ") ? initName.indexOf(">") + 4 : 3);
if (initName.contains("XYZ")) {
diff --git a/third_party/kotlinx-coroutines-1.3.6.tar.gz.sha1 b/third_party/kotlinx-coroutines-1.3.6.tar.gz.sha1
new file mode 100644
index 0000000..6b4a3b8
--- /dev/null
+++ b/third_party/kotlinx-coroutines-1.3.6.tar.gz.sha1
@@ -0,0 +1 @@
+fe2b5c46bec807d11fcbd5572f9f7ba9d755cefd
\ No newline at end of file
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
index ad9f63f..809a1fe 100755
--- a/tools/run_on_app.py
+++ b/tools/run_on_app.py
@@ -91,6 +91,12 @@
help='Archive find-min-xmx results on GCS',
default=False,
action='store_true')
+ result.add_option('--no-extra-pgconf', '--no_extra_pgconf',
+ help='Build without the following extra rules: ' +
+ '-printconfiguration, -printmapping, -printseeds, ' +
+ '-printusage',
+ default=False,
+ action='store_true')
result.add_option('--timeout',
type='int',
default=0,
@@ -529,6 +535,8 @@
args.extend(['--main-dex-rules', rules])
if 'allow-type-errors' in values:
extra_args.append('-Dcom.android.tools.r8.allowTypeErrors=1')
+ extra_args.append(
+ '-Dcom.android.tools.r8.disallowClassInlinerGracefulExit=1')
if options.debug_agent:
if not options.compiler_build == 'full':
@@ -575,9 +583,10 @@
pg_outdir = os.path.dirname(outdir)
else:
pg_outdir = outdir
- additional_pg_conf = GenerateAdditionalProguardConfiguration(
- temp, os.path.abspath(pg_outdir))
- args.extend(['--pg-conf', additional_pg_conf])
+ if not options.no_extra_pgconf:
+ additional_pg_conf = GenerateAdditionalProguardConfiguration(
+ temp, os.path.abspath(pg_outdir))
+ args.extend(['--pg-conf', additional_pg_conf])
build = not options.no_build and not options.golem
stderr_path = os.path.join(temp, 'stderr')
with open(stderr_path, 'w') as stderr:
