Towards an inlining oracle for jar code
It is only possible to merge a type A into its subtype B if A.<init>() can be inlined into B.<init>(). Thus we need to be sure that A.<init>() can in fact be inlined into B.<init>() *before* we merge the two classes.
The current infrastructure does not allow us to determine if this is possible, since we only have the jar code available by the time we run the vertical class merger, and the inliner looks at the instructions in the IR to determine if a method is eligible for inlining (see Inliner.computeInliningConstraint).
To address this problem, this CL creates a new visitor for ASM code called InliningConstraintVisitor that carries out the same checks as Inliner.computeInliningConstraint.
(Note that the implementation of InliningConstraintVisitor is still incomplete.)
Change-Id: I535425554bbeba4da0a2bd57f281a866b7ffdcef
diff --git a/src/main/java/com/android/tools/r8/graph/JarCode.java b/src/main/java/com/android/tools/r8/graph/JarCode.java
index 640172f..d64eaf0 100644
--- a/src/main/java/com/android/tools/r8/graph/JarCode.java
+++ b/src/main/java/com/android/tools/r8/graph/JarCode.java
@@ -10,9 +10,12 @@
import com.android.tools.r8.ir.code.ValueNumberGenerator;
import com.android.tools.r8.ir.conversion.IRBuilder;
import com.android.tools.r8.ir.conversion.JarSourceCode;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.jar.InliningConstraintVisitor;
import com.android.tools.r8.jar.JarRegisterEffectsVisitor;
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
import java.io.PrintWriter;
@@ -169,6 +172,21 @@
DescriptorUtils.getDescriptorFromClassBinaryName(tryCatchBlockNode.type))));
}
+ public Constraint computeInliningConstraint(
+ AppInfoWithLiveness appInfo, GraphLense graphLense, DexType invocationContext) {
+ InliningConstraintVisitor visitor =
+ new InliningConstraintVisitor(application, appInfo, graphLense, method, invocationContext);
+ AbstractInsnNode insn = node.instructions.getFirst();
+ while (insn != null) {
+ insn.accept(visitor);
+ if (visitor.isFinished()) {
+ break;
+ }
+ insn = insn.getNext();
+ }
+ return visitor.getConstraint();
+ }
+
@Override
public String toString() {
triggerDelayedParsingIfNeccessary();
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
index b343de7..1ad50bc 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
import java.util.Collections;
@@ -113,7 +114,7 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- return inliningConstraintForSinlgeTargetInvoke(info, invocationContext);
+ return new InliningConstraints(info).forInvokeDirect(getInvokedMethod(), invocationContext);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
index ff8f0d0..0fb447b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
import java.util.List;
@@ -95,7 +96,7 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- return inliningConstraintForVirtualInvoke(info, invocationContext);
+ return new InliningConstraints(info).forInvokeInterface(getInvokedMethod(), invocationContext);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
index 5fe8972..56b659a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
@@ -5,9 +5,7 @@
import com.android.tools.r8.cf.LoadStoreHelper;
import com.android.tools.r8.cf.TypeVerificationHelper;
-import com.android.tools.r8.graph.AppInfo.ResolutionResult;
import com.android.tools.r8.graph.AppInfoWithSubtyping;
-import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
@@ -85,85 +83,11 @@
return lookupSingleTarget(appInfo, appInfo.dexItemFactory.objectType);
}
+ // TODO(christofferqa): Pass an instance of InliningConstraints instead of [info] when
+ // InliningConstraints is complete.
@Override
- public abstract Constraint inliningConstraint(AppInfoWithLiveness info,
- DexType invocationContext);
-
- protected Constraint inliningConstraintForSinlgeTargetInvoke(AppInfoWithLiveness info,
- DexType invocationContext) {
- if (method.holder.isArrayType()) {
- return Constraint.ALWAYS;
- }
- DexEncodedMethod target = lookupSingleTarget(info, invocationContext);
- if (target != null) {
- DexType methodHolder = target.method.holder;
- DexClass methodClass = info.definitionFor(methodHolder);
- if ((methodClass != null)) {
- Constraint methodConstraint = Constraint
- .deriveConstraint(invocationContext, methodHolder, target.accessFlags, info);
- // We also have to take the constraint of the enclosing class into account.
- Constraint classConstraint = Constraint
- .deriveConstraint(invocationContext, methodHolder, methodClass.accessFlags, info);
- return Constraint.min(methodConstraint, classConstraint);
- }
- }
- return Constraint.NEVER;
- }
-
- protected Constraint inliningConstraintForVirtualInvoke(AppInfoWithSubtyping info,
- DexType invocationContext) {
- if (method.holder.isArrayType()) {
- return Constraint.ALWAYS;
- }
- Collection<DexEncodedMethod> targets = lookupTargets(info, invocationContext);
- if (targets == null) {
- return Constraint.NEVER;
- }
-
- Constraint result = Constraint.ALWAYS;
-
- // Perform resolution and derive inlining constraints based on the accessibility of the
- // resolution result.
- ResolutionResult resolutionResult = info.resolveMethod(method.holder, method);
- DexEncodedMethod resolutionTarget = resolutionResult.asResultOfResolve();
- if (resolutionTarget == null) {
- // This will fail at runtime.
- return Constraint.NEVER;
- }
- DexType methodHolder = resolutionTarget.method.holder;
- DexClass methodClass = info.definitionFor(methodHolder);
- assert methodClass != null;
- Constraint methodConstraint = Constraint
- .deriveConstraint(invocationContext, methodHolder, resolutionTarget.accessFlags, info);
- result = Constraint.min(result, methodConstraint);
- // We also have to take the constraint of the enclosing class of the resolution result
- // into account. We do not allow inlining this method if it is calling something that
- // is inaccessible. Inlining in that case could move the code to another package making a
- // call succeed that should not succeed. Conversely, if the resolution result is accessible,
- // we have to make sure that inlining cannot make it inaccessible.
- Constraint classConstraint = Constraint
- .deriveConstraint(invocationContext, methodHolder, methodClass.accessFlags, info);
- result = Constraint.min(result, classConstraint);
- if (result == Constraint.NEVER) {
- return result;
- }
-
- // For each of the actual potential targets, derive constraints based on the accessibility
- // of the method itself.
- for (DexEncodedMethod target : targets) {
- methodHolder = target.method.holder;
- methodClass = info.definitionFor(methodHolder);
- assert methodClass != null;
- methodConstraint = Constraint
- .deriveConstraint(invocationContext, methodHolder, target.accessFlags, info);
- result = Constraint.min(result, methodConstraint);
- if (result == Constraint.NEVER) {
- return result;
- }
- }
-
- return result;
- }
+ public abstract Constraint inliningConstraint(
+ AppInfoWithLiveness info, DexType invocationContext);
public abstract InlineAction computeInlining(InliningOracle decider, DexType invocationContext);
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
index 81d4cdc..91f657d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
@@ -15,6 +15,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.ir.optimize.InliningOracle;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
@@ -126,7 +127,8 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- return Constraint.NEVER;
+ return new InliningConstraints(info)
+ .forInvokePolymorphic(getInvokedMethod(), invocationContext);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
index 94df8d3..b985916 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.ir.optimize.InliningOracle;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
@@ -103,7 +104,7 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- return inliningConstraintForSinlgeTargetInvoke(info, invocationContext);
+ return new InliningConstraints(info).forInvokeStatic(getInvokedMethod(), invocationContext);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
index e5bd604..64f0d7b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
import java.util.Collections;
@@ -112,7 +113,6 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- // The semantics of invoke super depend on the context.
- return Constraint.SAMECLASS;
+ return new InliningConstraints(info).forInvokeSuper(getInvokedMethod(), invocationContext);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
index d104270..85c80ed 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
import java.util.Collection;
import java.util.List;
@@ -95,7 +96,7 @@
@Override
public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
- return inliningConstraintForVirtualInvoke(info, invocationContext);
+ return new InliningConstraints(info).forInvokeVirtual(getInvokedMethod(), invocationContext);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
new file mode 100644
index 0000000..d4a06cd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -0,0 +1,148 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize;
+
+import com.android.tools.r8.graph.AppInfo.ResolutionResult;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
+import java.util.Collection;
+
+// Computes the inlining constraint for a given instruction.
+//
+// TODO(christofferqa): This class is incomplete.
+public class InliningConstraints {
+
+ private AppInfoWithLiveness appInfo;
+
+ // Currently used only by the vertical class merger (in all other cases this is the identity).
+ //
+ // When merging a type A into its subtype B we need to inline A.<init>() into B.<init>().
+ // Therefore, we need to be sure that A.<init>() can in fact be inlined into B.<init>() *before*
+ // we merge the two classes. However, at this point, we may reject the method A.<init>() from
+ // being inlined into B.<init>() only because it is not declared in the same class as B (which
+ // it would be after merging A and B).
+ //
+ // To circumvent this problem, the vertical class merger creates a graph lense that maps the
+ // type A to B, to create a temporary view of what the world would look like after class merging.
+ private GraphLense graphLense;
+
+ public InliningConstraints(AppInfoWithLiveness appInfo) {
+ this(appInfo, GraphLense.getIdentityLense());
+ }
+
+ public InliningConstraints(AppInfoWithLiveness appInfo, GraphLense graphLense) {
+ this.appInfo = appInfo;
+ this.graphLense = graphLense;
+ }
+
+ public Constraint forCheckCast(DexType type, DexType invocationContext) {
+ return Constraint.classIsVisible(invocationContext, type, appInfo);
+ }
+
+ public Constraint forInvokeDirect(DexMethod method, DexType invocationContext) {
+ return forSingleTargetInvoke(method, appInfo.lookupDirectTarget(method), invocationContext);
+ }
+
+ public Constraint forInvokeInterface(DexMethod method, DexType invocationContext) {
+ return forVirtualInvoke(method, appInfo.lookupInterfaceTargets(method), invocationContext);
+ }
+
+ public Constraint forInvokePolymorphic(DexMethod method, DexType invocationContext) {
+ return Constraint.NEVER;
+ }
+
+ public Constraint forInvokeStatic(DexMethod method, DexType invocationContext) {
+ return forSingleTargetInvoke(method, appInfo.lookupStaticTarget(method), invocationContext);
+ }
+
+ public Constraint forInvokeSuper(DexMethod method, DexType invocationContext) {
+ // The semantics of invoke super depend on the context.
+ return Constraint.SAMECLASS;
+ }
+
+ public Constraint forInvokeVirtual(DexMethod method, DexType invocationContext) {
+ return forVirtualInvoke(method, appInfo.lookupVirtualTargets(method), invocationContext);
+ }
+
+ private Constraint forSingleTargetInvoke(
+ DexMethod method, DexEncodedMethod target, DexType invocationContext) {
+ if (method.holder.isArrayType()) {
+ return Constraint.ALWAYS;
+ }
+ if (target != null) {
+ DexType methodHolder = graphLense.lookupType(target.method.holder);
+ DexClass methodClass = appInfo.definitionFor(methodHolder);
+ if (methodClass != null) {
+ Constraint methodConstraint =
+ Constraint.deriveConstraint(
+ invocationContext, methodHolder, target.accessFlags, appInfo);
+ // We also have to take the constraint of the enclosing class into account.
+ Constraint classConstraint =
+ Constraint.deriveConstraint(
+ invocationContext, methodHolder, methodClass.accessFlags, appInfo);
+ return Constraint.min(methodConstraint, classConstraint);
+ }
+ }
+ return Constraint.NEVER;
+ }
+
+ private Constraint forVirtualInvoke(
+ DexMethod method, Collection<DexEncodedMethod> targets, DexType invocationContext) {
+ if (method.holder.isArrayType()) {
+ return Constraint.ALWAYS;
+ }
+ if (targets == null) {
+ return Constraint.NEVER;
+ }
+
+ // Perform resolution and derive inlining constraints based on the accessibility of the
+ // resolution result.
+ ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
+ DexEncodedMethod resolutionTarget = resolutionResult.asResultOfResolve();
+ if (resolutionTarget == null) {
+ // This will fail at runtime.
+ return Constraint.NEVER;
+ }
+
+ DexType methodHolder = graphLense.lookupType(resolutionTarget.method.holder);
+ DexClass methodClass = appInfo.definitionFor(methodHolder);
+ assert methodClass != null;
+ Constraint methodConstraint =
+ Constraint.deriveConstraint(
+ invocationContext, methodHolder, resolutionTarget.accessFlags, appInfo);
+ // We also have to take the constraint of the enclosing class of the resolution result
+ // into account. We do not allow inlining this method if it is calling something that
+ // is inaccessible. Inlining in that case could move the code to another package making a
+ // call succeed that should not succeed. Conversely, if the resolution result is accessible,
+ // we have to make sure that inlining cannot make it inaccessible.
+ Constraint classConstraint =
+ Constraint.deriveConstraint(
+ invocationContext, methodHolder, methodClass.accessFlags, appInfo);
+ Constraint result = Constraint.min(methodConstraint, classConstraint);
+ if (result == Constraint.NEVER) {
+ return result;
+ }
+
+ // For each of the actual potential targets, derive constraints based on the accessibility
+ // of the method itself.
+ for (DexEncodedMethod target : targets) {
+ methodHolder = graphLense.lookupType(target.method.holder);
+ assert appInfo.definitionFor(methodHolder) != null;
+ methodConstraint =
+ Constraint.deriveConstraint(invocationContext, methodHolder, target.accessFlags, appInfo);
+ result = Constraint.min(result, methodConstraint);
+ if (result == Constraint.NEVER) {
+ return result;
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java b/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java
new file mode 100644
index 0000000..5652be8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java
@@ -0,0 +1,128 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.jar;
+
+import static org.objectweb.asm.Opcodes.ASM6;
+
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.graph.JarApplicationReader;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+// This visitor can be used to determine if a piece of jar code has any instructions that the
+// inliner would not be willing to inline. This can be used to determine if a method can be force
+// inlined although its IR is still not available.
+//
+// TODO(christofferqa): This class is incomplete. Still need to add support for ConstClass,
+// InstanceGet, InstanceOf, InstancePut, Monitor, MoveException, NewArrayEmpty, NewInstance,
+// StaticGet, StaticPut, etc.
+public class InliningConstraintVisitor extends MethodVisitor {
+
+ private final JarApplicationReader application;
+ private final AppInfoWithLiveness appInfo;
+ private final InliningConstraints inliningConstraints;
+ private final DexMethod method;
+ private final DexType invocationContext;
+
+ private Constraint constraint = Constraint.ALWAYS;
+
+ public InliningConstraintVisitor(
+ JarApplicationReader application,
+ AppInfoWithLiveness appInfo,
+ GraphLense graphLense,
+ DexMethod method,
+ DexType invocationContext) {
+ super(ASM6);
+ this.application = application;
+ this.appInfo = appInfo;
+ this.inliningConstraints = new InliningConstraints(appInfo, graphLense);
+ this.method = method;
+ this.invocationContext = invocationContext;
+ }
+
+ public Constraint getConstraint() {
+ return constraint;
+ }
+
+ private void updateConstraint(Constraint other) {
+ constraint = Constraint.min(constraint, other);
+ }
+
+ // Used to signal that the result is ready, such that we do not need to visit all instructions of
+ // the method, if we can see early on that it cannot be inlined anyway.
+ public boolean isFinished() {
+ return constraint == Constraint.NEVER;
+ }
+
+ @Override
+ public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+ DexType ownerType = application.getTypeFromName(owner);
+ DexMethod target = application.getMethod(ownerType, name, desc);
+ switch (opcode) {
+ case Opcodes.INVOKEINTERFACE:
+ updateConstraint(inliningConstraints.forInvokeInterface(target, invocationContext));
+ break;
+
+ case Opcodes.INVOKESPECIAL:
+ if (name.equals(Constants.INSTANCE_INITIALIZER_NAME) || ownerType == invocationContext) {
+ updateConstraint(inliningConstraints.forInvokeDirect(target, invocationContext));
+ } else {
+ updateConstraint(inliningConstraints.forInvokeSuper(target, invocationContext));
+ }
+ break;
+
+ case Opcodes.INVOKESTATIC:
+ updateConstraint(inliningConstraints.forInvokeStatic(target, invocationContext));
+ break;
+
+ case Opcodes.INVOKEVIRTUAL:
+ // Instructions that target a private method in the same class are translated to
+ // invoke-direct.
+ if (target.holder == method.holder) {
+ DexClass clazz = appInfo.definitionFor(target.holder);
+ if (clazz != null && clazz.lookupDirectMethod(target) != null) {
+ updateConstraint(inliningConstraints.forInvokeDirect(target, invocationContext));
+ break;
+ }
+ }
+
+ updateConstraint(inliningConstraints.forInvokeVirtual(target, invocationContext));
+ break;
+
+ default:
+ throw new Unreachable("Unexpected opcode " + opcode);
+ }
+ }
+
+ @Override
+ public void visitTypeInsn(int opcode, String typeName) {
+ DexType type = application.getTypeFromName(typeName);
+ switch (opcode) {
+ case Opcodes.ANEWARRAY:
+ break;
+
+ case Opcodes.CHECKCAST:
+ updateConstraint(inliningConstraints.forCheckCast(type, invocationContext));
+ break;
+
+ case Opcodes.INSTANCEOF:
+ break;
+
+ case Opcodes.NEW:
+ break;
+
+ default:
+ throw new Unreachable("Unexpected opcode " + opcode);
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 531c731..0ed3c11 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -22,12 +22,14 @@
import com.android.tools.r8.graph.DexTypeList;
import com.android.tools.r8.graph.GraphLense;
import com.android.tools.r8.graph.GraphLense.Builder;
+import com.android.tools.r8.graph.JarCode;
import com.android.tools.r8.graph.KeyedDexItem;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.PresortedComparable;
import com.android.tools.r8.graph.UseRegistry;
import com.android.tools.r8.ir.code.Invoke.Type;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
import com.android.tools.r8.ir.synthetic.SynthesizedCode;
import com.android.tools.r8.logging.Log;
@@ -294,8 +296,7 @@
if (appInfo.isPinned(method.method)) {
return false;
}
- // TODO(christofferqa): We should always be able to force inline initializers.
- if (method.isInstanceInitializer() && disallowInlining(method)) {
+ if (method.isInstanceInitializer() && disallowInlining(method, singleSubtype)) {
// Cannot guarantee that markForceInline() will work.
if (Log.ENABLED) {
AbortReason.UNSAFE_INLINING.printLogMessageForClass(clazz);
@@ -1358,83 +1359,52 @@
}
}
- private static boolean disallowInlining(DexEncodedMethod method) {
+ private boolean disallowInlining(DexEncodedMethod method, DexType invocationContext) {
// TODO(christofferqa): Determine the situations where markForceInline() may fail, and ensure
// that we always return true here in these cases.
- MethodInlineDecision registry = new MethodInlineDecision();
- method.getCode().registerCodeReferences(registry);
- return registry.isInliningDisallowed();
+ if (method.getCode().isJarCode()) {
+ JarCode jarCode = method.getCode().asJarCode();
+ Constraint constraint =
+ jarCode.computeInliningConstraint(
+ appInfo,
+ new SingleTypeMapperGraphLense(method.method.holder, invocationContext),
+ invocationContext);
+ return constraint == Constraint.NEVER;
+ }
+ // TODO(christofferqa): For non-jar code we currently cannot guarantee that markForceInline()
+ // will succeed.
+ return true;
}
- private static class MethodInlineDecision extends UseRegistry {
- private boolean disallowInlining = false;
+ private static class SingleTypeMapperGraphLense extends GraphLense {
- public boolean isInliningDisallowed() {
- return disallowInlining;
- }
+ private final DexType source;
+ private final DexType target;
- private boolean allowInlining() {
- return true;
- }
-
- private boolean disallowInlining() {
- disallowInlining = true;
- return true;
+ public SingleTypeMapperGraphLense(DexType source, DexType target) {
+ this.source = source;
+ this.target = target;
}
@Override
- public boolean registerInvokeInterface(DexMethod method) {
- return disallowInlining();
+ public DexType lookupType(DexType type) {
+ return type == source ? target : type;
}
@Override
- public boolean registerInvokeVirtual(DexMethod method) {
- return disallowInlining();
+ public GraphLenseLookupResult lookupMethod(
+ DexMethod method, DexEncodedMethod context, Type type) {
+ throw new Unreachable();
}
@Override
- public boolean registerInvokeDirect(DexMethod method) {
- return allowInlining();
+ public DexField lookupField(DexField field) {
+ throw new Unreachable();
}
@Override
- public boolean registerInvokeStatic(DexMethod method) {
- return allowInlining();
- }
-
- @Override
- public boolean registerInvokeSuper(DexMethod method) {
- return allowInlining();
- }
-
- @Override
- public boolean registerInstanceFieldWrite(DexField field) {
- return allowInlining();
- }
-
- @Override
- public boolean registerInstanceFieldRead(DexField field) {
- return allowInlining();
- }
-
- @Override
- public boolean registerNewInstance(DexType type) {
- return allowInlining();
- }
-
- @Override
- public boolean registerStaticFieldRead(DexField field) {
- return allowInlining();
- }
-
- @Override
- public boolean registerStaticFieldWrite(DexField field) {
- return allowInlining();
- }
-
- @Override
- public boolean registerTypeReference(DexType type) {
- return allowInlining();
+ public boolean isContextFreeForMethods() {
+ throw new Unreachable();
}
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
index c2df29a..55f0919 100644
--- a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
@@ -43,6 +43,7 @@
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Predicate;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -335,6 +336,7 @@
// }
@Test
@IgnoreForRangeOfVmVersions(from = Version.V5_1_1, to = Version.V6_0_1)
+ @Ignore // TODO(christofferqa): Need to use jasmin for the classes that are merge candidates.
public void testSuperCallToMergedClassIsRewritten() throws Exception {
String main = "classmerging.SuperCallToMergedClassIsRewrittenTest";
Set<String> preservedClassNames =
