Merge commit '74b2bd6f9854f668928607bab99fdc59d264783a' into dev-release
diff --git a/build.gradle b/build.gradle
index 33dfc26..d7c83e7 100644
--- a/build.gradle
+++ b/build.gradle
@@ -294,6 +294,7 @@
def r8LibTestPath = "$buildDir/classes/r8libtest"
def java11ClassFiles = "$buildDir/classes/java/mainJava11"
def r8RetracePath = "$buildDir/libs/r8retrace.jar"
+def r8RetraceExludeDepsPath = "$buildDir/libs/r8retrace-exclude-deps.jar"
def osString = OperatingSystem.current().isLinux() ? "linux" :
OperatingSystem.current().isMacOsX() ? "mac" : "windows"
@@ -1082,6 +1083,19 @@
outputs.file r8RetracePath
}
+task R8RetraceNoDeps {
+ dependsOn R8LibNoDeps
+ dependsOn r8LibCreateTask(
+ "RetraceNoDeps",
+ ["src/main/keep_retrace.txt"],
+ R8LibNoDeps,
+ r8RetraceExludeDepsPath,
+ "--release",
+ repackageDepsNew.outputs.files
+ ).dependsOn(R8LibNoDeps)
+ outputs.file r8RetraceExludeDepsPath
+}
+
task sourceJar(type: Jar, dependsOn: classes) {
classifier = 'src'
from sourceSets.main.allSource
diff --git a/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java b/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
index 559d2f2..187402a 100644
--- a/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
@@ -6,8 +6,8 @@
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
import com.android.tools.r8.utils.MapUtils;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
-import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
+import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeHashMap;
+import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneRepresentativeMap;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableList;
@@ -26,8 +26,8 @@
*/
public final class AppliedGraphLens extends NonIdentityGraphLens {
- private final MutableBidirectionalManyToOneMap<DexType, DexType> renamedTypeNames =
- new BidirectionalManyToOneHashMap<>();
+ private final MutableBidirectionalManyToOneRepresentativeMap<DexType, DexType> renamedTypeNames =
+ new BidirectionalManyToOneRepresentativeHashMap<>();
private final BiMap<DexField, DexField> originalFieldSignatures = HashBiMap.create();
private final BiMap<DexMethod, DexMethod> originalMethodSignatures = HashBiMap.create();
@@ -39,6 +39,12 @@
public AppliedGraphLens(AppView<? extends AppInfoWithClassHierarchy> appView) {
super(appView.dexItemFactory(), GraphLens.getIdentityLens());
for (DexProgramClass clazz : appView.appInfo().classes()) {
+ // TODO(b/169395592): If merged classes were removed from the application this would not be
+ // necessary.
+ if (appView.graphLens().lookupType(clazz.getType()) != clazz.getType()) {
+ continue;
+ }
+
// Record original type names.
recordOriginalTypeNames(clazz, appView);
@@ -83,7 +89,12 @@
List<DexType> originalTypes = Lists.newArrayList(appView.graphLens().getOriginalTypes(type));
boolean isIdentity = originalTypes.size() == 1 && originalTypes.get(0) == type;
if (!isIdentity) {
- originalTypes.forEach(originalType -> renamedTypeNames.put(originalType, type));
+ originalTypes.forEach(
+ originalType -> {
+ assert !renamedTypeNames.containsKey(originalType);
+ renamedTypeNames.put(originalType, type);
+ });
+ renamedTypeNames.setRepresentative(type, appView.graphLens().getOriginalType(type));
}
}
@@ -94,11 +105,7 @@
@Override
public DexType getOriginalType(DexType type) {
- Set<DexType> originalTypeNames = renamedTypeNames.getKeys(type);
- if (!originalTypeNames.isEmpty()) {
- return originalTypeNames.iterator().next();
- }
- return type;
+ return renamedTypeNames.getRepresentativeKeyOrDefault(type, type);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 70bad80..22a830e 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
import static com.google.common.base.Predicates.alwaysFalse;
+import static com.google.common.base.Predicates.alwaysTrue;
import com.android.tools.r8.dex.MixedSectionCollection;
import com.android.tools.r8.errors.CompilationError;
@@ -121,6 +122,16 @@
}
}
+ public void forEachClassMethod(Consumer<? super DexClassAndMethod> consumer) {
+ forEachClassMethodMatching(alwaysTrue(), consumer);
+ }
+
+ public void forEachClassMethodMatching(
+ Predicate<DexEncodedMethod> predicate, Consumer<? super DexClassAndMethod> consumer) {
+ methodCollection.forEachMethodMatching(
+ predicate, method -> consumer.accept(DexClassAndMethod.create(this, method)));
+ }
+
@Override
public ClassAccessFlags getAccessFlags() {
return accessFlags;
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
index 0a17134..0446e09 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
@@ -27,11 +27,23 @@
}
}
+ public boolean isDefaultMethod() {
+ return getHolder().isInterface() && getDefinition().isDefaultMethod();
+ }
+
+ public boolean isStructurallyEqualTo(DexClassAndMethod other) {
+ return getDefinition() == other.getDefinition() && getHolder() == other.getHolder();
+ }
+
@Override
public MethodAccessFlags getAccessFlags() {
return getDefinition().getAccessFlags();
}
+ public DexProto getProto() {
+ return getReference().getProto();
+ }
+
@Override
public boolean isMethodTarget() {
return true;
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 4fcd92b..91203c8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -1383,13 +1383,13 @@
}
public static DexEncodedMethod createDesugaringForwardingMethod(
- DexEncodedMethod target, DexClass clazz, DexMethod forwardMethod, DexItemFactory factory) {
- DexMethod method = target.method;
+ DexClassAndMethod target, DexClass clazz, DexMethod forwardMethod, DexItemFactory factory) {
+ DexMethod method = target.getReference();
assert forwardMethod != null;
// New method will have the same name, proto, and also all the flags of the
// default method, including bridge flag.
DexMethod newMethod = factory.createMethod(clazz.type, method.proto, method.name);
- MethodAccessFlags newFlags = target.accessFlags.copy();
+ MethodAccessFlags newFlags = target.getAccessFlags().copy();
// Some debuggers (like IntelliJ) automatically skip synthetic methods on single step.
newFlags.setSynthetic();
newFlags.unsetAbstract();
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 385fb58..e6d824a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -682,14 +682,18 @@
// Library methods listed here are based on their original implementations. That is, we assume
// these cannot be overridden.
public final Set<DexMethod> libraryMethodsReturningNonNull =
- ImmutableSet.of(
- classMethods.getName,
- classMethods.getSimpleName,
- classMethods.forName,
- objectsMethods.requireNonNull,
- objectsMethods.requireNonNullWithMessage,
- objectsMethods.requireNonNullWithMessageSupplier,
- stringMembers.valueOf);
+ ImmutableSet.<DexMethod>builder()
+ .add(
+ classMethods.getName,
+ classMethods.getSimpleName,
+ classMethods.forName,
+ objectsMethods.requireNonNull,
+ objectsMethods.requireNonNullWithMessage,
+ objectsMethods.requireNonNullWithMessageSupplier,
+ stringMembers.valueOf)
+ .addAll(stringBufferMethods.appendMethods)
+ .addAll(stringBuilderMethods.appendMethods)
+ .build();
// TODO(b/119596718): More idempotent methods? Any singleton accessors? E.g.,
// java.util.Calendar#getInstance(...) // 4 variants
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index e00c1fe..d35b1a0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -261,6 +261,10 @@
return factory.isConstructor(this);
}
+ public boolean mustBeInlinedIntoInstanceInitializer(DexItemFactory dexItemFactory) {
+ return getName().startsWith(dexItemFactory.temporaryConstructorMethodPrefix);
+ }
+
public DexMethod withExtraArgumentPrepended(DexType type, DexItemFactory dexItemFactory) {
return dexItemFactory.createMethod(
holder, dexItemFactory.prependTypeToProto(type, proto), name);
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 376abd6..27284ea 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -7,7 +7,6 @@
import static com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer.TYPE_WRAPPER_SUFFIX;
import static com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer.VIVIFIED_TYPE_WRAPPER_SUFFIX;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
-import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.DISPATCH_CLASS_NAME_SUFFIX;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX;
import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_GROUP_CLASS_NAME_PREFIX;
@@ -42,7 +41,7 @@
// Bundletool is merging classes that may originate from a build with an old version of R8.
// Allow merging of classes that use names from older versions of R8.
private static List<String> OLD_SYNTHESIZED_NAMES =
- ImmutableList.of("$r8$backportedMethods$utility", "$r8$java8methods$utility");
+ ImmutableList.of("$r8$backportedMethods$utility", "$r8$java8methods$utility", "$-DC");
public final DexString descriptor;
private String toStringCache = null;
@@ -313,9 +312,11 @@
String name = toSourceString();
// The synthesized classes listed here must always be unique to a program context and thus
// never duplicated for distinct inputs.
- return
- // Hygienic suffix.
- name.contains(COMPANION_CLASS_NAME_SUFFIX)
+ return false
+ // Hygienic suffix.
+ || name.contains(COMPANION_CLASS_NAME_SUFFIX)
+ || name.contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)
+ || name.contains(SyntheticArgumentClass.SYNTHETIC_CLASS_SUFFIX)
// New and hygienic synthesis infrastructure.
|| name.contains(SyntheticItems.INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
|| name.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
@@ -336,11 +337,8 @@
private static boolean isSynthesizedTypeThatCouldBeDuplicated(String name) {
// Any entry that is removed from here must be added to OLD_SYNTHESIZED_NAMES to ensure that
// newer releases can be used to merge previous builds.
- return name.contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX) // Shared among enums.
- || name.contains(SyntheticArgumentClass.SYNTHETIC_CLASS_SUFFIX)
- || name.contains(LAMBDA_CLASS_NAME_PREFIX) // Could collide.
+ return name.contains(LAMBDA_CLASS_NAME_PREFIX) // Could collide.
|| name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
- || name.contains(DISPATCH_CLASS_NAME_SUFFIX) // Shared on reference.
|| name.contains(OutlineOptions.CLASS_NAME) // Global singleton.
|| name.contains(TwrCloseResourceRewriter.UTILITY_CLASS_NAME) // Global singleton.
|| name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME) // Global singleton.
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
index 33063ba..3dc807c 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
@@ -52,10 +52,6 @@
definition.parameterAnnotationsList.collectIndexedItems(indexedItems);
}
- public boolean isStructurallyEqualTo(ProgramMethod other) {
- return getDefinition() == other.getDefinition() && getHolder() == other.getHolder();
- }
-
public void registerCodeReferences(UseRegistry registry) {
Code code = getDefinition().getCode();
if (code != null) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index 495be54..dd0486a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -155,7 +155,7 @@
new AllInstantiatedOrUninstantiated(appView),
new SameParentClass(),
new SameNestHost(),
- new PreserveMethodCharacteristics(),
+ new PreserveMethodCharacteristics(appView),
new SameFeatureSplit(appView),
new RespectPackageBoundaries(appView),
new DontMergeSynchronizedClasses(appView),
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
index 431fdb9..3adb35c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
@@ -4,12 +4,14 @@
package com.android.tools.r8.horizontalclassmerging.policies;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethodSignature;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.horizontalclassmerging.MergeGroup;
import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.OptionalBool;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
@@ -28,9 +30,10 @@
static class MethodCharacteristics {
private final MethodAccessFlags accessFlags;
+ private final boolean isAssumeNoSideEffectsMethod;
private final OptionalBool isLibraryMethodOverride;
- private MethodCharacteristics(DexEncodedMethod method) {
+ private MethodCharacteristics(boolean isAssumeNoSideEffectsMethod, DexEncodedMethod method) {
this.accessFlags =
MethodAccessFlags.builder()
.setPrivate(method.getAccessFlags().isPrivate())
@@ -39,9 +42,16 @@
.setStrict(method.getAccessFlags().isStrict())
.setSynchronized(method.getAccessFlags().isSynchronized())
.build();
+ this.isAssumeNoSideEffectsMethod = isAssumeNoSideEffectsMethod;
this.isLibraryMethodOverride = method.isLibraryMethodOverride();
}
+ static MethodCharacteristics create(
+ AppView<AppInfoWithLiveness> appView, DexEncodedMethod method) {
+ return new MethodCharacteristics(
+ appView.appInfo().isAssumeNoSideEffectsMethod(method.getReference()), method);
+ }
+
@Override
public int hashCode() {
return (accessFlags.hashCode() << 2) | isLibraryMethodOverride.ordinal();
@@ -56,12 +66,17 @@
return false;
}
MethodCharacteristics characteristics = (MethodCharacteristics) obj;
- return isLibraryMethodOverride == characteristics.isLibraryMethodOverride
- && accessFlags.equals(characteristics.accessFlags);
+ return accessFlags.equals(characteristics.accessFlags)
+ && isAssumeNoSideEffectsMethod == characteristics.isAssumeNoSideEffectsMethod
+ && isLibraryMethodOverride == characteristics.isLibraryMethodOverride;
}
}
- public PreserveMethodCharacteristics() {}
+ private final AppView<AppInfoWithLiveness> appView;
+
+ public PreserveMethodCharacteristics(AppView<AppInfoWithLiveness> appView) {
+ this.appView = appView;
+ }
public static class TargetGroup {
@@ -72,12 +87,12 @@
return group;
}
- public boolean tryAdd(DexProgramClass clazz) {
+ public boolean tryAdd(AppView<AppInfoWithLiveness> appView, DexProgramClass clazz) {
Map<DexMethodSignature, MethodCharacteristics> newMethods = new HashMap<>();
for (DexEncodedMethod method : clazz.methods()) {
DexMethodSignature signature = method.getSignature();
MethodCharacteristics existingCharacteristics = methodMap.get(signature);
- MethodCharacteristics methodCharacteristics = new MethodCharacteristics(method);
+ MethodCharacteristics methodCharacteristics = MethodCharacteristics.create(appView, method);
if (existingCharacteristics == null) {
newMethods.put(signature, methodCharacteristics);
continue;
@@ -97,10 +112,10 @@
List<TargetGroup> groups = new ArrayList<>();
for (DexProgramClass clazz : group) {
- boolean added = Iterables.any(groups, targetGroup -> targetGroup.tryAdd(clazz));
+ boolean added = Iterables.any(groups, targetGroup -> targetGroup.tryAdd(appView, clazz));
if (!added) {
TargetGroup newGroup = new TargetGroup();
- added = newGroup.tryAdd(clazz);
+ added = newGroup.tryAdd(appView, clazz);
assert added;
groups.add(newGroup);
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index ee770e8..a1c4e7b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.code;
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
import static com.android.tools.r8.ir.code.DominatorTree.Assumption.MAY_HAVE_UNREACHABLE_BLOCKS;
@@ -12,6 +13,9 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
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;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
@@ -19,6 +23,7 @@
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Phi.RegisterReadType;
import com.android.tools.r8.ir.optimize.NestUtils;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.IteratorUtils;
import com.google.common.collect.ImmutableList;
@@ -269,6 +274,76 @@
}
@Override
+ public boolean replaceCurrentInstructionByNullCheckIfPossible(
+ AppView<?> appView, ProgramMethod context) {
+ Instruction toBeReplaced = current;
+ assert toBeReplaced != null;
+ assert toBeReplaced.isInstanceFieldInstruction() || toBeReplaced.isInvokeMethodWithReceiver();
+ if (toBeReplaced.hasUsedOutValue()) {
+ return false;
+ }
+ if (toBeReplaced.isInvokeDirect()) {
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexMethod invokedMethod = toBeReplaced.asInvokeDirect().getInvokedMethod();
+ if (invokedMethod.isInstanceInitializer(dexItemFactory)
+ || invokedMethod.mustBeInlinedIntoInstanceInitializer(dexItemFactory)) {
+ return false;
+ }
+ }
+ if (toBeReplaced.instructionMayHaveSideEffects(
+ appView, context, Instruction.SideEffectAssumption.RECEIVER_NOT_NULL)) {
+ return false;
+ }
+ Value receiver =
+ toBeReplaced.isInstanceFieldInstruction()
+ ? toBeReplaced.asInstanceFieldInstruction().object()
+ : toBeReplaced.asInvokeMethodWithReceiver().getReceiver();
+ if (receiver.isNeverNull()) {
+ removeOrReplaceByDebugLocalRead();
+ return true;
+ }
+ InvokeMethod replacement;
+ if (appView.options().canUseRequireNonNull()) {
+ DexMethod requireNonNullMethod = appView.dexItemFactory().objectsMethods.requireNonNull;
+ replacement = new InvokeStatic(requireNonNullMethod, null, ImmutableList.of(receiver));
+ } else {
+ DexMethod getClassMethod = appView.dexItemFactory().objectMembers.getClass;
+ replacement = new InvokeVirtual(getClassMethod, null, ImmutableList.of(receiver));
+ }
+ replaceCurrentInstruction(replacement);
+ return true;
+ }
+
+ @Override
+ public boolean replaceCurrentInstructionByInitClassIfPossible(
+ AppView<AppInfoWithLiveness> appView, IRCode code, DexType type) {
+ Instruction toBeReplaced = current;
+ assert toBeReplaced != null;
+ assert toBeReplaced.isStaticFieldInstruction() || toBeReplaced.isInvokeStatic();
+ if (toBeReplaced.hasUsedOutValue()) {
+ return false;
+ }
+ ProgramMethod context = code.context();
+ if (toBeReplaced.instructionMayHaveSideEffects(
+ appView, context, Instruction.SideEffectAssumption.CLASS_ALREADY_INITIALIZED)) {
+ return false;
+ }
+ if (!type.classInitializationMayHaveSideEffectsInContext(appView, context)) {
+ removeOrReplaceByDebugLocalRead();
+ return true;
+ }
+ if (!appView.canUseInitClass()) {
+ return false;
+ }
+ DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(type));
+ if (clazz != null) {
+ Value dest = code.createValue(TypeElement.getInt());
+ replaceCurrentInstruction(new InitClass(dest, clazz.type));
+ }
+ return true;
+ }
+
+ @Override
public void replaceCurrentInstructionWithConstClass(
AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo) {
if (current == null) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
index 763d520..b849f75 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
@@ -47,7 +47,10 @@
}
public static ConstNumber asConstNumberOrNull(Instruction instruction) {
- return (ConstNumber) instruction;
+ if (instruction == null) {
+ return null;
+ }
+ return instruction.asConstNumber();
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
index a96760f..757a581 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
@@ -11,7 +11,9 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import java.util.ListIterator;
import java.util.NoSuchElementException;
@@ -42,6 +44,18 @@
}
@Override
+ public boolean replaceCurrentInstructionByNullCheckIfPossible(
+ AppView<?> appView, ProgramMethod context) {
+ return instructionIterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context);
+ }
+
+ @Override
+ public boolean replaceCurrentInstructionByInitClassIfPossible(
+ AppView<AppInfoWithLiveness> appView, IRCode code, DexType type) {
+ return instructionIterator.replaceCurrentInstructionByInitClassIfPossible(appView, code, type);
+ }
+
+ @Override
public void replaceCurrentInstructionWithConstClass(
AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo) {
instructionIterator.replaceCurrentInstructionWithConstClass(appView, code, type, localInfo);
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 e8ba6bd..689514f 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
@@ -130,7 +130,11 @@
}
public boolean hasUnusedOutValue() {
- return !hasOutValue() || !outValue().hasAnyUsers();
+ return !hasUsedOutValue();
+ }
+
+ public boolean hasUsedOutValue() {
+ return hasOutValue() && outValue().hasAnyUsers();
}
public Value outValue() {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
index c4cceea..6b17a04 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
@@ -11,7 +11,9 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.Sets;
import java.util.ListIterator;
@@ -97,6 +99,11 @@
Value insertConstStringInstruction(AppView<?> appView, IRCode code, DexString value);
+ boolean replaceCurrentInstructionByNullCheckIfPossible(AppView<?> appView, ProgramMethod context);
+
+ boolean replaceCurrentInstructionByInitClassIfPossible(
+ AppView<AppInfoWithLiveness> appView, IRCode code, DexType type);
+
void replaceCurrentInstructionWithConstClass(
AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo);
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 31fd8f4..5793ec1 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
@@ -144,6 +144,10 @@
abstract public DexType getReturnType();
+ public boolean hasArguments() {
+ return !arguments().isEmpty();
+ }
+
public boolean hasReturnTypeVoid(DexItemFactory factory) {
return getReturnType() == factory.voidType;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
index 0fc2768..bbb6d27 100644
--- a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
@@ -10,7 +10,9 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.Sets;
import java.util.ListIterator;
@@ -62,6 +64,18 @@
}
@Override
+ public boolean replaceCurrentInstructionByNullCheckIfPossible(
+ AppView<?> appView, ProgramMethod context) {
+ return currentBlockIterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context);
+ }
+
+ @Override
+ public boolean replaceCurrentInstructionByInitClassIfPossible(
+ AppView<AppInfoWithLiveness> appView, IRCode code, DexType type) {
+ return currentBlockIterator.replaceCurrentInstructionByInitClassIfPossible(appView, code, type);
+ }
+
+ @Override
public void replaceCurrentInstructionWithConstClass(
AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo) {
currentBlockIterator.replaceCurrentInstructionWithConstClass(appView, code, type, localInfo);
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 e2b0e47..d08eb3e 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
@@ -442,8 +442,7 @@
}
private void synthesizeTwrCloseResourceUtilityClass(
- Builder<?> builder, ExecutorService executorService)
- throws ExecutionException {
+ Builder<?> builder, ExecutorService executorService) throws ExecutionException {
if (twrCloseResourceRewriter != null) {
twrCloseResourceRewriter.synthesizeUtilityClass(builder, executorService, options);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
index f6ad5f3..f348214 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
@@ -56,14 +56,14 @@
public void registerInvokeVirtual(DexMethod method) {
registerBackportedMethodRewriting(method);
registerLibraryRetargeting(method, false);
- registerInterfaceMethodRewriting(method);
+ registerInterfaceMethodRewriting(method, false);
registerDesugaredLibraryAPIConverter(method);
}
@Override
public void registerInvokeDirect(DexMethod method) {
registerLibraryRetargeting(method, false);
- registerInterfaceMethodRewriting(method);
+ registerInterfaceMethodRewriting(method, false);
registerDesugaredLibraryAPIConverter(method);
}
@@ -73,10 +73,11 @@
}
}
- private void registerInterfaceMethodRewriting(DexMethod method) {
+ private void registerInterfaceMethodRewriting(DexMethod method, boolean isInvokeSuper) {
if (!needsDesugarging) {
needsDesugarging =
- interfaceMethodRewriter != null && interfaceMethodRewriter.needsRewriting(method);
+ interfaceMethodRewriter != null
+ && interfaceMethodRewriter.needsRewriting(method, isInvokeSuper, appView);
}
}
@@ -103,14 +104,14 @@
}
registerBackportedMethodRewriting(method);
registerLibraryRetargeting(method, false);
- registerInterfaceMethodRewriting(method);
+ registerInterfaceMethodRewriting(method, false);
registerDesugaredLibraryAPIConverter(method);
}
@Override
public void registerInvokeInterface(DexMethod method) {
registerLibraryRetargeting(method, true);
- registerInterfaceMethodRewriting(method);
+ registerInterfaceMethodRewriting(method, false);
registerDesugaredLibraryAPIConverter(method);
}
@@ -131,7 +132,7 @@
@Override
public void registerInvokeSuper(DexMethod method) {
registerLibraryRetargeting(method, false);
- registerInterfaceMethodRewriting(method);
+ registerInterfaceMethodRewriting(method, true);
registerDesugaredLibraryAPIConverter(method);
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
index 1e3b81f..6200603 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndMember;
import com.android.tools.r8.graph.DexClassAndMethod;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
@@ -18,6 +19,7 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GenericSignature;
import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
+import com.android.tools.r8.graph.LibraryMethod;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.ProgramMethod;
@@ -25,6 +27,7 @@
import com.android.tools.r8.ir.synthetic.ExceptionThrowingSourceCode;
import com.android.tools.r8.ir.synthetic.SynthesizedCode;
import com.android.tools.r8.position.MethodPosition;
+import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
import com.android.tools.r8.utils.WorkList;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
@@ -39,7 +42,6 @@
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.function.BiConsumer;
import java.util.function.Consumer;
import org.objectweb.asm.Opcodes;
@@ -105,14 +107,14 @@
// List of methods that are known to be forwarded to by a forwarding method at this point in the
// class hierarchy. This set consists of the default interface methods, i.e., the targets of the
// forwarding methods, *not* the forwarding methods themselves.
- final ImmutableList<DexEncodedMethod> forwardedMethodTargets;
+ final ImmutableList<DexClassAndMethod> forwardedMethodTargets;
// If the forwarding methods for the emulated interface methods have not been added yet,
// this contains the information to add it in the subclasses.
final EmulatedInterfaceInfo emulatedInterfaceInfo;
ClassInfo(
ClassInfo parent,
- ImmutableList<DexEncodedMethod> forwardedMethodTargets,
+ ImmutableList<DexClassAndMethod> forwardedMethodTargets,
EmulatedInterfaceInfo emulatedInterfaceInfo) {
this.parent = parent;
this.forwardedMethodTargets = forwardedMethodTargets;
@@ -121,7 +123,7 @@
static ClassInfo create(
ClassInfo parent,
- ImmutableList<DexEncodedMethod> forwardedMethodTargets,
+ ImmutableList<DexClassAndMethod> forwardedMethodTargets,
EmulatedInterfaceInfo emulatedInterfaceInfo) {
return forwardedMethodTargets.isEmpty()
? parent
@@ -132,8 +134,11 @@
return this == EMPTY;
}
- boolean isTargetedByForwards(DexEncodedMethod method) {
- return forwardedMethodTargets.contains(method)
+ boolean isTargetedByForwards(DexClassAndMethod method) {
+ return IterableUtils.any(
+ forwardedMethodTargets,
+ DexClassAndMember::getDefinition,
+ definition -> definition == method.getDefinition())
|| (parent != null && parent.isTargetedByForwards(method));
}
}
@@ -394,7 +399,7 @@
// The computation of a class information and the insertions of forwarding methods.
private ClassInfo computeClassInfo(
DexClass clazz, ClassInfo superInfo, SignaturesInfo signatureInfo) {
- Builder<DexEncodedMethod> additionalForwards = ImmutableList.builder();
+ ImmutableList.Builder<DexClassAndMethod> additionalForwards = ImmutableList.builder();
// First we deal with non-emulated interface desugaring.
resolveForwardingMethods(clazz, superInfo, signatureInfo.signatures, additionalForwards);
// Second we deal with emulated interface, if one method has override in the current class,
@@ -507,7 +512,7 @@
DexClass clazz,
ClassInfo superInfo,
MethodSignatures signatures,
- Builder<DexEncodedMethod> additionalForwards) {
+ Builder<DexClassAndMethod> additionalForwards) {
if (clazz.isProgramClass() && appView.isAlreadyLibraryDesugared(clazz.asProgramClass())) {
return;
}
@@ -515,10 +520,10 @@
resolveForwardForSignature(
clazz,
wrapper.get(),
- (targetHolder, target) -> {
+ target -> {
if (!superInfo.isTargetedByForwards(target)) {
additionalForwards.add(target);
- addForwardingMethod(targetHolder, target, clazz);
+ addForwardingMethod(target, clazz);
}
});
}
@@ -527,7 +532,7 @@
// Looks up a method signature from the point of 'clazz', if it can dispatch to a default method
// the 'addForward' call-back is called with the target of the forward.
private void resolveForwardForSignature(
- DexClass clazz, DexMethod method, BiConsumer<DexClass, DexEncodedMethod> addForward) {
+ DexClass clazz, DexMethod method, Consumer<DexClassAndMethod> addForward) {
// Resolve the default method with base type as the symbolic holder as call sites are not known.
// The dispatch target is then looked up from the possible "instance" class.
// Doing so can cause an invalid invoke to become valid (at runtime resolution at a subtype
@@ -550,54 +555,52 @@
return;
}
- DexEncodedMethod target = virtualDispatchTarget.getDefinition();
- DexClass targetHolder = virtualDispatchTarget.getHolder();
// Don't forward if the target is explicitly marked as 'dont-rewrite'
- if (dontRewrite(targetHolder, target)) {
+ if (dontRewrite(virtualDispatchTarget)) {
return;
}
// If resolution targets a default interface method, forward it.
- if (targetHolder.isInterface() && target.isDefaultMethod()) {
- addForward.accept(targetHolder, target);
+ if (virtualDispatchTarget.isDefaultMethod()) {
+ addForward.accept(virtualDispatchTarget);
return;
}
// Remaining edge cases only pertain to desugaring of library methods.
- DexLibraryClass libraryHolder = targetHolder.asLibraryClass();
- if (libraryHolder == null || ignoreLibraryInfo()) {
+ if (!virtualDispatchTarget.isLibraryMethod() || ignoreLibraryInfo()) {
return;
}
- if (isRetargetMethod(libraryHolder, target)) {
- addForward.accept(targetHolder, target);
+ LibraryMethod libraryMethod = virtualDispatchTarget.asLibraryMethod();
+ if (isRetargetMethod(libraryMethod)) {
+ addForward.accept(virtualDispatchTarget);
return;
}
// If target is a non-interface library class it may be an emulated interface,
// except on a rewritten type, where L8 has already dealt with the desugaring.
- if (!libraryHolder.isInterface()
- && !appView.rewritePrefix.hasRewrittenType(libraryHolder.type, appView)) {
+ if (!libraryMethod.getHolder().isInterface()
+ && !appView.rewritePrefix.hasRewrittenType(libraryMethod.getHolderType(), appView)) {
// Here we use step-3 of resolution to find a maximally specific default interface method.
- DexClassAndMethod result = appInfo.lookupMaximallySpecificMethod(libraryHolder, method);
- if (result != null && rewriter.isEmulatedInterface(result.getHolder().type)) {
- addForward.accept(result.getHolder(), result.getDefinition());
+ DexClassAndMethod result =
+ appInfo.lookupMaximallySpecificMethod(libraryMethod.getHolder(), method);
+ if (result != null && rewriter.isEmulatedInterface(result.getHolderType())) {
+ addForward.accept(result);
}
}
}
- private boolean isRetargetMethod(DexLibraryClass holder, DexEncodedMethod method) {
+ private boolean isRetargetMethod(LibraryMethod method) {
assert needsLibraryInfo();
- assert holder.type == method.getHolderType();
- assert method.isNonPrivateVirtualMethod();
- if (method.isFinal()) {
- return false;
- }
- return appView.options().desugaredLibraryConfiguration.retargetMethod(method, appView) != null;
+ assert method.getDefinition().isNonPrivateVirtualMethod();
+ return !method.getAccessFlags().isFinal()
+ && appView.options().desugaredLibraryConfiguration.retargetMethod(method, appView) != null;
}
- private boolean dontRewrite(DexClass clazz, DexEncodedMethod method) {
- return needsLibraryInfo() && clazz.isLibraryClass() && rewriter.dontRewrite(method.method);
+ private boolean dontRewrite(DexClassAndMethod method) {
+ return needsLibraryInfo()
+ && method.getHolder().isLibraryClass()
+ && rewriter.dontRewrite(method);
}
// Construction of actual forwarding methods.
@@ -630,13 +633,12 @@
// Note: The parameter 'target' may be a public method on a class in case of desugared
// library retargeting (See below target.isInterface check).
- private void addForwardingMethod(DexClass targetHolder, DexEncodedMethod target, DexClass clazz) {
- assert targetHolder != null;
+ private void addForwardingMethod(DexClassAndMethod target, DexClass clazz) {
if (!clazz.isProgramClass()) {
return;
}
- DexEncodedMethod methodOnSelf = clazz.lookupMethod(target.method);
+ DexEncodedMethod methodOnSelf = clazz.lookupMethod(target.getReference());
if (methodOnSelf != null) {
throw new CompilationError(
"Attempt to add forwarding method that conflicts with existing method.",
@@ -645,13 +647,12 @@
new MethodPosition(methodOnSelf.method.asMethodReference()));
}
- DexMethod method = target.method;
// NOTE: Never add a forwarding method to methods of classes unknown or coming from android.jar
// even if this results in invalid code, these classes are never desugared.
// In desugared library, emulated interface methods can be overridden by retarget lib members.
DexMethod forwardMethod =
- targetHolder.isInterface()
- ? rewriter.defaultAsMethodOfCompanionClass(method)
+ target.getHolder().isInterface()
+ ? rewriter.defaultAsMethodOfCompanionClass(target)
: appView.options().desugaredLibraryConfiguration.retargetMethod(target, appView);
DexEncodedMethod desugaringForwardingMethod =
DexEncodedMethod.createDesugaringForwardingMethod(
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 c2b151c..3dc74ac 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
@@ -44,9 +44,10 @@
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.utils.StringDiagnostic;
+import com.android.tools.r8.utils.WorkList;
+import com.android.tools.r8.utils.collections.DexClassAndMethodSet;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@@ -73,7 +74,7 @@
// the invoke needs to be rewritten.
private final Map<DexString, List<DexMethod>> nonFinalHolderRewrites = new IdentityHashMap<>();
// Non final virtual library methods requiring generation of emulated dispatch.
- private final Set<DexEncodedMethod> emulatedDispatchMethods = Sets.newIdentityHashSet();
+ private final DexClassAndMethodSet emulatedDispatchMethods = DexClassAndMethodSet.create();
public DesugaredLibraryRetargeter(AppView<?> appView) {
this.appView = appView;
@@ -316,9 +317,6 @@
DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
assert singleTarget != null;
retarget = getRetargetLibraryMember(singleTarget.method);
- if (retarget == null) {
- return null;
- }
}
return retarget;
}
@@ -356,52 +354,80 @@
DexClass typeClass = appView.definitionFor(inType);
if (typeClass != null) {
DexType newHolder = retargetCoreLibMember.get(methodName).get(inType);
- List<DexEncodedMethod> found = findDexEncodedMethodsWithName(methodName, typeClass);
- for (DexEncodedMethod encodedMethod : found) {
+ List<DexClassAndMethod> found = findMethodsWithName(methodName, typeClass);
+ for (DexClassAndMethod method : found) {
+ DexMethod methodReference = method.getReference();
if (!typeClass.isFinal()) {
- nonFinalHolderRewrites.putIfAbsent(encodedMethod.method.name, new ArrayList<>());
- nonFinalHolderRewrites.get(encodedMethod.method.name).add(encodedMethod.method);
- if (!encodedMethod.isStatic()) {
- if (InterfaceMethodRewriter.isEmulatedInterfaceDispatch(appView, encodedMethod)) {
+ nonFinalHolderRewrites.putIfAbsent(method.getName(), new ArrayList<>());
+ nonFinalHolderRewrites.get(method.getName()).add(methodReference);
+ if (!method.getAccessFlags().isStatic()) {
+ if (isEmulatedInterfaceDispatch(method)) {
// In this case interface method rewriter takes care of it.
continue;
- } else if (!encodedMethod.isFinal()) {
+ } else if (!method.getAccessFlags().isFinal()) {
// Virtual rewrites require emulated dispatch for inheritance.
// The call is rewritten to the dispatch holder class instead.
- handleEmulateDispatch(appView, encodedMethod);
- newHolder = dispatchHolderTypeFor(encodedMethod);
+ handleEmulateDispatch(appView, method);
+ newHolder = dispatchHolderTypeFor(method);
}
}
}
- DexProto proto = encodedMethod.method.proto;
- DexMethod method = appView.dexItemFactory().createMethod(inType, proto, methodName);
- retargetLibraryMember.put(
- method, computeRetargetMethod(method, encodedMethod.isStatic(), newHolder));
+ retargetLibraryMember.put(methodReference, computeRetargetMethod(method, newHolder));
}
}
}
}
}
- private DexMethod computeRetargetMethod(DexMethod method, boolean isStatic, DexType newHolder) {
- DexItemFactory factory = appView.dexItemFactory();
- DexProto newProto = isStatic ? method.proto : factory.prependHolderToProto(method);
- return factory.createMethod(newHolder, newProto, method.name);
+ private boolean isEmulatedInterfaceDispatch(DexClassAndMethod method) {
+ // Answers true if this method is already managed through emulated interface dispatch.
+ Map<DexType, DexType> emulateLibraryInterface =
+ appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface();
+ if (emulateLibraryInterface.isEmpty()) {
+ return false;
+ }
+ DexMethod methodToFind = method.getReference();
+
+ // Look-up all superclass and interfaces, if an emulated interface is found, and it implements
+ // the method, answers true.
+ WorkList<DexClass> worklist = WorkList.newIdentityWorkList(method.getHolder());
+ while (worklist.hasNext()) {
+ DexClass clazz = worklist.next();
+ if (clazz.isInterface()
+ && emulateLibraryInterface.containsKey(clazz.getType())
+ && clazz.lookupMethod(methodToFind) != null) {
+ return true;
+ }
+ // All super types are library class, or we are doing L8 compilation.
+ clazz.forEachImmediateSupertype(
+ superType -> {
+ DexClass superClass = appView.definitionFor(superType);
+ if (superClass != null) {
+ worklist.addIfNotSeen(superClass);
+ }
+ });
+ }
+ return false;
}
- private List<DexEncodedMethod> findDexEncodedMethodsWithName(
- DexString methodName, DexClass clazz) {
- List<DexEncodedMethod> found = new ArrayList<>();
- for (DexEncodedMethod encodedMethod : clazz.methods()) {
- if (encodedMethod.method.name == methodName) {
- found.add(encodedMethod);
- }
- }
- assert found.size() > 0 : "Should have found a method (library specifications).";
+ private DexMethod computeRetargetMethod(DexClassAndMethod method, DexType newHolder) {
+ DexItemFactory factory = appView.dexItemFactory();
+ DexProto newProto =
+ method.getAccessFlags().isStatic()
+ ? method.getProto()
+ : factory.prependHolderToProto(method.getReference());
+ return factory.createMethod(newHolder, newProto, method.getName());
+ }
+
+ private List<DexClassAndMethod> findMethodsWithName(DexString methodName, DexClass clazz) {
+ List<DexClassAndMethod> found = new ArrayList<>();
+ clazz.forEachClassMethodMatching(
+ definition -> definition.getName() == methodName, found::add);
+ assert !found.isEmpty() : "Should have found a method (library specifications).";
return found;
}
- private void handleEmulateDispatch(AppView<?> appView, DexEncodedMethod method) {
+ private void handleEmulateDispatch(AppView<?> appView, DexClassAndMethod method) {
emulatedDispatchMethods.add(method);
if (!appView.options().isDesugaredLibraryCompilation()) {
// Add rewrite rules so keeps rules are correctly generated in the program.
@@ -437,8 +463,8 @@
private void addInterfacesAndForwardingMethods(
ExecutorService executorService, IRConverter converter) throws ExecutionException {
assert !appView.options().isDesugaredLibraryCompilation();
- Map<DexType, List<DexEncodedMethod>> map = Maps.newIdentityHashMap();
- for (DexEncodedMethod emulatedDispatchMethod : emulatedDispatchMethods) {
+ Map<DexType, List<DexClassAndMethod>> map = Maps.newIdentityHashMap();
+ for (DexClassAndMethod emulatedDispatchMethod : emulatedDispatchMethods) {
map.putIfAbsent(emulatedDispatchMethod.getHolderType(), new ArrayList<>(1));
map.get(emulatedDispatchMethod.getHolderType()).add(emulatedDispatchMethod);
}
@@ -470,7 +496,7 @@
}
private boolean inherit(
- DexLibraryClass clazz, DexType typeToInherit, Set<DexEncodedMethod> retarget) {
+ DexLibraryClass clazz, DexType typeToInherit, DexClassAndMethodSet retarget) {
DexLibraryClass current = clazz;
while (current.type != appView.dexItemFactory().objectType) {
if (current.type == typeToInherit) {
@@ -491,13 +517,13 @@
private void addInterfacesAndForwardingMethods(
DexProgramClass clazz,
- List<DexEncodedMethod> methods,
+ List<DexClassAndMethod> methods,
Consumer<DexEncodedMethod> newForwardingMethodsConsumer) {
// DesugaredLibraryRetargeter emulate dispatch: insertion of a marker interface & forwarding
// methods.
// We cannot use the ClassProcessor since this applies up to 26, while the ClassProcessor
// applies up to 24.
- for (DexEncodedMethod method : methods) {
+ for (DexClassAndMethod method : methods) {
clazz.addExtraInterfaces(
Collections.singletonList(new ClassTypeSignature(dispatchInterfaceTypeFor(method))));
if (clazz.lookupVirtualMethod(method.getReference()) == null) {
@@ -508,7 +534,7 @@
}
}
- private DexEncodedMethod createForwardingMethod(DexEncodedMethod target, DexClass clazz) {
+ private DexEncodedMethod createForwardingMethod(DexClassAndMethod target, DexClass clazz) {
// NOTE: Never add a forwarding method to methods of classes unknown or coming from
// android.jar
// even if this results in invalid code, these classes are never desugared.
@@ -533,7 +559,7 @@
| Constants.ACC_INTERFACE);
ClassAccessFlags holderAccessFlags =
ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
- for (DexEncodedMethod emulatedDispatchMethod : emulatedDispatchMethods) {
+ for (DexClassAndMethod emulatedDispatchMethod : emulatedDispatchMethods) {
// Dispatch interface.
DexType interfaceType = dispatchInterfaceTypeFor(emulatedDispatchMethod);
DexEncodedMethod itfMethod =
@@ -560,7 +586,7 @@
}
private DexEncodedMethod generateInterfaceDispatchMethod(
- DexEncodedMethod emulatedDispatchMethod, DexType interfaceType) {
+ DexClassAndMethod emulatedDispatchMethod, DexType interfaceType) {
MethodAccessFlags flags =
MethodAccessFlags.fromSharedAccessFlags(
Constants.ACC_PUBLIC | Constants.ACC_ABSTRACT | Constants.ACC_SYNTHETIC, false);
@@ -582,7 +608,7 @@
}
private DexEncodedMethod generateHolderDispatchMethod(
- DexEncodedMethod emulatedDispatchMethod, DexType dispatchHolder, DexMethod itfMethod) {
+ DexClassAndMethod emulatedDispatchMethod, DexType dispatchHolder, DexMethod itfMethod) {
// The method should look like:
// static foo(rcvr, arg0, arg1) {
// if (rcvr instanceof interfaceType) {
@@ -613,7 +639,7 @@
}
private void reportInvalidLibrarySupertype(
- DexLibraryClass libraryClass, Set<DexEncodedMethod> retarget) {
+ DexLibraryClass libraryClass, DexClassAndMethodSet retarget) {
DexClass dexClass = appView.definitionFor(libraryClass.superType);
String message;
if (dexClass == null) {
@@ -634,15 +660,15 @@
retarget);
}
- private DexType dispatchInterfaceTypeFor(DexEncodedMethod method) {
+ private DexType dispatchInterfaceTypeFor(DexClassAndMethod method) {
return dispatchTypeFor(method, "dispatchInterface");
}
- private DexType dispatchHolderTypeFor(DexEncodedMethod method) {
+ private DexType dispatchHolderTypeFor(DexClassAndMethod method) {
return dispatchTypeFor(method, "dispatchHolder");
}
- private DexType dispatchTypeFor(DexEncodedMethod method, String suffix) {
+ private DexType dispatchTypeFor(DexClassAndMethod method, String suffix) {
String descriptor =
"L"
+ appView
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 47793a8..1529d2f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -4,6 +4,13 @@
package com.android.tools.r8.ir.desugar;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_CUSTOM;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_DIRECT;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_INTERFACE;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_STATIC;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_SUPER;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_VIRTUAL;
+
import com.android.tools.r8.DesugarGraphConsumer;
import com.android.tools.r8.cf.CfVersion;
import com.android.tools.r8.dex.Constants;
@@ -36,8 +43,10 @@
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeCustom;
import com.android.tools.r8.ir.code.InvokeDirect;
import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.code.InvokeSuper;
import com.android.tools.r8.ir.conversion.IRConverter;
@@ -102,7 +111,6 @@
// Public for testing.
public static final String EMULATE_LIBRARY_CLASS_NAME_SUFFIX = "$-EL";
- public static final String DISPATCH_CLASS_NAME_SUFFIX = "$-DC";
public static final String COMPANION_CLASS_NAME_SUFFIX = "$-CC";
public static final String DEFAULT_METHOD_PREFIX = "$default$";
public static final String PRIVATE_METHOD_PREFIX = "$private$";
@@ -208,7 +216,16 @@
return emulatedInterfaces.containsKey(itf);
}
- public boolean needsRewriting(DexMethod method) {
+ public boolean needsRewriting(DexMethod method, boolean isInvokeSuper, AppView<?> appView) {
+ if (isInvokeSuper) {
+ DexClass clazz = appView.appInfo().definitionFor(method.getHolderType());
+ if (clazz != null
+ && clazz.isLibraryClass()
+ && clazz.isInterface()
+ && appView.rewritePrefix.hasRewrittenType(clazz.type, appView)) {
+ return true;
+ }
+ }
return emulatedMethods.contains(method.getName());
}
@@ -216,18 +233,19 @@
return emulatedInterfaces.get(itf);
}
- private void leavingStaticInvokeToInterface(
- DexProgramClass holder, DexEncodedMethod encodedMethod) {
+ private void leavingStaticInvokeToInterface(ProgramMethod method) {
// When leaving static interface method invokes possibly upgrade the class file
// version, but don't go above the initial class file version. If the input was
// 1.7 or below, this will make a VerificationError on the input a VerificationError
// on the output. If the input was 1.8 or above the runtime behaviour (potential ICCE)
// will remain the same.
- if (holder.hasClassFileVersion()) {
- encodedMethod.upgradeClassFileVersion(
- Ordered.min(CfVersion.V1_8, holder.getInitialClassFileVersion()));
+ if (method.getHolder().hasClassFileVersion()) {
+ method
+ .getDefinition()
+ .upgradeClassFileVersion(
+ Ordered.min(CfVersion.V1_8, method.getHolder().getInitialClassFileVersion()));
} else {
- encodedMethod.upgradeClassFileVersion(CfVersion.V1_8);
+ method.getDefinition().upgradeClassFileVersion(CfVersion.V1_8);
}
}
@@ -235,279 +253,300 @@
// NOTE: can be called for different methods concurrently.
public void rewriteMethodReferences(IRCode code) {
ProgramMethod context = code.context();
- DexEncodedMethod encodedMethod = context.getDefinition();
- if (synthesizedMethods.contains(encodedMethod)) {
+ if (synthesizedMethods.contains(context)) {
return;
}
ListIterator<BasicBlock> blocks = code.listIterator();
- AppInfo appInfo = appView.appInfo();
while (blocks.hasNext()) {
BasicBlock block = blocks.next();
InstructionListIterator instructions = block.listIterator(code);
while (instructions.hasNext()) {
Instruction instruction = instructions.next();
-
- if (instruction.isInvokeCustom()) {
- // Check that static interface methods are not referenced
- // from invoke-custom instructions via method handles.
- DexCallSite callSite = instruction.asInvokeCustom().getCallSite();
- reportStaticInterfaceMethodHandle(encodedMethod.method, callSite.bootstrapMethod);
- for (DexValue arg : callSite.bootstrapArgs) {
- if (arg.isDexValueMethodHandle()) {
- reportStaticInterfaceMethodHandle(
- encodedMethod.method, arg.asDexValueMethodHandle().value);
- }
- }
- continue;
+ switch (instruction.opcode()) {
+ case INVOKE_CUSTOM:
+ rewriteInvokeCustom(instruction.asInvokeCustom(), context);
+ break;
+ case INVOKE_DIRECT:
+ rewriteInvokeDirect(instruction.asInvokeDirect(), instructions, context);
+ break;
+ case INVOKE_STATIC:
+ rewriteInvokeStatic(instruction.asInvokeStatic(), instructions, context);
+ break;
+ case INVOKE_SUPER:
+ rewriteInvokeSuper(instruction.asInvokeSuper(), instructions, context);
+ break;
+ case INVOKE_INTERFACE:
+ case INVOKE_VIRTUAL:
+ rewriteInvokeInterfaceOrInvokeVirtual(
+ instruction.asInvokeMethodWithReceiver(), instructions);
+ break;
+ default:
+ // Intentionally empty.
+ break;
}
+ }
+ }
+ }
- if (instruction.isInvokeStatic()) {
- InvokeStatic invokeStatic = instruction.asInvokeStatic();
- DexMethod method = invokeStatic.getInvokedMethod();
- if (appView.getSyntheticItems().isPendingSynthetic(method.holder)) {
- // We did not create this code yet, but it will not require rewriting.
- continue;
- }
- DexClass clazz = appInfo.definitionFor(method.holder);
- if (clazz == null) {
- // NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
- // exception but we can not report it as error since it can also be the intended
- // behavior.
- if (invokeStatic.getInterfaceBit()) {
- leavingStaticInvokeToInterface(context.getHolder(), encodedMethod);
- }
- warnMissingType(encodedMethod.method, method.holder);
- } else if (clazz.isInterface()) {
- if (isNonDesugaredLibraryClass(clazz)) {
- // NOTE: we intentionally don't desugar static calls into static interface
- // methods coming from android.jar since it is only possible in case v24+
- // version of android.jar is provided.
- //
- // We assume such calls are properly guarded by if-checks like
- // 'if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.XYZ) { ... }'
- //
- // WARNING: This may result in incorrect code on older platforms!
- // Retarget call to an appropriate method of companion class.
+ private void rewriteInvokeCustom(InvokeCustom invoke, ProgramMethod context) {
+ // Check that static interface methods are not referenced from invoke-custom instructions via
+ // method handles.
+ DexCallSite callSite = invoke.getCallSite();
+ reportStaticInterfaceMethodHandle(context, callSite.bootstrapMethod);
+ for (DexValue arg : callSite.bootstrapArgs) {
+ if (arg.isDexValueMethodHandle()) {
+ reportStaticInterfaceMethodHandle(context, arg.asDexValueMethodHandle().value);
+ }
+ }
+ }
- if (!options.canLeaveStaticInterfaceMethodInvokes()) {
- // On pre-L devices static calls to interface methods result in verifier
- // rejecting the whole class. We have to create special dispatch classes,
- // so the user class is not rejected because it make this call directly.
- // TODO(b/166247515): If this an incorrect invoke-static without the interface bit
- // we end up "fixing" the code and remove and ICCE error.
- ProgramMethod newProgramMethod =
- appView
- .getSyntheticItems()
- .createMethod(
- context.getHolder(),
- factory,
- syntheticMethodBuilder -> {
- syntheticMethodBuilder
- .setProto(method.proto)
- .setAccessFlags(
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC
- | Constants.ACC_STATIC
- | Constants.ACC_SYNTHETIC,
- false))
- .setCode(
- m ->
- ForwardMethodBuilder.builder(factory)
- .setStaticTarget(method, true)
- .setStaticSource(m)
- .build());
- });
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- newProgramMethod.getReference(),
- invokeStatic.outValue(),
- invokeStatic.arguments()));
- synchronized (synthesizedMethods) {
- // The synthetic dispatch class has static interface method invokes, so set
- // the class file version accordingly.
- newProgramMethod.getDefinition().upgradeClassFileVersion(CfVersion.V1_8);
- synthesizedMethods.add(newProgramMethod);
- }
- } else {
- // When leaving static interface method invokes upgrade the class file version.
- encodedMethod.upgradeClassFileVersion(CfVersion.V1_8);
- }
- } else {
+ private void rewriteInvokeDirect(
+ InvokeDirect invoke, InstructionListIterator instructions, ProgramMethod context) {
+ DexMethod method = invoke.getInvokedMethod();
+ if (factory.isConstructor(method)) {
+ return;
+ }
+
+ DexClass clazz = appView.definitionForHolder(method, context);
+ if (clazz == null) {
+ // Report missing class since we don't know if it is an interface.
+ warnMissingType(context, method.holder);
+ return;
+ }
+
+ if (!clazz.isInterface()) {
+ return;
+ }
+
+ if (clazz.isLibraryClass()) {
+ throw new CompilationError(
+ "Unexpected call to a private method "
+ + "defined in library class "
+ + clazz.toSourceString(),
+ getMethodOrigin(context.getReference()));
+ }
+
+ DexEncodedMethod directTarget = clazz.lookupMethod(method);
+ if (directTarget != null) {
+ // This can be a private instance method call. Note that the referenced
+ // method is expected to be in the current class since it is private, but desugaring
+ // may move some methods or their code into other classes.
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(
+ directTarget.isPrivateMethod()
+ ? privateAsMethodOfCompanionClass(method)
+ : defaultAsMethodOfCompanionClass(method),
+ invoke.outValue(),
+ invoke.arguments()));
+ } else {
+ // The method can be a default method in the interface hierarchy.
+ DexClassAndMethod virtualTarget =
+ appView.appInfoForDesugaring().lookupMaximallySpecificMethod(clazz, method);
+ if (virtualTarget != null) {
+ // This is a invoke-direct call to a virtual method.
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(
+ defaultAsMethodOfCompanionClass(virtualTarget.getDefinition().method),
+ invoke.outValue(),
+ invoke.arguments()));
+ } else {
+ // The below assert is here because a well-type program should have a target, but we
+ // cannot throw a compilation error, since we have no knowledge about the input.
+ assert false;
+ }
+ }
+ }
+
+ private void rewriteInvokeStatic(
+ InvokeStatic invoke, InstructionListIterator instructions, ProgramMethod context) {
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ if (appView.getSyntheticItems().isPendingSynthetic(invokedMethod.holder)) {
+ // We did not create this code yet, but it will not require rewriting.
+ return;
+ }
+
+ DexClass clazz = appView.definitionFor(invokedMethod.holder, context);
+ if (clazz == null) {
+ // NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
+ // exception but we can not report it as error since it can also be the intended
+ // behavior.
+ if (invoke.getInterfaceBit()) {
+ leavingStaticInvokeToInterface(context);
+ }
+ warnMissingType(context, invokedMethod.holder);
+ return;
+ }
+
+ if (!clazz.isInterface()) {
+ if (invoke.getInterfaceBit()) {
+ leavingStaticInvokeToInterface(context);
+ }
+ return;
+ }
+
+ if (isNonDesugaredLibraryClass(clazz)) {
+ // NOTE: we intentionally don't desugar static calls into static interface
+ // methods coming from android.jar since it is only possible in case v24+
+ // version of android.jar is provided.
+ //
+ // We assume such calls are properly guarded by if-checks like
+ // 'if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.XYZ) { ... }'
+ //
+ // WARNING: This may result in incorrect code on older platforms!
+ // Retarget call to an appropriate method of companion class.
+
+ if (!options.canLeaveStaticInterfaceMethodInvokes()) {
+ // On pre-L devices static calls to interface methods result in verifier
+ // rejecting the whole class. We have to create special dispatch classes,
+ // so the user class is not rejected because it make this call directly.
+ // TODO(b/166247515): If this an incorrect invoke-static without the interface bit
+ // we end up "fixing" the code and remove and ICCE error.
+ ProgramMethod newProgramMethod =
+ appView
+ .getSyntheticItems()
+ .createMethod(
+ context.getHolder(),
+ factory,
+ syntheticMethodBuilder ->
+ syntheticMethodBuilder
+ .setProto(invokedMethod.proto)
+ .setAccessFlags(
+ MethodAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC
+ | Constants.ACC_STATIC
+ | Constants.ACC_SYNTHETIC,
+ false))
+ .setCode(
+ m ->
+ ForwardMethodBuilder.builder(factory)
+ .setStaticTarget(invokedMethod, true)
+ .setStaticSource(m)
+ .build()));
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(
+ newProgramMethod.getReference(), invoke.outValue(), invoke.arguments()));
+ synchronized (synthesizedMethods) {
+ // The synthetic dispatch class has static interface method invokes, so set
+ // the class file version accordingly.
+ newProgramMethod.getDefinition().upgradeClassFileVersion(CfVersion.V1_8);
+ synthesizedMethods.add(newProgramMethod);
+ }
+ } else {
+ // When leaving static interface method invokes upgrade the class file version.
+ context.getDefinition().upgradeClassFileVersion(CfVersion.V1_8);
+ }
+ } else {
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(
+ staticAsMethodOfCompanionClass(invokedMethod),
+ invoke.outValue(),
+ invoke.arguments()));
+ }
+ }
+
+ private void rewriteInvokeSuper(
+ InvokeSuper invoke, InstructionListIterator instructions, ProgramMethod context) {
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ DexClass clazz = appView.definitionFor(invokedMethod.holder, context);
+ if (clazz == null) {
+ // NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
+ // exception but we can not report it as error since it can also be the intended
+ // behavior.
+ warnMissingType(context, invokedMethod.holder);
+ return;
+ }
+
+ if (clazz.isInterface() && !clazz.isLibraryClass()) {
+ // NOTE: we intentionally don't desugar super calls into interface methods
+ // coming from android.jar since it is only possible in case v24+ version
+ // of android.jar is provided.
+ //
+ // We assume such calls are properly guarded by if-checks like
+ // 'if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.XYZ) { ... }'
+ //
+ // WARNING: This may result in incorrect code on older platforms!
+ // Retarget call to an appropriate method of companion class.
+ DexMethod amendedMethod = amendDefaultMethod(context.getHolder(), invokedMethod);
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(
+ defaultAsMethodOfCompanionClass(amendedMethod),
+ invoke.outValue(),
+ invoke.arguments()));
+ } else {
+ DexType emulatedItf = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
+ if (emulatedItf == null) {
+ if (clazz.isInterface() && appView.rewritePrefix.hasRewrittenType(clazz.type, appView)) {
+ DexClassAndMethod target =
+ appView.appInfoForDesugaring().lookupSuperTarget(invokedMethod, context);
+ if (target != null && target.getDefinition().isDefaultMethod()) {
+ DexClass holder = target.getHolder();
+ if (holder.isLibraryClass() && holder.isInterface()) {
instructions.replaceCurrentInstruction(
- new InvokeStatic(staticAsMethodOfCompanionClass(method),
- invokeStatic.outValue(), invokeStatic.arguments()));
- }
- } else {
- assert !clazz.isInterface();
- if (invokeStatic.getInterfaceBit()) {
- leavingStaticInvokeToInterface(context.getHolder(), encodedMethod);
+ new InvokeStatic(
+ defaultAsMethodOfCompanionClass(target.getReference(), factory),
+ invoke.outValue(),
+ invoke.arguments()));
}
}
- continue;
}
-
- if (instruction.isInvokeSuper()) {
- InvokeSuper invokeSuper = instruction.asInvokeSuper();
- DexMethod invokedMethod = invokeSuper.getInvokedMethod();
- DexClass clazz = appInfo.definitionFor(invokedMethod.holder);
- if (clazz == null) {
- // NOTE: leave unchanged those calls to undefined targets. This may lead to runtime
- // exception but we can not report it as error since it can also be the intended
- // behavior.
- warnMissingType(encodedMethod.method, invokedMethod.holder);
- } else if (clazz.isInterface() && !clazz.isLibraryClass()) {
- // NOTE: we intentionally don't desugar super calls into interface methods
- // coming from android.jar since it is only possible in case v24+ version
- // of android.jar is provided.
- //
- // We assume such calls are properly guarded by if-checks like
- // 'if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.XYZ) { ... }'
- //
- // WARNING: This may result in incorrect code on older platforms!
- // Retarget call to an appropriate method of companion class.
- DexMethod amendedMethod =
- amendDefaultMethod(
- appInfo.definitionFor(encodedMethod.getHolderType()), invokedMethod);
+ } else {
+ // That invoke super may not resolve since the super method may not be present
+ // since it's in the emulated interface. We need to force resolution. If it resolves
+ // to a library method, then it needs to be rewritten.
+ // If it resolves to a program overrides, the invoke-super can remain.
+ DexClassAndMethod superTarget =
+ appView.appInfoForDesugaring().lookupSuperTarget(invoke.getInvokedMethod(), context);
+ if (superTarget != null && superTarget.isLibraryMethod()) {
+ // Rewriting is required because the super invoke resolves into a missing
+ // method (method is on desugared library). Find out if it needs to be
+ // retarget or if it just calls a companion class method and rewrite.
+ DexMethod retargetMethod =
+ options.desugaredLibraryConfiguration.retargetMethod(superTarget, appView);
+ if (retargetMethod == null) {
+ DexMethod originalCompanionMethod =
+ instanceAsMethodOfCompanionClass(
+ superTarget.getReference(), DEFAULT_METHOD_PREFIX, factory);
+ DexMethod companionMethod =
+ factory.createMethod(
+ getCompanionClassType(emulatedItf),
+ factory.protoWithDifferentFirstParameter(
+ originalCompanionMethod.proto, emulatedItf),
+ originalCompanionMethod.name);
instructions.replaceCurrentInstruction(
- new InvokeStatic(defaultAsMethodOfCompanionClass(amendedMethod),
- invokeSuper.outValue(), invokeSuper.arguments()));
+ new InvokeStatic(companionMethod, invoke.outValue(), invoke.arguments()));
} else {
- DexType dexType = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
- if (dexType == null) {
- if (clazz.isInterface()
- && appView.rewritePrefix.hasRewrittenType(clazz.type, appView)) {
- DexClassAndMethod target =
- appView.appInfoForDesugaring().lookupSuperTarget(invokedMethod, code.context());
- if (target != null && target.getDefinition().isDefaultMethod()) {
- DexClass holder = target.getHolder();
- if (holder.isLibraryClass() && holder.isInterface()) {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- defaultAsMethodOfCompanionClass(target.getReference(), factory),
- invokeSuper.outValue(),
- invokeSuper.arguments()));
- }
- }
- }
- } else {
- // That invoke super may not resolve since the super method may not be present
- // since it's in the emulated interface. We need to force resolution. If it resolves
- // to a library method, then it needs to be rewritten.
- // If it resolves to a program overrides, the invoke-super can remain.
- DexClassAndMethod superTarget =
- appView
- .appInfoForDesugaring()
- .lookupSuperTarget(invokeSuper.getInvokedMethod(), code.context());
- if (superTarget != null && superTarget.isLibraryMethod()) {
- // Rewriting is required because the super invoke resolves into a missing
- // method (method is on desugared library). Find out if it needs to be
- // retarget or if it just calls a companion class method and rewrite.
- DexMethod retargetMethod =
- options.desugaredLibraryConfiguration.retargetMethod(superTarget, appView);
- if (retargetMethod == null) {
- DexMethod originalCompanionMethod =
- instanceAsMethodOfCompanionClass(
- superTarget.getReference(), DEFAULT_METHOD_PREFIX, factory);
- DexMethod companionMethod =
- factory.createMethod(
- getCompanionClassType(dexType),
- factory.protoWithDifferentFirstParameter(
- originalCompanionMethod.proto, dexType),
- originalCompanionMethod.name);
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- companionMethod, invokeSuper.outValue(), invokeSuper.arguments()));
- } else {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- retargetMethod, invokeSuper.outValue(), invokeSuper.arguments()));
- }
- }
- }
- }
- continue;
- }
-
- if (instruction.isInvokeDirect()) {
- InvokeDirect invokeDirect = instruction.asInvokeDirect();
- DexMethod method = invokeDirect.getInvokedMethod();
- if (factory.isConstructor(method)) {
- continue;
- }
-
- DexClass clazz = appInfo.definitionForHolder(method);
- if (clazz == null) {
- // Report missing class since we don't know if it is an interface.
- warnMissingType(encodedMethod.method, method.holder);
- } else if (clazz.isInterface()) {
- if (clazz.isLibraryClass()) {
- throw new CompilationError("Unexpected call to a private method " +
- "defined in library class " + clazz.toSourceString(),
- getMethodOrigin(encodedMethod.method));
- }
- DexEncodedMethod directTarget = clazz.lookupMethod(method);
- if (directTarget != null) {
- // This can be a private instance method call. Note that the referenced
- // method is expected to be in the current class since it is private, but desugaring
- // may move some methods or their code into other classes.
- if (directTarget.isPrivateMethod()) {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- privateAsMethodOfCompanionClass(method),
- invokeDirect.outValue(),
- invokeDirect.arguments()));
- } else {
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- defaultAsMethodOfCompanionClass(method),
- invokeDirect.outValue(),
- invokeDirect.arguments()));
- }
- } else {
- // The method can be a default method in the interface hierarchy.
- DexClassAndMethod virtualTarget =
- appView.appInfoForDesugaring().lookupMaximallySpecificMethod(clazz, method);
- if (virtualTarget != null) {
- // This is a invoke-direct call to a virtual method.
- instructions.replaceCurrentInstruction(
- new InvokeStatic(
- defaultAsMethodOfCompanionClass(virtualTarget.getDefinition().method),
- invokeDirect.outValue(),
- invokeDirect.arguments()));
- } else {
- // The below assert is here because a well-type program should have a target, but we
- // cannot throw a compilation error, since we have no knowledge about the input.
- assert false;
- }
- }
- }
- }
-
- if (instruction.isInvokeVirtual() || instruction.isInvokeInterface()) {
- InvokeMethod invokeMethod = instruction.asInvokeMethod();
- DexMethod invokedMethod = invokeMethod.getInvokedMethod();
- DexType dexType = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
- if (dexType != null) {
- // The call potentially ends up in a library class, in which case we need to rewrite,
- // since the code may be in the desugared library.
- SingleResolutionResult resolution =
- appView
- .appInfoForDesugaring()
- .resolveMethod(invokedMethod, invokeMethod.getInterfaceBit())
- .asSingleResolution();
- if (resolution != null
- && (resolution.getResolvedHolder().isLibraryClass()
- || appView.options().isDesugaredLibraryCompilation())) {
- rewriteCurrentInstructionToEmulatedInterfaceCall(
- dexType, invokedMethod, invokeMethod, instructions);
- }
+ instructions.replaceCurrentInstruction(
+ new InvokeStatic(retargetMethod, invoke.outValue(), invoke.arguments()));
}
}
}
}
}
+ private void rewriteInvokeInterfaceOrInvokeVirtual(
+ InvokeMethodWithReceiver invoke, InstructionListIterator instructions) {
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ DexType emulatedItf = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
+ if (emulatedItf == null) {
+ return;
+ }
+
+ // The call potentially ends up in a library class, in which case we need to rewrite, since the
+ // code may be in the desugared library.
+ SingleResolutionResult resolution =
+ appView
+ .appInfoForDesugaring()
+ .resolveMethod(invokedMethod, invoke.getInterfaceBit())
+ .asSingleResolution();
+ if (resolution != null
+ && (resolution.getResolvedHolder().isLibraryClass()
+ || appView.options().isDesugaredLibraryCompilation())) {
+ rewriteCurrentInstructionToEmulatedInterfaceCall(
+ emulatedItf, invokedMethod, invoke, instructions);
+ }
+ }
+
private DexType maximallySpecificEmulatedInterfaceOrNull(DexMethod invokedMethod) {
// Here we try to avoid doing the expensive look-up on all invokes.
if (!emulatedMethods.contains(invokedMethod.name)) {
@@ -547,12 +586,13 @@
DexMethod invokedMethod,
InvokeMethod invokeMethod,
InstructionListIterator instructions) {
- DexEncodedMethod defaultMethod = appView.definitionFor(emulatedItf).lookupMethod(invokedMethod);
- if (defaultMethod != null && !dontRewrite(defaultMethod.method)) {
- assert !defaultMethod.isAbstract();
+ DexClassAndMethod defaultMethod =
+ appView.definitionFor(emulatedItf).lookupClassMethod(invokedMethod);
+ if (defaultMethod != null && !dontRewrite(defaultMethod)) {
+ assert !defaultMethod.getAccessFlags().isAbstract();
instructions.replaceCurrentInstruction(
new InvokeStatic(
- emulateInterfaceLibraryMethod(invokedMethod, emulatedItf, factory),
+ emulateInterfaceLibraryMethod(defaultMethod),
invokeMethod.outValue(),
invokeMethod.arguments()));
}
@@ -570,10 +610,11 @@
return appView.rewritePrefix.hasRewrittenType(clazz.type, appView);
}
- boolean dontRewrite(DexMethod method) {
+ boolean dontRewrite(DexClassAndMethod method) {
for (Pair<DexType, DexString> dontRewrite :
options.desugaredLibraryConfiguration.getDontRewriteInvocation()) {
- if (method.holder == dontRewrite.getFirst() && method.name == dontRewrite.getSecond()) {
+ if (method.getHolderType() == dontRewrite.getFirst()
+ && method.getName() == dontRewrite.getSecond()) {
return true;
}
}
@@ -666,87 +707,82 @@
return false;
}
- private static DexMethod emulateInterfaceLibraryMethod(
- DexMethod method, DexType holder, DexItemFactory factory) {
+ private DexMethod emulateInterfaceLibraryMethod(DexClassAndMethod method) {
return factory.createMethod(
- getEmulateLibraryInterfaceClassType(holder, factory),
- factory.prependTypeToProto(holder, method.proto),
- factory.createString(method.name.toString()));
+ getEmulateLibraryInterfaceClassType(method.getHolderType(), factory),
+ factory.prependTypeToProto(method.getHolderType(), method.getProto()),
+ method.getName());
}
private DexProgramClass synthesizeEmulateInterfaceLibraryClass(
DexProgramClass theInterface, Map<DexType, List<DexType>> emulatedInterfacesHierarchy) {
List<DexEncodedMethod> emulationMethods = new ArrayList<>();
- for (DexEncodedMethod method : theInterface.methods()) {
- if (method.isDefaultMethod()) {
- DexMethod libraryMethod =
- factory.createMethod(
- emulatedInterfaces.get(theInterface.type), method.method.proto, method.method.name);
- DexMethod originalCompanionMethod =
- method.isStatic()
- ? staticAsMethodOfCompanionClass(method.method)
- : instanceAsMethodOfCompanionClass(method.method, DEFAULT_METHOD_PREFIX, factory);
- DexMethod companionMethod =
- factory.createMethod(
- getCompanionClassType(theInterface.type),
- originalCompanionMethod.proto,
- originalCompanionMethod.name);
+ theInterface.forEachProgramMethodMatching(
+ DexEncodedMethod::isDefaultMethod,
+ method -> {
+ DexMethod libraryMethod =
+ method.getReference().withHolder(emulatedInterfaces.get(theInterface.type), factory);
+ DexMethod companionMethod =
+ method.getAccessFlags().isStatic()
+ ? staticAsMethodOfCompanionClass(method)
+ : defaultAsMethodOfCompanionClass(method);
- // To properly emulate the library interface call, we need to compute the interfaces
- // inheriting from the interface and manually implement the dispatch with instance of.
- // The list guarantees that an interface is always after interfaces it extends,
- // hence reverse iteration.
- List<DexType> subInterfaces = emulatedInterfacesHierarchy.get(theInterface.type);
- List<Pair<DexType, DexMethod>> extraDispatchCases = new ArrayList<>();
- // In practice, there is usually a single case (except for tests),
- // so we do not bother to make the following loop more clever.
- Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
- options.desugaredLibraryConfiguration.getRetargetCoreLibMember();
- for (DexString methodName : retargetCoreLibMember.keySet()) {
- if (method.method.name == methodName) {
- for (DexType inType : retargetCoreLibMember.get(methodName).keySet()) {
- DexClass inClass = appView.definitionFor(inType);
- if (inClass != null && implementsInterface(inClass, theInterface.type)) {
- extraDispatchCases.add(
- new Pair<>(
- inType,
- factory.createMethod(
- retargetCoreLibMember.get(methodName).get(inType),
- factory.protoWithDifferentFirstParameter(
- originalCompanionMethod.proto, inType),
- method.method.name)));
+ // To properly emulate the library interface call, we need to compute the interfaces
+ // inheriting from the interface and manually implement the dispatch with instance of.
+ // The list guarantees that an interface is always after interfaces it extends,
+ // hence reverse iteration.
+ List<DexType> subInterfaces = emulatedInterfacesHierarchy.get(theInterface.type);
+ List<Pair<DexType, DexMethod>> extraDispatchCases = new ArrayList<>();
+ // In practice, there is usually a single case (except for tests),
+ // so we do not bother to make the following loop more clever.
+ Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
+ options.desugaredLibraryConfiguration.getRetargetCoreLibMember();
+ for (DexString methodName : retargetCoreLibMember.keySet()) {
+ if (method.getName() == methodName) {
+ for (DexType inType : retargetCoreLibMember.get(methodName).keySet()) {
+ DexClass inClass = appView.definitionFor(inType);
+ if (inClass != null && implementsInterface(inClass, theInterface.type)) {
+ extraDispatchCases.add(
+ new Pair<>(
+ inType,
+ factory.createMethod(
+ retargetCoreLibMember.get(methodName).get(inType),
+ factory.protoWithDifferentFirstParameter(
+ companionMethod.proto, inType),
+ method.getName())));
+ }
}
}
}
- }
- if (subInterfaces != null) {
- for (int i = subInterfaces.size() - 1; i >= 0; i--) {
- DexClass subInterfaceClass = appView.definitionFor(subInterfaces.get(i));
- assert subInterfaceClass != null; // Else computation of subInterface would have failed.
- // if the method is implemented, extra dispatch is required.
- DexEncodedMethod result = subInterfaceClass.lookupVirtualMethod(method.method);
- if (result != null && !result.isAbstract()) {
- extraDispatchCases.add(
- new Pair<>(
- subInterfaceClass.type,
- factory.createMethod(
- getCompanionClassType(subInterfaceClass.type),
- factory.protoWithDifferentFirstParameter(
- originalCompanionMethod.proto, subInterfaceClass.type),
- originalCompanionMethod.name)));
+ if (subInterfaces != null) {
+ for (int i = subInterfaces.size() - 1; i >= 0; i--) {
+ DexClass subInterfaceClass = appView.definitionFor(subInterfaces.get(i));
+ assert subInterfaceClass
+ != null; // Else computation of subInterface would have failed.
+ // if the method is implemented, extra dispatch is required.
+ DexEncodedMethod result =
+ subInterfaceClass.lookupVirtualMethod(method.getReference());
+ if (result != null && !result.isAbstract()) {
+ extraDispatchCases.add(
+ new Pair<>(
+ subInterfaceClass.type,
+ factory.createMethod(
+ getCompanionClassType(subInterfaceClass.type),
+ factory.protoWithDifferentFirstParameter(
+ companionMethod.proto, subInterfaceClass.type),
+ companionMethod.name)));
+ }
}
}
- }
- emulationMethods.add(
- DexEncodedMethod.toEmulateDispatchLibraryMethod(
- method.getHolderType(),
- emulateInterfaceLibraryMethod(method.method, method.getHolderType(), factory),
- companionMethod,
- libraryMethod,
- extraDispatchCases,
- appView));
- }
- }
+ emulationMethods.add(
+ DexEncodedMethod.toEmulateDispatchLibraryMethod(
+ method.getHolderType(),
+ emulateInterfaceLibraryMethod(method),
+ companionMethod,
+ libraryMethod,
+ extraDispatchCases,
+ appView));
+ });
if (emulationMethods.isEmpty()) {
return null;
}
@@ -799,17 +835,17 @@
return factory.createSynthesizedType(elTypeDescriptor);
}
- private void reportStaticInterfaceMethodHandle(DexMethod referencedFrom, DexMethodHandle handle) {
+ private void reportStaticInterfaceMethodHandle(ProgramMethod context, DexMethodHandle handle) {
if (handle.type.isInvokeStatic()) {
DexClass holderClass = appView.definitionFor(handle.asMethod().holder);
// NOTE: If the class definition is missing we can't check. Let it be handled as any other
// missing call target.
if (holderClass == null) {
- warnMissingType(referencedFrom, handle.asMethod().holder);
+ warnMissingType(context, handle.asMethod().holder);
} else if (holderClass.isInterface()) {
throw new Unimplemented(
"Desugaring of static interface method handle in `"
- + referencedFrom.toSourceString()
+ + context.toSourceString()
+ "` is not yet supported.");
}
}
@@ -831,15 +867,6 @@
return getCompanionClassType(type, factory);
}
- // Gets the forwarding class for the interface `type`.
- final DexType getDispatchClassType(DexType type) {
- assert type.isClassType();
- String descriptor = type.descriptor.toString();
- String dcTypeDescriptor = descriptor.substring(0, descriptor.length() - 1)
- + DISPATCH_CLASS_NAME_SUFFIX + ";";
- return factory.createType(dcTypeDescriptor);
- }
-
// Checks if `type` is a companion class.
public static boolean isCompanionClassType(DexType type) {
return type.descriptor.toString().endsWith(COMPANION_CLASS_NAME_SUFFIX + ";");
@@ -864,21 +891,15 @@
}
// Represent a static interface method as a method of companion class.
+ final DexMethod staticAsMethodOfCompanionClass(DexClassAndMethod method) {
+ return staticAsMethodOfCompanionClass(method.getReference());
+ }
+
final DexMethod staticAsMethodOfCompanionClass(DexMethod method) {
// No changes for static methods.
return factory.createMethod(getCompanionClassType(method.holder), method.proto, method.name);
}
- // Represent a static interface method as a method of dispatch class.
- final DexMethod staticAsMethodOfDispatchClass(DexMethod method) {
- return factory.createMethod(getDispatchClassType(method.holder), method.proto, method.name);
- }
-
- // Checks if the type ends with dispatch class suffix.
- public static boolean hasDispatchClassSuffix(DexType clazz) {
- return clazz.getName().endsWith(DISPATCH_CLASS_NAME_SUFFIX);
- }
-
private static DexMethod instanceAsMethodOfCompanionClass(
DexMethod method, String prefix, DexItemFactory factory) {
// Add an implicit argument to represent the receiver.
@@ -913,6 +934,10 @@
return defaultAsMethodOfCompanionClass(method, factory);
}
+ DexMethod defaultAsMethodOfCompanionClass(DexClassAndMethod method) {
+ return defaultAsMethodOfCompanionClass(method.getReference(), factory);
+ }
+
// Represent a private instance interface method as a method of companion class.
static DexMethod privateAsMethodOfCompanionClass(DexMethod method, DexItemFactory factory) {
// Add an implicit argument to represent the receiver.
@@ -1135,37 +1160,6 @@
return true;
}
- public static boolean isEmulatedInterfaceDispatch(AppView<?> appView, DexEncodedMethod method) {
- // Answers true if this method is already managed through emulated interface dispatch.
- Map<DexType, DexType> emulateLibraryInterface =
- appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface();
- if (emulateLibraryInterface.isEmpty()) {
- return false;
- }
- DexMethod methodToFind = method.method;
-
- // Look-up all superclass and interfaces, if an emulated interface is found, and it implements
- // the method, answers true.
- LinkedList<DexType> workList = new LinkedList<>();
- workList.add(methodToFind.holder);
- while (!workList.isEmpty()) {
- DexType dexType = workList.removeFirst();
- DexClass dexClass = appView.definitionFor(dexType);
- assert dexClass != null; // It is a library class, or we are doing L8 compilation.
- if (dexClass.isInterface() && emulateLibraryInterface.containsKey(dexType)) {
- DexEncodedMethod dexEncodedMethod = dexClass.lookupMethod(methodToFind);
- if (dexEncodedMethod != null) {
- return true;
- }
- }
- Collections.addAll(workList, dexClass.interfaces.values);
- if (dexClass.superType != appView.dexItemFactory().objectType) {
- workList.add(dexClass.superType);
- }
- }
- return false;
- }
-
private boolean shouldIgnoreFromReports(DexType missing) {
return appView.rewritePrefix.hasRewrittenType(missing, appView)
|| missing.isD8R8SynthesizedClassType()
@@ -1187,13 +1181,13 @@
options.warningMissingInterfaceForDesugar(classToDesugar, implementing, missing);
}
- private void warnMissingType(DexMethod referencedFrom, DexType missing) {
+ private void warnMissingType(ProgramMethod context, DexType missing) {
// Companion/Emulated interface/Conversion classes for desugared library won't be missing,
// they are in the desugared library.
if (shouldIgnoreFromReports(missing)) {
return;
}
- DexMethod method = appView.graphLens().getOriginalMethodSignature(referencedFrom);
+ DexMethod method = appView.graphLens().getOriginalMethodSignature(context.getReference());
Origin origin = getMethodOrigin(method);
MethodPosition position = new MethodPosition(method.asMethodReference());
options.warningMissingTypeForDesugar(origin, position, missing, method);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index 42787b7..c2db31a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -14,7 +14,6 @@
import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.code.InvokeSuper;
-import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.graph.AppView;
@@ -27,7 +26,6 @@
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.DexLibraryClass;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexProgramClass.ChecksumSupplier;
@@ -45,7 +43,6 @@
import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.collections.BidirectionalManyToManyRepresentativeMap;
@@ -362,85 +359,6 @@
return c -> 7 * checksum;
}
- DexProgramClass process(DexLibraryClass iface, Set<DexProgramClass> callers) {
- assert iface.isInterface();
-
- // The list of methods to be created in dispatch class.
- // NOTE: we do NOT check static methods being actually called on the interface against
- // static methods actually existing in that interface. It is essential for supporting
- // D8 desugaring when each class may be dexed separately since it allows us to assume
- // that all synthesized dispatch classes have the same set of methods so we don't
- // need to merge them.
- List<DexEncodedMethod> dispatchMethods = new ArrayList<>();
-
- // Process public static methods, for each of them create a method dispatching the call to it.
- for (DexEncodedMethod direct : iface.directMethods()) {
- MethodAccessFlags originalAccessFlags = direct.accessFlags;
- if (!originalAccessFlags.isStatic() || !originalAccessFlags.isPublic()) {
- // We assume only public static methods of library interfaces can be called
- // from program classes, since there should not be protected or package private
- // static methods on interfaces.
- assert !originalAccessFlags.isStatic() || originalAccessFlags.isPrivate();
- continue;
- }
-
- assert !rewriter.factory.isClassConstructor(direct.method);
-
- DexMethod origMethod = direct.method;
- DexMethod newMethod = rewriter.staticAsMethodOfDispatchClass(origMethod);
- // Create a forwarding method to the library static interface method. The method is added
- // to the dispatch class, however, the targeted method is still on the interface, so the
- // interface bit should be set to true.
- ForwardMethodBuilder forwardMethodBuilder =
- ForwardMethodBuilder.builder(appView.dexItemFactory())
- .setStaticSource(newMethod)
- .setStaticTarget(origMethod, true);
- DexEncodedMethod newEncodedMethod =
- new DexEncodedMethod(
- newMethod,
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false),
- MethodTypeSignature.noSignature(),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- forwardMethodBuilder.build(),
- true);
- newEncodedMethod.getMutableOptimizationInfo().markNeverInline();
- dispatchMethods.add(newEncodedMethod);
- }
-
- ClassAccessFlags dispatchClassFlags =
- ClassAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_FINAL | Constants.ACC_SYNTHETIC);
-
- // Create dispatch class.
- DexType dispatchClassType = rewriter.getDispatchClassType(iface.type);
- DexProgramClass dispatchClass =
- new DexProgramClass(
- dispatchClassType,
- null,
- new SynthesizedOrigin("interface dispatch", getClass()),
- dispatchClassFlags,
- rewriter.factory.objectType,
- DexTypeList.empty(),
- iface.sourceFile,
- null,
- Collections.emptyList(),
- null,
- Collections.emptyList(),
- ClassSignature.noSignature(),
- DexAnnotationSet.empty(),
- DexEncodedField.EMPTY_ARRAY,
- DexEncodedField.EMPTY_ARRAY,
- dispatchMethods.toArray(DexEncodedMethod.EMPTY_ARRAY),
- DexEncodedMethod.EMPTY_ARRAY,
- rewriter.factory.getSkipNameValidationForTesting(),
- DexProgramClass::checksumFromType,
- callers);
- syntheticClasses.put(iface, dispatchClass);
- return dispatchClass;
- }
-
private boolean canMoveToCompanionClass(DexEncodedMethod method) {
Code code = method.getCode();
assert code != null;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
index d41fd32..f7be74d 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
@@ -132,10 +132,10 @@
// The only encoded method.
CfCode code =
- BackportedMethods.CloseResourceMethod_closeResourceImpl(
- options, twrCloseResourceMethod);
- MethodAccessFlags flags = MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false);
+ BackportedMethods.CloseResourceMethod_closeResourceImpl(options, twrCloseResourceMethod);
+ MethodAccessFlags flags =
+ MethodAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false);
DexEncodedMethod method =
new DexEncodedMethod(
twrCloseResourceMethod,
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 8f510fb..1cce76e 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
@@ -985,6 +985,16 @@
continue;
}
+ if (invoke.isInvokeMethodWithReceiver()) {
+ if (iterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context)) {
+ continue;
+ }
+ } else if (invoke.isInvokeStatic()
+ && iterator.replaceCurrentInstructionByInitClassIfPossible(
+ appView, code, resolutionResult.getResolvedHolder().getType())) {
+ continue;
+ }
+
// TODO(b/156853206): Should not duplicate resolution.
ProgramMethod singleTarget = oracle.lookupSingleTarget(invoke, context);
if (singleTarget == null) {
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 39ce729..2950d4c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize;
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
import static com.google.common.base.Predicates.alwaysTrue;
@@ -14,7 +13,6 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
@@ -26,13 +24,10 @@
import com.android.tools.r8.ir.code.FieldInstruction;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.IRMetadata;
-import com.android.tools.r8.ir.code.InitClass;
import com.android.tools.r8.ir.code.InstancePut;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.InvokeStatic;
-import com.android.tools.r8.ir.code.InvokeVirtual;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.StaticPut;
@@ -44,7 +39,6 @@
import com.android.tools.r8.shaking.ProguardMemberRuleReturnValue;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringDiagnostic;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import java.util.ListIterator;
import java.util.Set;
@@ -216,8 +210,8 @@
}
if (current.isStaticGet()) {
StaticGet staticGet = current.asStaticGet();
- replaceInstructionByInitClassIfPossible(
- staticGet, staticGet.getField().holder, code, iterator, code.context());
+ iterator.replaceCurrentInstructionByInitClassIfPossible(
+ appView, code, staticGet.getField().holder);
}
replacement.setPosition(position);
if (block.hasCatchHandlers()) {
@@ -236,16 +230,12 @@
ListIterator<BasicBlock> blocks,
InstructionListIterator iterator,
InvokeMethod invoke) {
+ if (invoke.hasUnusedOutValue()) {
+ return;
+ }
+
DexMethod invokedMethod = invoke.getInvokedMethod();
- if (invokedMethod.proto.returnType.isVoidType()) {
- return;
- }
-
- if (!invoke.hasOutValue() || !invoke.outValue().hasNonDebugUsers()) {
- return;
- }
-
- DexType invokedHolder = invokedMethod.holder;
+ DexType invokedHolder = invokedMethod.getHolderType();
if (!invokedHolder.isClassType()) {
return;
}
@@ -302,10 +292,10 @@
invoke.setOutValue(null);
if (invoke.isInvokeMethodWithReceiver()) {
- replaceInstructionByNullCheckIfPossible(invoke, iterator, context);
+ iterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context);
} else if (invoke.isInvokeStatic()) {
- replaceInstructionByInitClassIfPossible(
- invoke, singleTarget.getHolderType(), code, iterator, context);
+ iterator.replaceCurrentInstructionByInitClassIfPossible(
+ appView, code, singleTarget.getHolderType());
}
// Insert the definition of the replacement.
@@ -404,11 +394,11 @@
// To preserve side effects, original field-get is replaced by an explicit null-check, if
// the field-get instruction may only fail with an NPE, or the field-get remains as-is.
if (current.isInstanceGet()) {
- replaceInstructionByNullCheckIfPossible(current, iterator, context);
+ iterator.replaceCurrentInstructionByNullCheckIfPossible(appView, context);
} else {
assert current.isStaticGet();
- replaceInstructionByInitClassIfPossible(
- current, target.getHolderType(), code, iterator, context);
+ iterator.replaceCurrentInstructionByInitClassIfPossible(
+ appView, code, target.getHolderType());
}
// Insert the definition of the replacement.
@@ -426,58 +416,6 @@
}
}
- private void replaceInstructionByNullCheckIfPossible(
- Instruction instruction, InstructionListIterator iterator, ProgramMethod context) {
- assert instruction.isInstanceFieldInstruction() || instruction.isInvokeMethodWithReceiver();
- assert !instruction.hasOutValue() || !instruction.outValue().hasAnyUsers();
- if (instruction.instructionMayHaveSideEffects(
- appView, context, Instruction.SideEffectAssumption.RECEIVER_NOT_NULL)) {
- return;
- }
- Value receiver =
- instruction.isInstanceFieldInstruction()
- ? instruction.asInstanceFieldInstruction().object()
- : instruction.asInvokeMethodWithReceiver().getReceiver();
- if (receiver.isNeverNull()) {
- iterator.removeOrReplaceByDebugLocalRead();
- return;
- }
- InvokeMethod replacement;
- if (appView.options().canUseRequireNonNull()) {
- DexMethod requireNonNullMethod = appView.dexItemFactory().objectsMethods.requireNonNull;
- replacement = new InvokeStatic(requireNonNullMethod, null, ImmutableList.of(receiver));
- } else {
- DexMethod getClassMethod = appView.dexItemFactory().objectMembers.getClass;
- replacement = new InvokeVirtual(getClassMethod, null, ImmutableList.of(receiver));
- }
- iterator.replaceCurrentInstruction(replacement);
- }
-
- private void replaceInstructionByInitClassIfPossible(
- Instruction instruction,
- DexType holder,
- IRCode code,
- InstructionListIterator iterator,
- ProgramMethod context) {
- assert instruction.isStaticFieldInstruction() || instruction.isInvokeStatic();
- if (instruction.instructionMayHaveSideEffects(
- appView, context, Instruction.SideEffectAssumption.CLASS_ALREADY_INITIALIZED)) {
- return;
- }
- if (!holder.classInitializationMayHaveSideEffectsInContext(appView, context)) {
- iterator.removeOrReplaceByDebugLocalRead();
- return;
- }
- if (!appView.canUseInitClass()) {
- return;
- }
- DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(holder));
- if (clazz != null) {
- Value dest = code.createValue(TypeElement.getInt());
- iterator.replaceCurrentInstruction(new InitClass(dest, clazz.type));
- }
- }
-
private void replaceInstancePutByNullCheckIfNeverRead(
IRCode code, InstructionListIterator iterator, InstancePut current) {
DexEncodedField field = appView.appInfo().resolveField(current.getField()).getResolvedField();
@@ -492,7 +430,7 @@
return;
}
- replaceInstructionByNullCheckIfPossible(current, iterator, code.context());
+ iterator.replaceCurrentInstructionByNullCheckIfPossible(appView, code.context());
}
private void replaceStaticPutByInitClassIfNeverRead(
@@ -509,8 +447,7 @@
return;
}
- replaceInstructionByInitClassIfPossible(
- current, field.getHolderType(), code, iterator, code.context());
+ iterator.replaceCurrentInstructionByInitClassIfPossible(appView, code, field.getHolderType());
}
/**
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 508e0f4..f673395 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
@@ -37,6 +37,7 @@
import com.android.tools.r8.ir.analysis.type.PrimitiveTypeElement;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.Add;
+import com.android.tools.r8.ir.code.Assume;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.BasicBlock.ThrowingInfo;
import com.android.tools.r8.ir.code.Binop;
@@ -782,7 +783,7 @@
// Process instruction. Returns true if an outline candidate was found.
private void processInstruction(Instruction instruction) {
// Figure out whether to include the instruction.
- boolean include = false;
+ boolean include;
int instructionIncrement = 1;
if (instruction.isConstInstruction()) {
if (index == start) {
@@ -811,13 +812,13 @@
includeInstruction(instruction);
// Check if this instruction ends the outline.
if (actualInstructions >= appView.options().outline.maxSize) {
- candidate(start, index + 1, actualInstructions);
+ candidate(start, index + 1);
} else {
index++;
}
} else if (index > start) {
// Do not add this instruction, candidate ends with previous instruction.
- candidate(start, index, actualInstructions);
+ candidate(start, index);
} else {
// Restart search from next instruction.
reset(index + 1);
@@ -830,7 +831,7 @@
int returnValueUsersLeftIfIncluded = returnValueUsersLeft;
if (returnValue != null) {
for (Value value : instruction.inValues()) {
- if (value == returnValue) {
+ if (value.getAliasedValue() == returnValue) {
returnValueUsersLeftIfIncluded--;
}
}
@@ -870,10 +871,9 @@
}
// Find the number of in-going arguments, if adding this instruction.
int newArgumentRegisters = argumentRegisters;
- if (instruction.inValues().size() > 0) {
- List<Value> inValues = orderedInValues(instruction, returnValue);
- for (int i = 0; i < inValues.size(); i++) {
- Value value = inValues.get(i);
+ if (invoke.hasArguments()) {
+ for (int i = 0; i < invoke.arguments().size(); i++) {
+ Value value = invoke.getArgument(i).getAliasedValue();
if (value == returnValue) {
continue;
}
@@ -884,7 +884,8 @@
newArgumentRegisters += value.requiredRegisters();
} else {
// For virtual calls only re-use the receiver argument.
- if (i > 0 || !arguments.contains(value)) {
+ Value receiver = invoke.asInvokeMethodWithReceiver().getReceiver().getAliasedValue();
+ if (value != receiver || !arguments.contains(value)) {
newArgumentRegisters += value.requiredRegisters();
}
}
@@ -907,7 +908,11 @@
offset++;
previous = instructions.get(index - offset);
} while (previous.isConstInstruction());
- if (!previous.isNewInstance() || previous.outValue() != returnValue) {
+ if (!previous.isNewInstance()) {
+ return false;
+ }
+ if (returnValue == null || returnValue != previous.outValue()) {
+ assert false;
return false;
}
// Clear pending new instance flag as the last thing, now the matching constructor is known
@@ -996,6 +1001,10 @@
// Add the current instruction to the outline.
private void includeInstruction(Instruction instruction) {
if (instruction.isAssume()) {
+ Assume assume = instruction.asAssume();
+ if (returnValue != null && assume.src().getAliasedValue() == returnValue) {
+ adjustReturnValueUsersLeft(assume.outValue().numberOfAllUsers() - 1);
+ }
return;
}
@@ -1005,12 +1014,7 @@
if (returnValue != null) {
for (Value value : inValues) {
if (value.getAliasedValue() == returnValue) {
- assert returnValueUsersLeft > 0;
- returnValueUsersLeft--;
- }
- if (returnValueUsersLeft == 0) {
- returnValue = null;
- returnType = appView.dexItemFactory().voidType;
+ adjustReturnValueUsersLeft(-1);
}
}
}
@@ -1080,9 +1084,18 @@
}
}
+ private void adjustReturnValueUsersLeft(int change) {
+ returnValueUsersLeft += change;
+ assert returnValueUsersLeft >= 0;
+ if (returnValueUsersLeft == 0) {
+ returnValue = null;
+ returnType = appView.dexItemFactory().voidType;
+ }
+ }
+
protected abstract void handle(int start, int end, Outline outline);
- private void candidate(int start, int index, int actualInstructions) {
+ private void candidate(int start, int index) {
List<Instruction> instructions = getInstructionArray();
assert !instructions.get(start).isConstInstruction();
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 143d776..0ce08a5 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
@@ -584,10 +584,13 @@
currentUsers = indirectOutValueUsers;
}
- assert !methodCallsOnInstance.isEmpty();
-
- inliner.performForcedInlining(
- method, code, methodCallsOnInstance, inliningIRProvider, Timing.empty());
+ if (!methodCallsOnInstance.isEmpty()) {
+ inliner.performForcedInlining(
+ method, code, methodCallsOnInstance, inliningIRProvider, Timing.empty());
+ } else {
+ assert indirectMethodCallsOnInstance.stream()
+ .noneMatch(method -> method.getDefinition().getOptimizationInfo().mayHaveSideEffects());
+ }
return true;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
index b1890af..ae91ac8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodSideEffectModelCollection.java
@@ -38,7 +38,10 @@
ImmutableMap.<DexMethod, BiPredicate<DexMethod, List<Value>>>builder()
.put(
dexItemFactory.stringMembers.constructor,
- (method, arguments) -> arguments.get(1).isNeverNull());
+ (method, arguments) -> arguments.get(1).isNeverNull())
+ .put(
+ dexItemFactory.stringMembers.valueOf,
+ (method, arguments) -> arguments.get(0).isNeverNull());
putAll(
builder,
dexItemFactory.stringBufferMethods.constructorMethods,
diff --git a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
index 25688ce..ef724ec 100644
--- a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.dex.Marker;
import com.android.tools.r8.errors.CodeSizeOverflowDiagnostic;
import com.android.tools.r8.errors.ConstantPoolOverflowDiagnostic;
-import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
@@ -126,35 +125,29 @@
LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(appView);
for (DexProgramClass clazz : application.classes()) {
assert SyntheticItems.verifyNotInternalSynthetic(clazz.getType());
- if (clazz.getSynthesizedFrom().isEmpty()
- || options.isDesugaredLibraryCompilation()
- || options.cfToCfDesugar) {
- try {
- writeClass(clazz, consumer, rewriter, markerString);
- } catch (ClassTooLargeException e) {
- throw appView
- .options()
- .reporter
- .fatalError(
- new ConstantPoolOverflowDiagnostic(
- clazz.getOrigin(),
- Reference.classFromBinaryName(e.getClassName()),
- e.getConstantPoolCount()));
- } catch (MethodTooLargeException e) {
- throw appView
- .options()
- .reporter
- .fatalError(
- new CodeSizeOverflowDiagnostic(
- clazz.getOrigin(),
- Reference.methodFromDescriptor(
- Reference.classFromBinaryName(e.getClassName()).getDescriptor(),
- e.getMethodName(),
- e.getDescriptor()),
- e.getCodeSize()));
- }
- } else {
- throw new Unimplemented("No support for synthetics in the Java bytecode backend.");
+ try {
+ writeClass(clazz, consumer, rewriter, markerString);
+ } catch (ClassTooLargeException e) {
+ throw appView
+ .options()
+ .reporter
+ .fatalError(
+ new ConstantPoolOverflowDiagnostic(
+ clazz.getOrigin(),
+ Reference.classFromBinaryName(e.getClassName()),
+ e.getConstantPoolCount()));
+ } catch (MethodTooLargeException e) {
+ throw appView
+ .options()
+ .reporter
+ .fatalError(
+ new CodeSizeOverflowDiagnostic(
+ clazz.getOrigin(),
+ Reference.methodFromDescriptor(
+ Reference.classFromBinaryName(e.getClassName()).getDescriptor(),
+ e.getMethodName(),
+ e.getDescriptor()),
+ e.getCodeSize()));
}
}
ApplicationWriter.supplyAdditionalConsumers(
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index b374e58..6b316f7 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -469,7 +469,6 @@
|| getMissingClasses().contains(type)
// TODO(b/150693139): Remove these exceptions once fixed.
|| InterfaceMethodRewriter.isCompanionClassType(type)
- || InterfaceMethodRewriter.hasDispatchClassSuffix(type)
|| InterfaceMethodRewriter.isEmulatedLibraryClassType(type)
|| type.toDescriptorString().startsWith("Lj$/$r8$retargetLibraryMember$")
|| TwrCloseResourceRewriter.isUtilityClassDescriptor(type)
@@ -577,6 +576,10 @@
return neverInlineDueToSingleCaller.contains(method.getReference());
}
+ public boolean isAssumeNoSideEffectsMethod(DexMethod method) {
+ return noSideEffects.containsKey(method);
+ }
+
public boolean isWhyAreYouNotInliningMethod(DexMethod method) {
return whyAreYouNotInlining.contains(method);
}
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 985090a..db914a4 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -63,12 +63,15 @@
import com.android.tools.r8.shaking.ProguardConfigurationRule;
import com.android.tools.r8.utils.IROrdering.IdentityIROrdering;
import com.android.tools.r8.utils.IROrdering.NondeterministicIROrdering;
+import com.android.tools.r8.utils.collections.DexClassAndMethodSet;
import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
import com.android.tools.r8.utils.structural.Ordered;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.io.IOException;
import java.io.PrintStream;
@@ -990,7 +993,7 @@
DexType libraryType,
DexType invalidSuperType,
String message,
- Set<DexEncodedMethod> retarget) {
+ DexClassAndMethodSet retarget) {
if (invalidLibraryClasses.add(invalidSuperType)) {
reporter.warning(
new InvalidLibrarySuperclassDiagnostic(
@@ -998,7 +1001,9 @@
Reference.classFromDescriptor(libraryType.toDescriptorString()),
Reference.classFromDescriptor(invalidSuperType.toDescriptorString()),
message,
- ListUtils.map(retarget, method -> method.getReference().asMethodReference())));
+ Lists.newArrayList(
+ Iterables.transform(
+ retarget, method -> method.getReference().asMethodReference()))));
}
}
diff --git a/src/main/java/com/android/tools/r8/utils/IterableUtils.java b/src/main/java/com/android/tools/r8/utils/IterableUtils.java
index ebbef95..cd1c0a0 100644
--- a/src/main/java/com/android/tools/r8/utils/IterableUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/IterableUtils.java
@@ -15,6 +15,16 @@
public class IterableUtils {
+ public static <S, T> boolean any(
+ Iterable<S> iterable, Function<S, T> transform, Predicate<T> predicate) {
+ for (S element : iterable) {
+ if (predicate.test(transform.apply(element))) {
+ return true;
+ }
+ }
+ return false;
+ }
+
public static <T> Iterable<T> append(Iterable<T> iterable, T element) {
return Iterables.concat(iterable, singleton(element));
}
diff --git a/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSet.java b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSet.java
new file mode 100644
index 0000000..ad7c3fe
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSet.java
@@ -0,0 +1,66 @@
+// 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.DexClassAndMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.google.common.collect.ImmutableMap;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+public class DexClassAndMethodSet extends DexClassAndMethodSetBase<DexClassAndMethod> {
+
+ private static final DexClassAndMethodSet EMPTY = new DexClassAndMethodSet(ImmutableMap::of);
+
+ protected DexClassAndMethodSet(
+ Supplier<? extends Map<DexMethod, DexClassAndMethod>> backingFactory) {
+ super(backingFactory);
+ }
+
+ protected DexClassAndMethodSet(
+ Supplier<? extends Map<DexMethod, DexClassAndMethod>> backingFactory,
+ Map<DexMethod, DexClassAndMethod> backing) {
+ super(backingFactory, backing);
+ }
+
+ public static DexClassAndMethodSet create() {
+ return new DexClassAndMethodSet(IdentityHashMap::new);
+ }
+
+ public static DexClassAndMethodSet create(int capacity) {
+ return new DexClassAndMethodSet(IdentityHashMap::new, new IdentityHashMap<>(capacity));
+ }
+
+ public static DexClassAndMethodSet create(DexClassAndMethod element) {
+ DexClassAndMethodSet result = create();
+ result.add(element);
+ return result;
+ }
+
+ public static DexClassAndMethodSet create(DexClassAndMethodSet methodSet) {
+ DexClassAndMethodSet newMethodSet = create();
+ newMethodSet.addAll(methodSet);
+ return newMethodSet;
+ }
+
+ public static DexClassAndMethodSet createConcurrent() {
+ return new DexClassAndMethodSet(ConcurrentHashMap::new);
+ }
+
+ public static DexClassAndMethodSet createLinked() {
+ return new DexClassAndMethodSet(LinkedHashMap::new);
+ }
+
+ public static DexClassAndMethodSet empty() {
+ return EMPTY;
+ }
+
+ public void addAll(DexClassAndMethodSet methods) {
+ backing.putAll(methods.backing);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSetBase.java b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSetBase.java
new file mode 100644
index 0000000..797d8b6
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMethodSetBase.java
@@ -0,0 +1,87 @@
+// 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.DexClassAndMethod;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.google.common.collect.Sets;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+public abstract class DexClassAndMethodSetBase<T extends DexClassAndMethod> implements Iterable<T> {
+
+ protected final Map<DexMethod, T> backing;
+ protected final Supplier<? extends Map<DexMethod, T>> backingFactory;
+
+ protected DexClassAndMethodSetBase(Supplier<? extends Map<DexMethod, T>> backingFactory) {
+ this(backingFactory, backingFactory.get());
+ }
+
+ protected DexClassAndMethodSetBase(
+ Supplier<? extends Map<DexMethod, T>> backingFactory, Map<DexMethod, T> backing) {
+ this.backing = backing;
+ this.backingFactory = backingFactory;
+ }
+
+ public boolean add(T method) {
+ T existing = backing.put(method.getReference(), method);
+ assert existing == null || existing.isStructurallyEqualTo(method);
+ return existing == null;
+ }
+
+ public void addAll(Iterable<T> methods) {
+ methods.forEach(this::add);
+ }
+
+ public boolean contains(DexEncodedMethod method) {
+ return backing.containsKey(method.getReference());
+ }
+
+ public boolean contains(T method) {
+ return backing.containsKey(method.getReference());
+ }
+
+ public void clear() {
+ backing.clear();
+ }
+
+ public boolean isEmpty() {
+ return backing.isEmpty();
+ }
+
+ @Override
+ public Iterator<T> iterator() {
+ return backing.values().iterator();
+ }
+
+ public boolean remove(DexMethod method) {
+ T existing = backing.remove(method);
+ return existing != null;
+ }
+
+ public boolean remove(DexEncodedMethod method) {
+ return remove(method.getReference());
+ }
+
+ public int size() {
+ return backing.size();
+ }
+
+ public Stream<T> stream() {
+ return backing.values().stream();
+ }
+
+ public Set<DexEncodedMethod> toDefinitionSet() {
+ assert backing instanceof IdentityHashMap;
+ Set<DexEncodedMethod> definitions = Sets.newIdentityHashSet();
+ forEach(method -> definitions.add(method.getDefinition()));
+ return definitions;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodSet.java b/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodSet.java
index f058bf1..d36d207 100644
--- a/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodSet.java
+++ b/src/main/java/com/android/tools/r8/utils/collections/ProgramMethodSet.java
@@ -11,32 +11,24 @@
import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.ProgramMethod;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Sets;
import java.util.IdentityHashMap;
-import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
-import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
-import java.util.stream.Stream;
-public class ProgramMethodSet implements Iterable<ProgramMethod> {
+public class ProgramMethodSet extends DexClassAndMethodSetBase<ProgramMethod> {
private static final ProgramMethodSet EMPTY = new ProgramMethodSet(ImmutableMap::of);
- private final Map<DexMethod, ProgramMethod> backing;
- private final Supplier<? extends Map<DexMethod, ProgramMethod>> backingFactory;
-
protected ProgramMethodSet(Supplier<? extends Map<DexMethod, ProgramMethod>> backingFactory) {
- this(backingFactory, backingFactory.get());
+ super(backingFactory);
}
protected ProgramMethodSet(
Supplier<? extends Map<DexMethod, ProgramMethod>> backingFactory,
Map<DexMethod, ProgramMethod> backing) {
- this.backing = backing;
- this.backingFactory = backingFactory;
+ super(backingFactory, backing);
}
public static ProgramMethodSet create() {
@@ -71,16 +63,6 @@
return EMPTY;
}
- public boolean add(ProgramMethod method) {
- ProgramMethod existing = backing.put(method.getReference(), method);
- assert existing == null || existing.isStructurallyEqualTo(method);
- return existing == null;
- }
-
- public void addAll(Iterable<ProgramMethod> methods) {
- methods.forEach(this::add);
- }
-
public void addAll(ProgramMethodSet methods) {
backing.putAll(methods.backing);
}
@@ -89,36 +71,6 @@
return add(new ProgramMethod(clazz, definition));
}
- public boolean contains(DexEncodedMethod method) {
- return backing.containsKey(method.getReference());
- }
-
- public boolean contains(ProgramMethod method) {
- return backing.containsKey(method.getReference());
- }
-
- public void clear() {
- backing.clear();
- }
-
- public boolean isEmpty() {
- return backing.isEmpty();
- }
-
- @Override
- public Iterator<ProgramMethod> iterator() {
- return backing.values().iterator();
- }
-
- public boolean remove(DexMethod method) {
- ProgramMethod existing = backing.remove(method);
- return existing != null;
- }
-
- public boolean remove(DexEncodedMethod method) {
- return remove(method.getReference());
- }
-
public ProgramMethodSet rewrittenWithLens(DexDefinitionSupplier definitions, GraphLens lens) {
ProgramMethodSet rewritten = new ProgramMethodSet(backingFactory);
forEach(
@@ -130,19 +82,4 @@
});
return rewritten;
}
-
- public int size() {
- return backing.size();
- }
-
- public Stream<ProgramMethod> stream() {
- return backing.values().stream();
- }
-
- public Set<DexEncodedMethod> toDefinitionSet() {
- assert backing instanceof IdentityHashMap;
- Set<DexEncodedMethod> definitions = Sets.newIdentityHashSet();
- forEach(method -> definitions.add(method.getDefinition()));
- return definitions;
- }
}
diff --git a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
index 726136f..d25c465 100644
--- a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
@@ -96,7 +96,6 @@
Assert.assertTrue(
descriptor.contains(LambdaRewriter.LAMBDA_CLASS_NAME_PREFIX)
|| descriptor.endsWith(InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX + ";")
- || descriptor.endsWith(InterfaceMethodRewriter.DISPATCH_CLASS_NAME_SUFFIX + ";")
|| descriptor.equals(TwrCloseResourceRewriter.UTILITY_CLASS_DESCRIPTOR)
|| descriptor.contains(SyntheticItems.EXTERNAL_SYNTHETIC_CLASS_SEPARATOR)
|| descriptor.equals(mainClassDescriptor));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
index f6e0d0a..f998b89 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
@@ -4,16 +4,23 @@
package com.android.tools.r8.desugar.desugaredlibrary;
+import static org.hamcrest.MatcherAssert.assertThat;
+
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.CodeMatchers;
+import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
+import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.jetbrains.annotations.NotNull;
+import org.junit.Assume;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -25,12 +32,13 @@
private final TestParameters parameters;
private final boolean shrinkDesugaredLibrary;
private static final String EXPECTED_OUTPUT =
- StringUtils.lines("1", "2", "3", "4", "5", "Count: 4");
+ StringUtils.lines("1", "2", "3", "4", "5", "Count: 4", "1", "2", "3", "4", "5");
@Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
public static List<Object[]> data() {
return buildParameters(
- BooleanUtils.values(), getTestParameters().withAllRuntimes().withAllApiLevels().build());
+ BooleanUtils.values(),
+ getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build());
}
public IterableTest(boolean shrinkDesugaredLibrary, TestParameters parameters) {
@@ -38,6 +46,54 @@
this.parameters = parameters;
}
+ private void inspect(CodeInspector inspector) {
+ if (parameters
+ .getApiLevel()
+ .isGreaterThanOrEqualTo(apiLevelWithDefaultInterfaceMethodsSupport())) {
+ assertThat(
+ inspector.clazz(MyIterableSub.class).uniqueMethodWithFinalName("myForEach"),
+ CodeMatchers.invokesMethod(null, MyIterable.class.getTypeName(), "forEach", null));
+ } else {
+ assertThat(
+ inspector.clazz(MyIterableSub.class).uniqueMethodWithFinalName("myForEach"),
+ CodeMatchers.invokesMethod(null, "j$.lang.Iterable$-CC", "$default$forEach", null));
+ }
+ }
+
+ @Test
+ public void testIterableD8Cf() throws Exception {
+ // Only test without shrinking desugared library.
+ Assume.assumeFalse(shrinkDesugaredLibrary);
+ // Use D8 to desugar with Java classfile output.
+ Path jar =
+ testForD8(Backend.CF)
+ .addInnerClasses(IterableTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .writeToZip();
+
+ if (parameters.getRuntime().isDex()) {
+ // Convert to DEX without desugaring and run.
+ testForD8()
+ .addProgramFiles(jar)
+ .setMinApi(parameters.getApiLevel())
+ .disableDesugaring()
+ .compile()
+ .addRunClasspathFiles(buildDesugaredLibrary(parameters.getApiLevel()))
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ } else {
+ // Run on the JVM with desugared library on classpath.
+ testForJvm()
+ .addProgramFiles(jar)
+ .addRunClasspathFiles(buildDesugaredLibraryClassFile(parameters.getApiLevel()))
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+ }
+
@Test
public void testIterable() throws Exception {
if (parameters.isCfRuntime()) {
@@ -69,6 +125,8 @@
iterable.forEach(System.out::println);
Stream<Integer> stream = StreamSupport.stream(iterable.spliterator(), false);
System.out.println("Count: " + stream.filter(x -> x != 3).count());
+ MyIterableSub<Integer> iterableSub = new MyIterableSub<>(Arrays.asList(1, 2, 3, 4, 5));
+ iterableSub.myForEach(System.out::println);
}
}
@@ -86,4 +144,15 @@
return collection.iterator();
}
}
+
+ static class MyIterableSub<E> extends MyIterable<E> {
+
+ public MyIterableSub(Collection<E> collection) {
+ super(collection);
+ }
+
+ public void myForEach(Consumer<E> consumer) {
+ super.forEach(consumer);
+ }
+ }
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
index 3e40117..31bbcbd 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
@@ -5,10 +5,13 @@
package com.android.tools.r8.desugar.desugaredlibrary;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestCompileResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.graph.DexType;
@@ -19,6 +22,7 @@
import com.android.tools.r8.utils.codeinspector.CheckCastInstructionSubject;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.CodeMatchers;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import com.android.tools.r8.utils.codeinspector.InvokeInstructionSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -26,6 +30,12 @@
import com.android.tools.r8.utils.codeinspector.TypeSubject;
import com.google.common.collect.ImmutableSet;
import java.nio.file.Path;
+import java.time.DateTimeException;
+import java.time.ZoneId;
+import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalField;
+import java.time.temporal.TemporalQueries;
+import java.time.temporal.TemporalQuery;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
@@ -48,6 +58,8 @@
"1970-01-02T10:17:36.789Z",
"GMT",
"GMT",
+ "true",
+ "true",
"Hello, world");
@Parameters(name = "{2}, shrinkDesugaredLibrary: {0}, traceReferencesKeepRules {1}")
@@ -69,7 +81,15 @@
this.parameters = parameters;
}
- private void checkRewrittenInvokes(CodeInspector inspector) {
+ private void checkRewrittenInvokesForD8(CodeInspector inspector) {
+ checkRewrittenInvokes(inspector, false);
+ }
+
+ private void checkRewrittenInvokesForR8(CodeInspector inspector) {
+ checkRewrittenInvokes(inspector, true);
+ }
+
+ private void checkRewrittenInvokes(CodeInspector inspector, boolean isR8) {
Set<String> expectedInvokeHolders;
Set<String> expectedCatchGuards;
Set<String> expectedCheckCastType;
@@ -118,6 +138,31 @@
.map(TypeSubject::toString)
.collect(Collectors.toSet());
assertEquals(expectedCatchGuards, foundCatchGuards);
+
+ if (isR8) {
+ assertThat(
+ inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithFinalName("query"),
+ not(isPresent()));
+ } else {
+ assertThat(
+ inspector.clazz(TemporalAccessorImplSub.class).uniqueMethodWithFinalName("query"),
+ CodeMatchers.invokesMethod(
+ null, TemporalAccessorImpl.class.getTypeName(), "query", null));
+ }
+ if (parameters
+ .getApiLevel()
+ .isGreaterThanOrEqualTo(TestBase.apiLevelWithDefaultInterfaceMethodsSupport())) {
+ assertThat(
+ inspector.clazz(TemporalAccessorImpl.class).uniqueMethodWithName("query"),
+ not(isPresent()));
+ } else {
+ assertThat(
+ inspector
+ .clazz(isR8 ? TemporalAccessorImplSub.class : TemporalAccessorImpl.class)
+ .uniqueMethodWithFinalName("query"),
+ CodeMatchers.invokesMethod(
+ null, "j$.time.temporal.TemporalAccessor$-CC", "$default$query", null));
+ }
}
private String desugaredLibraryKeepRules(
@@ -149,7 +194,7 @@
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
- .inspect(this::checkRewrittenInvokes)
+ .inspect(this::checkRewrittenInvokesForD8)
.writeToZip();
String desugaredLibraryKeepRules;
@@ -198,7 +243,7 @@
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
- .inspect(this::checkRewrittenInvokes);
+ .inspect(this::checkRewrittenInvokesForD8);
result
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibrary,
@@ -219,11 +264,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(JavaTimeTest.class)
.addKeepMainRule(TestClass.class)
+ .enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.enableInliningAnnotations()
.compile()
- .inspect(this::checkRewrittenInvokes);
+ .inspect(this::checkRewrittenInvokesForR8);
result
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibrary,
@@ -234,6 +280,31 @@
.assertSuccessWithOutput(expectedOutput);
}
+ @NoVerticalClassMerging
+ static class TemporalAccessorImpl implements TemporalAccessor {
+ @Override
+ public boolean isSupported(TemporalField field) {
+ return false;
+ }
+
+ @Override
+ public long getLong(TemporalField field) {
+ throw new DateTimeException("Mock");
+ }
+ }
+
+ @NoVerticalClassMerging
+ static class TemporalAccessorImplSub extends TemporalAccessorImpl {
+ @SuppressWarnings("unchecked")
+ @Override
+ public <R> R query(TemporalQuery<R> query) {
+ if (query == TemporalQueries.zoneId()) {
+ return (R) ZoneId.of("GMT");
+ }
+ return super.query(query);
+ }
+ }
+
static class TestClass {
@NeverInline
@@ -246,6 +317,36 @@
return System.currentTimeMillis() > 0 ? null : new Object();
}
+ public static void superInvokeOnLibraryDesugaredDefaultMethod() {
+ TemporalAccessor mock =
+ new TemporalAccessor() {
+ @Override
+ public boolean isSupported(TemporalField field) {
+ return false;
+ }
+
+ @Override
+ public long getLong(TemporalField field) {
+ throw new DateTimeException("Mock");
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <R> R query(TemporalQuery<R> query) {
+ if (query == TemporalQueries.zoneId()) {
+ return (R) ZoneId.of("GMT");
+ }
+ return TemporalAccessor.super.query(query);
+ }
+ };
+ System.out.println(ZoneId.from(mock).equals(ZoneId.of("GMT")));
+ }
+
+ public static void superInvokeOnLibraryDesugaredDefaultMethodFromSubclass() {
+ TemporalAccessor mock = new TemporalAccessorImplSub();
+ System.out.println(ZoneId.from(mock).equals(ZoneId.of("GMT")));
+ }
+
public static void main(String[] args) {
java.time.Clock.systemDefaultZone();
try {
@@ -266,6 +367,9 @@
System.out.println(timeZone.getID());
System.out.println(timeZone.toZoneId().getId());
+ superInvokeOnLibraryDesugaredDefaultMethod();
+ superInvokeOnLibraryDesugaredDefaultMethodFromSubclass();
+
System.out.println("Hello, world");
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
index 294efee..bcdd93f 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/StringSwitchConversionFromIfTest.java
@@ -7,7 +7,7 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestBase;
@@ -87,7 +87,16 @@
// instruction may throw. This holds even if the string-switch instruction is
// compiled to a sequence of `if (x.equals("..."))` instructions that do not even
// use the hash code.
- assertNotEquals(0, hashCodeValues.size());
+ assertTrue(
+ code.collectArguments().get(0).uniqueUsers().stream()
+ .filter(Instruction::isInvokeMethod)
+ .map(Instruction::asInvokeMethod)
+ .map(invoke -> invoke.getInvokedMethod().getName().toSourceString())
+ .anyMatch(
+ name ->
+ name.equals("getClass")
+ || name.equals("hashCode")
+ || name.equals("requireNonNull")));
}
})
.run(parameters.getRuntime(), TestClass.class)
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 af047b9..7049089 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
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -333,7 +335,7 @@
assertCounters(INLINABLE, NEVER_INLINABLE, countInvokes(inspector, m));
m = clazz.method("int", "notInlinableDueToMissingNpe", ImmutableList.of("inlining.A"));
- assertCounters(INLINABLE, NEVER_INLINABLE, countInvokes(inspector, m));
+ assertCounters(INLINABLE, ALWAYS_INLINABLE, countInvokes(inspector, m));
m = clazz.method("int", "notInlinableDueToSideEffect", ImmutableList.of("inlining.A"));
assertCounters(INLINABLE, NEVER_INLINABLE, countInvokes(inspector, m));
@@ -354,7 +356,12 @@
CodeInspector inspector =
new CodeInspector(getGeneratedFiles(), getGeneratedProguardMap(), null);
ClassSubject clazz = inspector.clazz(nullabilityClass);
- MethodSubject m = clazz.method("int", "conditionalOperator", ImmutableList.of("inlining.A"));
+ assertThat(clazz.uniqueMethodWithName("conditionalOperator"), isAbsent());
+
+ // The enum parameter may get unboxed.
+ MethodSubject m =
+ clazz.uniqueMethodWithName(
+ parameters.isCfRuntime() ? "moreControlFlows" : "moreControlFlows$enumunboxing$");
assertTrue(m.isPresent());
// Verify that a.b() is resolved to an inline instance-get.
@@ -365,27 +372,6 @@
InstructionSubject instruction = iterator.next();
if (instruction.isInstanceGet()) {
++instanceGetCount;
- } else if (instruction.isInvoke()) {
- ++invokeCount;
- }
- }
- assertEquals(1, instanceGetCount);
- assertEquals(0, invokeCount);
-
- // The enum parameter may get unboxed.
- m =
- clazz.uniqueMethodWithName(
- parameters.isCfRuntime() ? "moreControlFlows" : "moreControlFlows$enumunboxing$");
- assertTrue(m.isPresent());
-
- // Verify that a.b() is resolved to an inline instance-get.
- iterator = m.iterateInstructions();
- instanceGetCount = 0;
- invokeCount = 0;
- while (iterator.hasNext()) {
- InstructionSubject instruction = iterator.next();
- if (instruction.isInstanceGet()) {
- ++instanceGetCount;
} else if (instruction.isInvoke() && !isEnumInvoke(instruction)) {
++invokeCount;
}
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
index c253c45..8d01a11 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeElement;
import com.android.tools.r8.ir.code.BasicBlock;
@@ -23,6 +24,7 @@
import com.android.tools.r8.ir.code.Move;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import java.util.LinkedList;
import java.util.List;
@@ -62,6 +64,18 @@
}
@Override
+ public boolean replaceCurrentInstructionByNullCheckIfPossible(
+ AppView<?> appView, ProgramMethod context) {
+ throw new Unimplemented();
+ }
+
+ @Override
+ public boolean replaceCurrentInstructionByInitClassIfPossible(
+ AppView<AppInfoWithLiveness> appView, IRCode code, DexType type) {
+ throw new Unimplemented();
+ }
+
+ @Override
public void replaceCurrentInstructionWithConstClass(
AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo) {
throw new Unimplemented();
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
index 447ed7e..7565cf7 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -87,7 +87,7 @@
.assertErrorsMatch(
diagnosticMessage(
containsString(
- "--main-dex-list-output require --main-dex-rules and/or"
+ "--main-dex-list-output requires --main-dex-rules and/or"
+ " --main-dex-list"))));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
index eb29f88..fed4e6d 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumeNoSideEffectsForJavaLangClassTest.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.onlyIf;
+import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.AssumeMayHaveSideEffects;
@@ -71,7 +72,11 @@
assertThat(
methodSubject,
onlyIf(maybeNullReceiver || maybeSubtype, invokesMethodWithName("hashCode")));
- assertThat(methodSubject, onlyIf(maybeNullReceiver, invokesMethodWithName("getClass")));
+ assertThat(
+ methodSubject,
+ onlyIf(
+ maybeNullReceiver,
+ anyOf(invokesMethodWithName("getClass"), invokesMethodWithName("requireNonNull"))));
assertThat(
methodSubject,
onlyIf(maybeNullReceiver || maybeSubtype, invokesMethodWithName("toString")));
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationTest.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationTest.java
index 1c7f6ac..8130a6f 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/AssumenosideeffectsPropagationTest.java
@@ -111,7 +111,7 @@
private final TestConfig config;
private final boolean enableHorizontalClassMerging;
- @Parameterized.Parameters(name = "{0} {1}")
+ @Parameterized.Parameters(name = "{0}, config: {1}, horizontal: {2}")
public static Collection<Object[]> data() {
return buildParameters(
getTestParameters().withAllRuntimesAndApiLevels().build(),
diff --git a/src/test/java/com/android/tools/r8/smali/OutlineTest.java b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
index e85f2d8..04ac085 100644
--- a/src/test/java/com/android/tools/r8/smali/OutlineTest.java
+++ b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
@@ -252,7 +252,7 @@
" move-result-object v0",
" invoke-virtual { v0, v1 }, " + stringBuilderAppendSignature,
" move-result-object v0",
- " invoke-virtual { v0 }, " + stringBuilderToStringSignature,
+ " invoke-virtual { v0, v1 }, " + stringBuilderAppendSignature,
" move-result-object v0",
" const v0, 0",
" const v1, 1",
@@ -818,7 +818,7 @@
" move-result-object v0",
" invoke-virtual { v0, v1 }, " + stringBuilderAppendSignature,
" move-result-object v0",
- " invoke-virtual { v0 }, " + stringBuilderToStringSignature,
+ " invoke-virtual { v0, v1 }, " + stringBuilderAppendSignature,
" return-void");
String returnType2 = "java.lang.String";
@@ -866,14 +866,14 @@
ClassSubject clazz = inspector.clazz(OutlineOptions.CLASS_NAME);
assertTrue(clazz.isPresent());
assertEquals(3, clazz.getDexProgramClass().getMethodCollection().numberOfDirectMethods());
- // Collect the return types of the putlines for the body of method1 and method2.
+ // Collect the return types of the outlines for the body of method1 and method2.
List<DexType> r = new ArrayList<>();
for (DexEncodedMethod directMethod : clazz.getDexProgramClass().directMethods()) {
if (directMethod.getCode().asDexCode().instructions[0] instanceof InvokeVirtual) {
r.add(directMethod.method.proto.returnType);
}
}
- assert r.size() == 2;
+ assertEquals(2, r.size());
DexType r1 = r.get(0);
DexType r2 = r.get(1);
DexItemFactory factory = inspector.getFactory();
@@ -882,7 +882,7 @@
// Run the code.
String result = runArt(processedApplication);
- assertEquals("TestTestTestTest", result);
+ assertEquals("TestTestTestTestTest", result);
}
@Test
diff --git a/tools/archive.py b/tools/archive.py
index b7ca7c0..e92e87d 100755
--- a/tools/archive.py
+++ b/tools/archive.py
@@ -145,6 +145,8 @@
utils.D8,
utils.R8LIB,
utils.R8LIB_NO_DEPS,
+ utils.R8RETRACE,
+ utils.R8RETRACE_NO_DEPS,
utils.LIBRARY_DESUGAR_CONVERSIONS,
'-Pno_internal'
])
@@ -191,6 +193,8 @@
utils.R8_FULL_EXCLUDE_DEPS_JAR,
utils.R8LIB_EXCLUDE_DEPS_JAR,
utils.R8LIB_EXCLUDE_DEPS_JAR + '.map',
+ utils.R8RETRACE_JAR,
+ utils.R8RETRACE_EXCLUDE_DEPS_JAR,
utils.MAVEN_ZIP,
utils.MAVEN_ZIP_LIB,
utils.DESUGAR_CONFIGURATION,
diff --git a/tools/as_utils.py b/tools/as_utils.py
index fa81ac4..43153c6 100644
--- a/tools/as_utils.py
+++ b/tools/as_utils.py
@@ -3,11 +3,18 @@
# 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.
+import utils
+
from distutils.version import LooseVersion
-from HTMLParser import HTMLParser
import os
import shutil
+if utils.is_python3():
+ from html.parser import HTMLParser
+else:
+ from HTMLParser import HTMLParser
+
+
def add_r8_dependency(checkout_dir, temp_dir, minified):
build_file = os.path.join(checkout_dir, 'build.gradle')
assert os.path.isfile(build_file), (
diff --git a/tools/r8_release.py b/tools/r8_release.py
index c3aff38..31bb4c6 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -362,6 +362,7 @@
g4_open('src.jar')
g4_open('lib.jar')
g4_open('lib.jar.map')
+ g4_open('retrace.jar')
g4_open('desugar_jdk_libs_configuration.jar')
download_file(options.version, 'r8-full-exclude-deps.jar', 'full.jar')
download_file(options.version, 'r8-src.jar', 'src.jar')
@@ -370,6 +371,7 @@
options.version, 'r8lib-exclude-deps.jar.map', 'lib.jar.map')
download_file(options.version, 'desugar_jdk_libs_configuration.jar',
'desugar_jdk_libs_configuration.jar')
+ download_file(options.version, 'r8retrace-exclude-deps.jar', 'retrace.jar')
g4_open('METADATA')
sed(r'[1-9]\.[0-9]{1,2}\.[0-9]{1,3}-dev',
options.version,
diff --git a/tools/run_on_app_dump.py b/tools/run_on_app_dump.py
index 4509656..c4de6e3 100755
--- a/tools/run_on_app_dump.py
+++ b/tools/run_on_app_dump.py
@@ -5,6 +5,7 @@
import adb
import apk_masseur
+import as_utils
import compiledump
import gradle
import optparse
@@ -516,7 +517,7 @@
result['status'] = 'success'
result_per_shrinker = build_app_with_shrinkers(
app, options, temp_dir, app_dir)
- for shrinker, shrinker_result in result_per_shrinker.iteritems():
+ for shrinker, shrinker_result in result_per_shrinker.items():
result[shrinker] = shrinker_result
return result
@@ -940,7 +941,8 @@
assert any(app.name == app_name for app in options.apps)
if options.shrinker:
for shrinker in options.shrinker:
- assert shrinker in SHRINKERS
+ assert shrinker in SHRINKERS, (
+ 'Shrinker must be one of %s' % ', '.join(SHRINKERS))
else:
options.shrinker = [shrinker for shrinker in SHRINKERS]
diff --git a/tools/utils.py b/tools/utils.py
index 351a038..ee49000 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -41,6 +41,8 @@
R8 = 'r8'
R8LIB = 'r8lib'
R8LIB_NO_DEPS = 'r8LibNoDeps'
+R8RETRACE = 'R8Retrace'
+R8RETRACE_NO_DEPS = 'R8RetraceNoDeps'
R8_SRC = 'sourceJar'
LIBRARY_DESUGAR_CONVERSIONS = 'buildLibraryDesugarConversions'
@@ -52,6 +54,8 @@
R8_SRC_JAR = os.path.join(LIBS, 'r8-src.jar')
R8LIB_EXCLUDE_DEPS_JAR = os.path.join(LIBS, 'r8lib-exclude-deps.jar')
R8_FULL_EXCLUDE_DEPS_JAR = os.path.join(LIBS, 'r8-full-exclude-deps.jar')
+R8RETRACE_JAR = os.path.join(LIBS, 'r8retrace.jar')
+R8RETRACE_EXCLUDE_DEPS_JAR = os.path.join(LIBS, 'r8retrace-exclude-deps.jar')
MAVEN_ZIP = os.path.join(LIBS, 'r8.zip')
MAVEN_ZIP_LIB = os.path.join(LIBS, 'r8lib.zip')
LIBRARY_DESUGAR_CONVERSIONS_ZIP = os.path.join(LIBS, 'library_desugar_conversions.zip')
@@ -104,6 +108,9 @@
version = os.environ.get(ANDROID_TOOLS_VERSION_ENVIRONMENT_NAME, '28.0.3')
return os.path.join(getAndroidHome(), 'build-tools', version)
+def is_python3():
+ return sys.version_info.major == 3
+
def Print(s, quiet=False):
if quiet:
return
