Merge "Add Vungle to run_on_as_app"
diff --git a/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java b/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
index 8c79ea1..c5cb84e 100644
--- a/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
+++ b/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
@@ -26,6 +26,7 @@
import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.List;
+import java.util.ListIterator;
import java.util.Map;
public class LoadStoreHelper {
@@ -35,7 +36,7 @@
private final AppInfo appInfo;
private Map<Value, ConstInstruction> clonableConstants = null;
- private BasicBlock block = null;
+ private ListIterator<BasicBlock> blockIterator = null;
public LoadStoreHelper(IRCode code, TypeVerificationHelper typesHelper, AppInfo appInfo) {
this.code = code;
@@ -96,16 +97,16 @@
public void insertLoadsAndStores() {
clonableConstants = new IdentityHashMap<>();
- for (BasicBlock block : code.blocks) {
- this.block = block;
- InstructionListIterator it = block.listIterator();
+ blockIterator = code.blocks.listIterator();
+ while (blockIterator.hasNext()) {
+ InstructionListIterator it = blockIterator.next().listIterator();
while (it.hasNext()) {
it.next().insertLoadAndStores(it, this);
}
clonableConstants.clear();
}
clonableConstants = null;
- block = null;
+ blockIterator = null;
}
public void insertPhiMoves(CfRegisterAllocator allocator) {
@@ -170,8 +171,7 @@
assert !(instruction.outValue() instanceof StackValue);
if (instruction.isConstInstruction()) {
ConstInstruction constInstruction = instruction.asConstInstruction();
- assert block != null;
- if (canRemoveConstInstruction(constInstruction, block)) {
+ if (canRemoveConstInstruction(constInstruction, instruction.getBlock())) {
assert !constInstruction.isDexItemBasedConstString()
|| constInstruction.outValue().numberOfUsers() == 1;
clonableConstants.put(instruction.outValue(), constInstruction);
@@ -180,7 +180,8 @@
return;
}
assert instruction.outValue().isUsed(); // Should have removed it above.
- } else if (!instruction.outValue().isUsed()) {
+ }
+ if (!instruction.outValue().isUsed()) {
popOutValue(instruction.outValue(), instruction, it);
return;
}
@@ -189,19 +190,40 @@
Store store = new Store(oldOutValue, newOutValue);
// Move the debugging-locals liveness pertaining to the instruction to the store.
instruction.moveDebugValues(store);
- add(store, instruction, it);
- }
-
- public void popOutValue(Value value, Instruction instruction, InstructionListIterator it) {
- StackValue newOutValue = createStackValue(value, 0);
- instruction.swapOutValue(newOutValue);
- add(new Pop(newOutValue), instruction, it);
+ BasicBlock storeBlock = instruction.getBlock();
+ // If the block has catch-handlers we are not allowed to modify the locals of the block. If the
+ // instruction is throwing, the action should be moved to a new block - otherwise, the store
+ // should be inserted and the remaining instructions should be moved along with the handlers to
+ // the new block.
+ boolean hasCatchHandlers = instruction.getBlock().hasCatchHandlers();
+ if (hasCatchHandlers && instruction.instructionTypeCanThrow()) {
+ storeBlock = it.split(this.code, this.blockIterator);
+ it = storeBlock.listIterator();
+ }
+ add(store, storeBlock, instruction.getPosition(), it);
+ if (hasCatchHandlers && !instruction.instructionTypeCanThrow()) {
+ it.split(this.code, this.blockIterator);
+ this.blockIterator.previous();
+ }
}
public void popOutType(DexType type, Instruction instruction, InstructionListIterator it) {
- StackValue newOutValue = createStackValue(type, 0);
+ popOutValue(createStackValue(type, 0), instruction, it);
+ }
+
+ private void popOutValue(Value value, Instruction instruction, InstructionListIterator it) {
+ popOutValue(createStackValue(value, 0), instruction, it);
+ }
+
+ private void popOutValue(
+ StackValue newOutValue, Instruction instruction, InstructionListIterator it) {
+ BasicBlock insertBlock = instruction.getBlock();
+ if (insertBlock.hasCatchHandlers() && instruction.instructionTypeCanThrow()) {
+ insertBlock = it.split(this.code, this.blockIterator);
+ it = insertBlock.listIterator();
+ }
instruction.swapOutValue(newOutValue);
- add(new Pop(newOutValue), instruction, it);
+ add(new Pop(newOutValue), insertBlock, instruction.getPosition(), it);
}
private static class PhiMove {
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 72c6903..6b9257b 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -173,6 +173,8 @@
public final DexString enumDescriptor = createString("Ljava/lang/Enum;");
public final DexString annotationDescriptor = createString("Ljava/lang/annotation/Annotation;");
public final DexString throwableDescriptor = createString("Ljava/lang/Throwable;");
+ public final DexString exceptionInInitializerErrorDescriptor =
+ createString("Ljava/lang/ExceptionInInitializerError;");
public final DexString objectsDescriptor = createString("Ljava/util/Objects;");
public final DexString stringBuilderDescriptor = createString("Ljava/lang/StringBuilder;");
public final DexString stringBufferDescriptor = createString("Ljava/lang/StringBuffer;");
@@ -228,6 +230,8 @@
public final DexType enumType = createType(enumDescriptor);
public final DexType annotationType = createType(annotationDescriptor);
public final DexType throwableType = createType(throwableDescriptor);
+ public final DexType exceptionInInitializerErrorType =
+ createType(exceptionInInitializerErrorDescriptor);
public final DexType classType = createType(classDescriptor);
public final DexType autoCloseableType = createType(autoCloseableDescriptor);
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
new file mode 100644
index 0000000..a0fbb59
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
@@ -0,0 +1,232 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.CatchHandlers.CatchHandler;
+import com.android.tools.r8.ir.code.DominatorTree;
+import com.android.tools.r8.ir.code.DominatorTree.Assumption;
+import com.android.tools.r8.ir.code.DominatorTree.Inclusive;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
+import com.google.common.collect.Streams;
+import java.util.Iterator;
+
+/**
+ * Analysis that given an instruction determines if a given type is guaranteed to be class
+ * initialized prior the given instruction.
+ */
+public class ClassInitializationAnalysis {
+
+ public enum AnalysisAssumption {
+ INSTRUCTION_DOES_NOT_THROW,
+ NONE
+ }
+
+ public enum Query {
+ DIRECTLY,
+ DIRECTLY_OR_INDIRECTLY
+ }
+
+ private static final ClassInitializationAnalysis TRIVIAL =
+ new ClassInitializationAnalysis() {
+
+ @Override
+ public boolean isClassDefinitelyLoadedBeforeInstruction(
+ DexType type, Instruction instruction) {
+ return false;
+ }
+ };
+
+ private final AppView<? extends AppInfoWithLiveness> appView;
+ private final IRCode code;
+ private final DexItemFactory dexItemFactory;
+
+ private DominatorTree dominatorTree = null;
+ private int markingColor = -1;
+
+ private ClassInitializationAnalysis() {
+ this.appView = null;
+ this.code = null;
+ this.dexItemFactory = null;
+ }
+
+ public ClassInitializationAnalysis(AppView<? extends AppInfoWithLiveness> appView, IRCode code) {
+ assert appView != null;
+ assert code != null;
+ this.appView = appView;
+ this.code = code;
+ this.dexItemFactory = appView.dexItemFactory();
+ }
+
+ // Returns a trivial, conservative analysis that always returns false.
+ public static ClassInitializationAnalysis trivial() {
+ return TRIVIAL;
+ }
+
+ public boolean isClassDefinitelyLoadedBeforeInstruction(DexType type, Instruction instruction) {
+ BasicBlock block = instruction.getBlock();
+
+ // Visit the instructions in `block` prior to `instruction`.
+ for (Instruction previous : block.getInstructions()) {
+ if (previous == instruction) {
+ break;
+ }
+ if (previous.definitelyTriggersClassInitialization(
+ type,
+ appView,
+ Query.DIRECTLY_OR_INDIRECTLY,
+ // The given instruction is only reached if none of the instructions in the same
+ // basic block throws, so we can safely assume that they will not.
+ AnalysisAssumption.INSTRUCTION_DOES_NOT_THROW)) {
+ return true;
+ }
+ }
+
+ if (dominatorTree == null) {
+ dominatorTree = new DominatorTree(code, Assumption.MAY_HAVE_UNREACHABLE_BLOCKS);
+ }
+
+ // Visit all the instructions in all the blocks that dominate `block`.
+ for (BasicBlock dominator : dominatorTree.dominatorBlocks(block, Inclusive.NO)) {
+ AnalysisAssumption assumption = getAssumptionForDominator(dominator, block);
+ Iterator<Instruction> instructionIterator = dominator.iterator();
+ while (instructionIterator.hasNext()) {
+ Instruction previous = instructionIterator.next();
+ if (previous.definitelyTriggersClassInitialization(
+ type, appView, Query.DIRECTLY_OR_INDIRECTLY, assumption)) {
+ return true;
+ }
+ if (dominator.hasCatchHandlers() && previous.instructionTypeCanThrow()) {
+ // All of the instructions that follow the first instruction that may throw are
+ // guaranteed to be non-throwing. Hence they cannot cause any class initializations.
+ assert Streams.stream(instructionIterator)
+ .noneMatch(Instruction::instructionTypeCanThrow);
+ break;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns the analysis assumption to use when analyzing the instructions in the given dominator
+ * block.
+ *
+ * <p>If the given block has no catch handlers, then we can safely assume that the instruction
+ * does not throw, because execution would otherwise exit the method.
+ *
+ * <p>As a simple example, consider the method below. In order for the execution to get from the
+ * call to A.foo() to the call to A.bar() the call A.foo() must not throw.
+ *
+ * <pre>
+ * public static void method() {
+ * A.foo();
+ * A.bar();
+ * }
+ * </pre>
+ *
+ * This assumption cannot be made in the presence of intraprocedural exceptional control flow.
+ * Consider the following example.
+ *
+ * <pre>
+ * public static void method(A instance) {
+ * try {
+ * instance.field = 42;
+ * } catch (Exception e) {
+ * A.foo();
+ * return;
+ * }
+ * A.bar();
+ * }
+ * </pre>
+ *
+ * <p>At the call to A.foo() it is not guaranteed that the class A has been initialized, since
+ * `instance` could always be null.
+ *
+ * <p>At the call to A.bar() it is guaranteed, since the instance field assignment succeeded.
+ */
+ private AnalysisAssumption getAssumptionForDominator(BasicBlock dominator, BasicBlock block) {
+ if (!dominator.hasCatchHandlers()) {
+ return AnalysisAssumption.INSTRUCTION_DOES_NOT_THROW;
+ }
+
+ Instruction exceptionalExit = dominator.exceptionalExit();
+ if (exceptionalExit == null) {
+ // The block cannot throw after all.
+ return AnalysisAssumption.INSTRUCTION_DOES_NOT_THROW;
+ }
+
+ if (markingColor < 0) {
+ markingColor = code.reserveMarkingColor();
+ code.markTransitivePredecessors(block, markingColor);
+ }
+
+ for (CatchHandler<BasicBlock> catchHandler : dominator.getCatchHandlers()) {
+ if (!catchHandler.target.isMarked(markingColor)) {
+ // There is no path from this catch handler to the instruction of interest, so we can
+ // ignore it.
+ continue;
+ }
+
+ DexType guard = catchHandler.guard;
+ if (guard == DexItemFactory.catchAllType) {
+ return AnalysisAssumption.NONE;
+ }
+
+ if (exceptionalExit.isInstanceGet()
+ || exceptionalExit.isInstancePut()
+ || exceptionalExit.isInvokeMethodWithReceiver()) {
+ // If an instance-get, instance-put, or instance-invoke instruction does not fail with a
+ // NullPointerException, then the receiver class must have been initialized.
+ if (!dexItemFactory.npeType.isSubtypeOf(guard, appView.appInfo())) {
+ continue;
+ }
+ }
+ if (exceptionalExit.isStaticGet()
+ || exceptionalExit.isStaticPut()
+ || exceptionalExit.isInvokeStatic()) {
+ // If a static-get, static-put, or invoke-static does not fail with an ExceptionIn-
+ // InitializerError, then the holder class must have been initialized.
+ if (!dexItemFactory.exceptionInInitializerErrorType.isSubtypeOf(guard, appView.appInfo())) {
+ continue;
+ }
+ }
+
+ return AnalysisAssumption.NONE;
+ }
+
+ // There are no paths from any of the catch handlers to the instruction of interest, so we can
+ // assume that no instructions in the given block will throw (otherwise, the instruction of
+ // interest will not be reached).
+ return AnalysisAssumption.INSTRUCTION_DOES_NOT_THROW;
+ }
+
+ /**
+ * The analysis reuses the dominator tree and basic block markings. If the underlying structure of
+ * the IR changes, then this method must be called to reset the dominator tree, return the current
+ * marking color, and clear all marks.
+ */
+ public void notifyCodeHasChanged() {
+ dominatorTree = null;
+ returnMarkingColor();
+ }
+
+ /** Returns the marking color, if any, and clears all marks. */
+ public void finish() {
+ returnMarkingColor();
+ }
+
+ private void returnMarkingColor() {
+ if (markingColor >= 0) {
+ code.returnMarkingColor(markingColor);
+ markingColor = -1;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java b/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
index 3f6a2ef..34926fa 100644
--- a/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
+++ b/src/main/java/com/android/tools/r8/ir/code/CatchHandlers.java
@@ -5,14 +5,16 @@
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.CatchHandlers.CatchHandler;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
-public class CatchHandlers<T> {
+public class CatchHandlers<T> implements Iterable<CatchHandler<T>> {
public static class CatchHandler<T> {
@@ -94,6 +96,27 @@
}
@Override
+ public Iterator<CatchHandler<T>> iterator() {
+ return new Iterator<CatchHandler<T>>() {
+
+ private int nextIndex = 0;
+
+ @Override
+ public boolean hasNext() {
+ return nextIndex < size();
+ }
+
+ @Override
+ public CatchHandler<T> next() {
+ DexType guard = guards.get(nextIndex);
+ T target = targets.get(nextIndex);
+ ++nextIndex;
+ return new CatchHandler<>(guard, target);
+ }
+ };
+ }
+
+ @Override
public boolean equals(Object o) {
if (this == o) {
return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/DominatorTree.java b/src/main/java/com/android/tools/r8/ir/code/DominatorTree.java
index b8192be..960ea92 100644
--- a/src/main/java/com/android/tools/r8/ir/code/DominatorTree.java
+++ b/src/main/java/com/android/tools/r8/ir/code/DominatorTree.java
@@ -20,6 +20,11 @@
MAY_HAVE_UNREACHABLE_BLOCKS
}
+ public enum Inclusive {
+ YES,
+ NO
+ }
+
private final BasicBlock[] sorted;
private BasicBlock[] doms;
private final BasicBlock normalExitBlock = new BasicBlock();
@@ -165,30 +170,42 @@
* iteration starts by returning <code>dominated</code>.
*/
public Iterable<BasicBlock> dominatorBlocks(BasicBlock dominated) {
+ return dominatorBlocks(dominated, Inclusive.YES);
+ }
+
+ public Iterable<BasicBlock> dominatorBlocks(BasicBlock dominated, Inclusive inclusive) {
assert !obsolete;
- return () -> new Iterator<BasicBlock>() {
- private BasicBlock current = dominated;
+ return () -> {
+ Iterator<BasicBlock> iterator =
+ new Iterator<BasicBlock>() {
+ private BasicBlock current = dominated;
- @Override
- public boolean hasNext() {
- return current != null;
- }
+ @Override
+ public boolean hasNext() {
+ return current != null;
+ }
- @Override
- public BasicBlock next() {
- if (!hasNext()) {
- return null;
- } else {
- BasicBlock result = current;
- if (current.getNumber() == 0) {
- current = null;
- } else {
- current = immediateDominator(current);
- assert current != result;
- }
- return result;
- }
+ @Override
+ public BasicBlock next() {
+ if (!hasNext()) {
+ return null;
+ } else {
+ BasicBlock result = current;
+ if (current.getNumber() == 0) {
+ current = null;
+ } else {
+ current = immediateDominator(current);
+ assert current != result;
+ }
+ return result;
+ }
+ }
+ };
+ if (inclusive == Inclusive.NO) {
+ BasicBlock block = iterator.next();
+ assert block == dominated;
}
+ return iterator;
};
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index a5070ca..870ae6f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -387,11 +387,9 @@
}
}
- private boolean verifyNoBlocksMarked(int color) {
+ public boolean verifyNoBlocksMarked(int color) {
for (BasicBlock block : blocks) {
- if (block.isMarked(color)) {
- return false;
- }
+ assert !block.isMarked(color);
}
return true;
}
@@ -667,15 +665,8 @@
}
// After the throwing instruction only debug instructions and the final jump
// instruction is allowed.
- // TODO(mkroghj) Temporarily allow stack-operations to be after throwing instructions.
if (seenThrowing) {
- assert instruction.isDebugInstruction()
- || instruction.isJumpInstruction()
- || instruction.isStore()
- || instruction.isPop()
- || instruction.isDup()
- || instruction.isDup2()
- || instruction.isSwap();
+ assert instruction.isDebugInstruction() || instruction.isGoto();
}
}
}
@@ -919,7 +910,7 @@
public Set<BasicBlock> getUnreachableBlocks() {
Set<BasicBlock> unreachableBlocks = Sets.newIdentityHashSet();
int color = reserveMarkingColor();
- markReachableBlocks(color);
+ markTransitiveSuccessors(blocks.getFirst(), color);
for (BasicBlock block : blocks) {
if (!block.isMarked(color)) {
unreachableBlocks.add(block);
@@ -932,7 +923,7 @@
public Set<Value> removeUnreachableBlocks() {
ImmutableSet.Builder<Value> affectedValueBuilder = ImmutableSet.builder();
int color = reserveMarkingColor();
- markReachableBlocks(color);
+ markTransitiveSuccessors(blocks.getFirst(), color);
ListIterator<BasicBlock> blockIterator = listIterator();
while (blockIterator.hasNext()) {
BasicBlock current = blockIterator.next();
@@ -946,10 +937,10 @@
}
// Note: It is the responsibility of the caller to return the marking color.
- private void markReachableBlocks(int color) {
+ private void markTransitiveSuccessors(BasicBlock subject, int color) {
assert isMarkingColorInUse(color) && !anyBlocksMarkedWithColor(color);
Queue<BasicBlock> worklist = new ArrayDeque<>();
- worklist.add(blocks.getFirst());
+ worklist.add(subject);
while (!worklist.isEmpty()) {
BasicBlock block = worklist.poll();
if (block.isMarked(color)) {
@@ -963,4 +954,27 @@
}
}
}
+
+ /**
+ * Marks the transitive predecessors of the given block, including the block itself.
+ *
+ * <p>Note: It is the responsibility of the caller to return the marking color.
+ */
+ public void markTransitivePredecessors(BasicBlock subject, int color) {
+ assert isMarkingColorInUse(color) && !anyBlocksMarkedWithColor(color);
+ Queue<BasicBlock> worklist = new ArrayDeque<>();
+ worklist.add(subject);
+ while (!worklist.isEmpty()) {
+ BasicBlock block = worklist.poll();
+ if (block.isMarked(color)) {
+ continue;
+ }
+ block.mark(color);
+ for (BasicBlock predecessor : block.getPredecessors()) {
+ if (!predecessor.isMarked(color)) {
+ worklist.add(predecessor);
+ }
+ }
+ }
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java b/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
index d292aca..acc122b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
@@ -17,9 +17,13 @@
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.conversion.CfBuilder;
@@ -158,4 +162,24 @@
public boolean throwsNpeIfValueIsNull(Value value, DexItemFactory dexItemFactory) {
return object() == value;
}
+
+ @Override
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ if (object().getTypeLattice().isNullable()) {
+ // If the receiver is null we cannot be sure that the holder has been initialized.
+ return false;
+ }
+ }
+ DexType holder = getField().clazz;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
index 2d70317..48bc0c0 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
@@ -15,9 +15,13 @@
import com.android.tools.r8.code.IputWide;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -141,4 +145,24 @@
public boolean throwsNpeIfValueIsNull(Value value, DexItemFactory dexItemFactory) {
return object() == value;
}
+
+ @Override
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ if (object().getTypeLattice().isNullable()) {
+ // If the receiver is null we cannot be sure that the holder has been initialized.
+ return false;
+ }
+ }
+ DexType holder = getField().clazz;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
+ }
}
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 6d21c5a..d8500e6 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
@@ -8,10 +8,14 @@
import com.android.tools.r8.errors.Unimplemented;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.constant.Bottom;
import com.android.tools.r8.ir.analysis.constant.ConstRangeLatticeElement;
import com.android.tools.r8.ir.analysis.constant.LatticeElement;
@@ -1250,11 +1254,14 @@
* Indicates whether the instruction triggers the class initialization (i.e. the <clinit> method)
* of the given class at runtime execution.
*
- * @param klass a class of the program
* @return true if the instruction triggers intialization of the class at runtime, false
- * otherwise.
+ * otherwise.
*/
- public boolean triggersInitializationOfClass(DexType klass) {
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
index 10a80e2..ca1180f 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
@@ -7,9 +7,12 @@
import com.android.tools.r8.code.InvokeDirectRange;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
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.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -120,4 +123,24 @@
public void buildCf(CfBuilder builder) {
builder.add(new CfInvoke(Opcodes.INVOKESPECIAL, getInvokedMethod(), itf));
}
+
+ @Override
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ if (getReceiver().getTypeLattice().isNullable()) {
+ // If the receiver is null we cannot be sure that the holder has been initialized.
+ return false;
+ }
+ }
+ DexType holder = getInvokedMethod().holder;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
+ }
}
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 060f1d8..d203184 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
@@ -9,6 +9,7 @@
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.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
import com.android.tools.r8.ir.optimize.InliningOracle;
import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
@@ -61,7 +62,10 @@
public abstract Collection<DexEncodedMethod> lookupTargets(
AppInfoWithSubtyping appInfo, DexType invocationContext);
- public abstract InlineAction computeInlining(InliningOracle decider, DexType invocationContext);
+ public abstract InlineAction computeInlining(
+ InliningOracle decider,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis);
@Override
public void insertLoadAndStores(InstructionListIterator it, LoadStoreHelper helper) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
index 44ec246..f994058 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
@@ -8,6 +8,7 @@
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.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
import com.android.tools.r8.ir.optimize.InliningOracle;
@@ -34,7 +35,10 @@
}
@Override
- public final InlineAction computeInlining(InliningOracle decider, DexType invocationContext) {
+ public final InlineAction computeInlining(
+ InliningOracle decider,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis) {
return decider.computeForInvokeWithReceiver(this, 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 fa760ff..4b9ff7d 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
@@ -11,6 +11,7 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProto;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -126,7 +127,10 @@
}
@Override
- public InlineAction computeInlining(InliningOracle decider, DexType invocationContext) {
+ public InlineAction computeInlining(
+ InliningOracle decider,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis) {
return decider.computeForInvokePolymorphic(this, invocationContext);
}
}
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 d5f86fa..e203cc6 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
@@ -6,9 +6,13 @@
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.InvokeStaticRange;
import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
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.ir.analysis.ClassInitializationAnalysis;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -105,8 +109,11 @@
}
@Override
- public InlineAction computeInlining(InliningOracle decider, DexType invocationContext) {
- return decider.computeForInvokeStatic(this, invocationContext);
+ public InlineAction computeInlining(
+ InliningOracle decider,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis) {
+ return decider.computeForInvokeStatic(this, invocationContext, classInitializationAnalysis);
}
@Override
@@ -115,7 +122,20 @@
}
@Override
- public boolean triggersInitializationOfClass(DexType klass) {
- return getInvokedMethod().holder == klass;
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ // Class initialization may fail with ExceptionInInitializerError.
+ return false;
+ }
+ DexType holder = getInvokedMethod().holder;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
}
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 cbb645f..b02ca94 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
@@ -5,10 +5,15 @@
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.InvokeSuperRange;
+import com.android.tools.r8.graph.AppInfo.ResolutionResult;
import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
+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.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -107,4 +112,39 @@
InliningConstraints inliningConstraints, DexType invocationContext) {
return inliningConstraints.forInvokeSuper(getInvokedMethod(), invocationContext);
}
+
+ @Override
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ if (getReceiver().getTypeLattice().isNullable()) {
+ // If the receiver is null we cannot be sure that the holder has been initialized.
+ return false;
+ }
+ }
+ if (mode == Query.DIRECTLY) {
+ // We cannot ensure exactly which class is being loaded because it depends on the runtime
+ // type of the receiver.
+ // TODO(christofferqa): We can do better if there is a unique target.
+ return false;
+ }
+ DexMethod method = getInvokedMethod();
+ DexClass enclosingClass = appView.appInfo().definitionFor(method.holder);
+ if (enclosingClass == null) {
+ return false;
+ }
+ DexType superType = enclosingClass.superType;
+ if (superType == null) {
+ return false;
+ }
+ ResolutionResult resolutionResult = appView.appInfo().resolveMethod(superType, method);
+ if (!resolutionResult.hasSingleTarget()) {
+ return false;
+ }
+ DexType holder = resolutionResult.asSingleTarget().method.holder;
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
index 7ef8979..4c2327f 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
@@ -5,10 +5,14 @@
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.InvokeVirtualRange;
+import com.android.tools.r8.graph.AppInfo.ResolutionResult;
import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
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.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
@@ -98,4 +102,31 @@
public void buildCf(CfBuilder builder) {
builder.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, getInvokedMethod(), false));
}
+
+ @Override
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ if (getReceiver().getTypeLattice().isNullable()) {
+ // If the receiver is null we cannot be sure that the holder has been initialized.
+ return false;
+ }
+ }
+ if (mode == Query.DIRECTLY) {
+ // We cannot ensure exactly which class is being loaded because it depends on the runtime
+ // type of the receiver.
+ // TODO(christofferqa): We can do better if there is a unique target.
+ return false;
+ }
+ DexMethod method = getInvokedMethod();
+ ResolutionResult resolutionResult = appView.appInfo().resolveMethod(method.holder, method);
+ if (!resolutionResult.hasSingleTarget()) {
+ return false;
+ }
+ DexType holder = resolutionResult.asSingleTarget().method.holder;
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
index fca7b7e..93b1042 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
@@ -8,7 +8,11 @@
import com.android.tools.r8.cf.code.CfNew;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.conversion.CfBuilder;
@@ -107,8 +111,17 @@
}
@Override
- public boolean triggersInitializationOfClass(DexType klass) {
- return clazz == klass;
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ DexType holder = this.clazz;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
public void markNoSpilling() {
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
index af9c5c6..db3838c 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
@@ -16,8 +16,12 @@
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.analysis.type.Nullability;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.conversion.CfBuilder;
@@ -147,7 +151,20 @@
}
@Override
- public boolean triggersInitializationOfClass(DexType klass) {
- return getField().clazz == klass;
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ // Class initialization may fail with ExceptionInInitializerError.
+ return false;
+ }
+ DexType holder = getField().clazz;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
index ba33cbf..4f63a1b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticPut.java
@@ -14,8 +14,12 @@
import com.android.tools.r8.code.SputWide;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
import com.android.tools.r8.ir.conversion.CfBuilder;
import com.android.tools.r8.ir.conversion.DexBuilder;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
@@ -130,7 +134,20 @@
}
@Override
- public boolean triggersInitializationOfClass(DexType klass) {
- return getField().clazz == klass;
+ public boolean definitelyTriggersClassInitialization(
+ DexType clazz,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ Query mode,
+ AnalysisAssumption assumption) {
+ if (assumption == AnalysisAssumption.NONE) {
+ // Class initialization may fail with ExceptionInInitializerError.
+ return false;
+ }
+ DexType holder = getField().clazz;
+ if (mode == Query.DIRECTLY) {
+ return holder == clazz;
+ } else {
+ return holder.isSubtypeOf(clazz, appView.appInfo());
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Store.java b/src/main/java/com/android/tools/r8/ir/code/Store.java
index 21cb146..202bac6 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Store.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Store.java
@@ -75,7 +75,7 @@
@Override
public void insertLoadAndStores(InstructionListIterator it, LoadStoreHelper helper) {
- // Nothing to do. This is only hit because loads and stores are insert for phis.
+ throw new Unreachable("This IR must not be inserted before load and store insertion.");
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index 6b5f6c4..8a46e1e 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -149,9 +149,6 @@
computeInitializers();
typeVerificationHelper = new TypeVerificationHelper(code, factory, appInfo);
typeVerificationHelper.computeVerificationTypes();
- if (!options.testing.noSplittingExceptionalEdges) {
- splitExceptionalBlocks();
- }
rewriter.converter.deadCodeRemover.run(code);
rewriteNots();
LoadStoreHelper loadStoreHelper = new LoadStoreHelper(code, typeVerificationHelper, appInfo);
@@ -223,38 +220,6 @@
return initializers;
}
- // Split all blocks with throwing instructions and exceptional edges such that any non-throwing
- // instructions that might define values prior to the throwing exception are excluded from the
- // try-catch range. Failure to do so will result in code that does not verify on the JVM.
- private void splitExceptionalBlocks() {
- ListIterator<BasicBlock> it = code.listIterator();
- while (it.hasNext()) {
- BasicBlock block = it.next();
- if (!block.hasCatchHandlers()) {
- continue;
- }
- int size = block.getInstructions().size();
- boolean isThrow = block.exit().isThrow();
- if ((isThrow && size == 1) || (!isThrow && size == 2)) {
- // Fast-path to avoid processing blocks with just a single throwing instruction.
- continue;
- }
- InstructionListIterator instructions = block.listIterator();
- boolean hasOutValues = false;
- while (instructions.hasNext()) {
- Instruction instruction = instructions.next();
- if (instruction.instructionTypeCanThrow()) {
- break;
- }
- hasOutValues |= instruction.outValue() != null;
- }
- if (hasOutValues) {
- instructions.previous();
- instructions.split(code, it);
- }
- }
- }
-
private void rewriteNots() {
for (BasicBlock block : code.blocks) {
InstructionListIterator it = block.listIterator();
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 5bf9154..0b5e17e 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
@@ -1125,12 +1125,14 @@
codeRewriter.identifyReturnsArgument(method, code, feedback);
if (options.enableInlining && inliner != null) {
- codeRewriter.identifyInvokeSemanticsForInlining(method, code, graphLense(), feedback);
+ codeRewriter.identifyInvokeSemanticsForInlining(method, code, appView, feedback);
}
// Track usage of parameters and compute their nullability and possibility of NPE.
- if (method.getOptimizationInfo().getNonNullParamOrThrow() == null) {
- computeNonNullParamHints(feedback, method, code);
+ if (enableWholeProgramOptimizations) {
+ if (method.getOptimizationInfo().getNonNullParamOrThrow() == null) {
+ computeNonNullParamHints(feedback, method, code);
+ }
}
// Insert code to log arguments if requested.
@@ -1189,8 +1191,7 @@
// invoke-static throwParameterIsNullException(msg)
//
// or some other variants, e.g., throw null or NPE after the direct null check.
- if (argument.isUsed()
- && checksNullBeforeSideEffect(code, appInfo, graphLense(), argument)) {
+ if (argument.isUsed() && checksNullBeforeSideEffect(code, argument, appView)) {
paramsCheckedForNull.set(index);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 0af7c9e..359223d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize;
+import static com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query.DIRECTLY;
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.optimize.ReflectionOptimizer.ClassNameComputationInfo.ClassNameComputationOption.CANONICAL_NAME;
@@ -15,6 +16,7 @@
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexClass;
@@ -42,10 +44,10 @@
import com.android.tools.r8.graph.DexValue.DexValueNull;
import com.android.tools.r8.graph.DexValue.DexValueShort;
import com.android.tools.r8.graph.DexValue.DexValueString;
-import com.android.tools.r8.graph.GraphLense;
import com.android.tools.r8.graph.ParameterUsagesInfo;
import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsageBuilder;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
import com.android.tools.r8.ir.code.AlwaysMaterializingNop;
@@ -1024,17 +1026,19 @@
}
public void identifyInvokeSemanticsForInlining(
- DexEncodedMethod method, IRCode code, GraphLense graphLense, OptimizationFeedback feedback) {
+ DexEncodedMethod method,
+ IRCode code,
+ AppView<? extends AppInfoWithSubtyping> appView,
+ OptimizationFeedback feedback) {
if (method.isStatic()) {
// Identifies if the method preserves class initialization after inlining.
- feedback.markTriggerClassInitBeforeAnySideEffect(method,
- triggersClassInitializationBeforeSideEffect(code, method.method.getHolder()));
+ feedback.markTriggerClassInitBeforeAnySideEffect(
+ method, triggersClassInitializationBeforeSideEffect(method.method.holder, code, appView));
} else {
// Identifies if the method preserves null check of the receiver after inlining.
final Value receiver = code.getThis();
- feedback.markCheckNullReceiverBeforeAnySideEffect(method,
- receiver.isUsed()
- && checksNullBeforeSideEffect(code, appInfo, graphLense, receiver));
+ feedback.markCheckNullReceiverBeforeAnySideEffect(
+ method, receiver.isUsed() && checksNullBeforeSideEffect(code, receiver, appView));
}
}
@@ -1366,10 +1370,10 @@
* Returns true if the given code unconditionally throws if value is null before any other side
* effect instruction.
*
- * Note: we do not track phis so we may return false negative. This is a conservative approach.
+ * <p>Note: we do not track phis so we may return false negative. This is a conservative approach.
*/
public static boolean checksNullBeforeSideEffect(
- IRCode code, AppInfo appInfo, GraphLense graphLense, Value value) {
+ IRCode code, Value value, AppView<? extends AppInfoWithSubtyping> appView) {
return alwaysTriggerExpectedEffectBeforeAnythingElse(
code,
(instr, it) -> {
@@ -1379,13 +1383,13 @@
if (!currentBlock.hasCatchHandlers() && isNullCheck(instr, value)) {
return InstructionEffect.CONDITIONAL_EFFECT;
}
- if (isKotlinNullCheck(appInfo, graphLense, instr, value)) {
+ if (isKotlinNullCheck(instr, value, appView)) {
DexMethod invokedMethod = instr.asInvokeStatic().getInvokedMethod();
// Kotlin specific way of throwing NPE: throwParameterIsNullException.
// Similarly, combined with the above CONDITIONAL_EFFECT, the code checks on NPE on
// the value.
if (invokedMethod.name
- == appInfo.dexItemFactory.kotlin.intrinsics.throwParameterIsNullException.name) {
+ == appView.dexItemFactory().kotlin.intrinsics.throwParameterIsNullException.name) {
// We found a NPE (or similar exception) throwing code.
// Combined with the above CONDITIONAL_EFFECT, the code checks NPE on the value.
for (BasicBlock predecessor : currentBlock.getPredecessors()) {
@@ -1401,14 +1405,14 @@
} else {
// Kotlin specific way of checking parameter nullness: checkParameterIsNotNull.
assert invokedMethod.name
- == appInfo.dexItemFactory.kotlin.intrinsics.checkParameterIsNotNull.name;
+ == appView.dexItemFactory().kotlin.intrinsics.checkParameterIsNotNull.name;
return InstructionEffect.DESIRED_EFFECT;
}
}
- if (isInstantiationOfNullPointerException(instr, it, appInfo.dexItemFactory)) {
+ if (isInstantiationOfNullPointerException(instr, it, appView.dexItemFactory())) {
it.next(); // Skip call to NullPointerException.<init>.
return InstructionEffect.NO_EFFECT;
- } else if (instr.throwsNpeIfValueIsNull(value, appInfo.dexItemFactory)) {
+ } else if (instr.throwsNpeIfValueIsNull(value, appView.dexItemFactory())) {
// In order to preserve NPE semantic, the exception must not be caught by any handler.
// Therefore, we must ignore this instruction if it is covered by a catch handler.
// Note: this is a conservative approach where we consider that any catch handler could
@@ -1434,7 +1438,7 @@
// declare a method called checkParameterIsNotNull(parameter, message) or
// throwParameterIsNullException(parameterName) in a package that starts with "kotlin".
private static boolean isKotlinNullCheck(
- AppInfo appInfo, GraphLense graphLense, Instruction instr, Value value) {
+ Instruction instr, Value value, AppView<? extends AppInfoWithSubtyping> appView) {
if (!instr.isInvokeStatic()) {
return false;
}
@@ -1442,11 +1446,11 @@
// e.g., kotlin.collections.ArraysKt___ArraysKt... or kotlin.jvm.internal.ArrayIteratorKt...
MethodSignatureEquivalence wrapper = MethodSignatureEquivalence.get();
Wrapper<DexMethod> checkParameterIsNotNull =
- wrapper.wrap(appInfo.dexItemFactory.kotlin.intrinsics.checkParameterIsNotNull);
+ wrapper.wrap(appView.dexItemFactory().kotlin.intrinsics.checkParameterIsNotNull);
Wrapper<DexMethod> throwParamIsNullException =
- wrapper.wrap(appInfo.dexItemFactory.kotlin.intrinsics.throwParameterIsNullException);
+ wrapper.wrap(appView.dexItemFactory().kotlin.intrinsics.throwParameterIsNullException);
DexMethod invokedMethod =
- graphLense.getOriginalMethodSignature(instr.asInvokeStatic().getInvokedMethod());
+ appView.graphLense().getOriginalMethodSignature(instr.asInvokeStatic().getInvokedMethod());
Wrapper<DexMethod> methodWrap = wrapper.wrap(invokedMethod);
if (methodWrap.equals(throwParamIsNullException)
|| (methodWrap.equals(checkParameterIsNotNull) && instr.inValues().get(0).equals(value))) {
@@ -1492,13 +1496,15 @@
* Returns true if the given code unconditionally triggers class initialization before any other
* side effecting instruction.
*
- * Note: we do not track phis so we may return false negative. This is a conservative approach.
+ * <p>Note: we do not track phis so we may return false negative. This is a conservative approach.
*/
- private static boolean triggersClassInitializationBeforeSideEffect(IRCode code, DexType klass) {
+ private static boolean triggersClassInitializationBeforeSideEffect(
+ DexType clazz, IRCode code, AppView<? extends AppInfoWithSubtyping> appView) {
return alwaysTriggerExpectedEffectBeforeAnythingElse(
code,
(instruction, it) -> {
- if (instruction.triggersInitializationOfClass(klass)) {
+ if (instruction.definitelyTriggersClassInitialization(
+ clazz, appView, DIRECTLY, AnalysisAssumption.INSTRUCTION_DOES_NOT_THROW)) {
// In order to preserve class initialization semantic, the exception must not be caught
// by any handler. Therefore, we must ignore this instruction if it is covered by a
// catch handler.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 357e949..d7faa6d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.InvokeMethod;
@@ -115,14 +116,20 @@
return Reason.SIMPLE;
}
- private boolean canInlineStaticInvoke(DexEncodedMethod method, DexEncodedMethod target) {
+ private boolean canInlineStaticInvoke(
+ InvokeStatic invoke,
+ DexEncodedMethod method,
+ DexEncodedMethod target,
+ ClassInitializationAnalysis classInitializationAnalysis) {
// Only proceed with inlining a static invoke if:
- // - the holder for the target equals the holder for the method, or
+ // - the holder for the target is a subtype of the holder for the method,
// - the target method always triggers class initialization of its holder before any other side
- // effect (hence preserving class initialization semantics).
+ // effect (hence preserving class initialization semantics),
+ // - the current method has already triggered the holder for the target method to be
+ // initialized, or
// - there is no non-trivial class initializer.
- DexType targetHolder = target.method.getHolder();
- if (method.method.getHolder() == targetHolder) {
+ DexType targetHolder = target.method.holder;
+ if (method.method.holder.isSubtypeOf(targetHolder, appView.appInfo())) {
return true;
}
DexClass clazz = inliner.appView.appInfo().definitionFor(targetHolder);
@@ -130,6 +137,10 @@
if (target.getOptimizationInfo().triggersClassInitBeforeAnySideEffect()) {
return true;
}
+ if (classInitializationAnalysis.isClassDefinitelyLoadedBeforeInstruction(
+ target.method.holder, invoke)) {
+ return true;
+ }
// Check for class initializer side effects when loading this class, as inlining might remove
// the load operation.
//
@@ -316,7 +327,10 @@
}
@Override
- public InlineAction computeForInvokeStatic(InvokeStatic invoke, DexType invocationContext) {
+ public InlineAction computeForInvokeStatic(
+ InvokeStatic invoke,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis) {
DexEncodedMethod candidate = validateCandidate(invoke, invocationContext);
if (candidate == null || inliner.isBlackListed(candidate.method)) {
return null;
@@ -333,7 +347,7 @@
}
// Abort inlining attempt if we can not guarantee class for static target has been initialized.
- if (!canInlineStaticInvoke(method, candidate)) {
+ if (!canInlineStaticInvoke(invoke, method, candidate, classInitializationAnalysis)) {
if (info != null) {
info.exclude(invoke, "target is static but we cannot guarantee class has been initialized");
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
index 6890dd8..5ffa2cf 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
@@ -6,6 +6,7 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.InvokeMethod;
@@ -39,7 +40,10 @@
}
@Override
- public InlineAction computeForInvokeStatic(InvokeStatic invoke, DexType invocationContext) {
+ public InlineAction computeForInvokeStatic(
+ InvokeStatic invoke,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis) {
return computeForInvoke(invoke);
}
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 27ea742..953562f 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
@@ -13,6 +13,7 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -593,6 +594,8 @@
InliningStrategy strategy, InliningOracle oracle, DexEncodedMethod context, IRCode code) {
List<BasicBlock> blocksToRemove = new ArrayList<>();
ListIterator<BasicBlock> blockIterator = code.listIterator();
+ ClassInitializationAnalysis classInitializationAnalysis =
+ new ClassInitializationAnalysis(appView, code);
while (blockIterator.hasNext()) {
BasicBlock block = blockIterator.next();
if (blocksToRemove.contains(block)) {
@@ -603,7 +606,8 @@
Instruction current = iterator.next();
if (current.isInvokeMethod()) {
InvokeMethod invoke = current.asInvokeMethod();
- InlineAction result = invoke.computeInlining(oracle, context.method.holder);
+ InlineAction result =
+ invoke.computeInlining(oracle, context.method.holder, classInitializationAnalysis);
if (result != null) {
if (!(strategy.stillHasBudget() || result.reason.mustBeInlined())) {
continue;
@@ -641,6 +645,8 @@
strategy.markInlined(inlinee);
iterator.inlineInvoke(
appView.appInfo(), code, inlinee.code, blockIterator, blocksToRemove, downcast);
+
+ classInitializationAnalysis.notifyCodeHasChanged();
strategy.updateTypeInformationIfNeeded(inlinee.code, blockIterator, block);
// If we inlined the invoke from a bridge method, it is no longer a bridge method.
@@ -656,6 +662,7 @@
}
}
}
+ classInitializationAnalysis.finish();
oracle.finish();
code.removeBlocks(blocksToRemove);
code.removeAllTrivialPhis();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
index 08f8045..15a6329 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.optimize;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
import com.android.tools.r8.ir.code.InvokePolymorphic;
import com.android.tools.r8.ir.code.InvokeStatic;
@@ -21,7 +22,9 @@
InvokeMethodWithReceiver invoke, DexType invocationContext);
InlineAction computeForInvokeStatic(
- InvokeStatic invoke, DexType invocationContext);
+ InvokeStatic invoke,
+ DexType invocationContext,
+ ClassInitializationAnalysis classInitializationAnalysis);
InlineAction computeForInvokePolymorphic(
InvokePolymorphic invoke, DexType invocationContext);
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 cdf37c4..1f036b6 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
@@ -18,6 +18,7 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.OptimizationInfo;
import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
+import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.ConstNumber;
@@ -822,7 +823,9 @@
}
// Check if the method is inline-able by standard inliner.
- InlineAction inlineAction = invoke.computeInlining(defaultOracle.get(), method.method.holder);
+ InlineAction inlineAction =
+ invoke.computeInlining(
+ defaultOracle.get(), method.method.holder, ClassInitializationAnalysis.trivial());
if (inlineAction == null) {
return false;
}
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 3997982..7f4fbe1 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -539,7 +539,6 @@
public boolean forceNameReflectionOptimization = false;
public boolean disallowLoadStoreOptimization = false;
public Consumer<IRCode> irModifier = null;
- public boolean noSplittingExceptionalEdges = false;
}
private boolean hasMinApi(AndroidApiLevel level) {
diff --git a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
index e4c7098..926a22d 100644
--- a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
@@ -8,9 +8,19 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfLabel;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.List;
import java.util.ListIterator;
import org.junit.Test;
@@ -18,8 +28,7 @@
* This tests that we produce valid code when having normal-flow with exceptional edges in blocks.
* We might perform optimizations that add operations (dup, swap, etc.) before and after
* instructions that lie on the boundary of the exception table that is generated for a basic block.
- * If live-ranges are minimized this could produce VerifyErrors. TODO(b/119771771) Will fail if
- * shorten live ranges without shorten exception table range.
+ * If live-ranges are minimized this could produce VerifyErrors.
*/
public class TryRangeTestRunner extends TestBase {
@@ -37,27 +46,45 @@
o.testing.disallowLoadStoreOptimization = true;
})
.run(TryRangeTest.class)
- .assertSuccess();
+ .assertSuccessWithOutput(StringUtils.lines("10", "7.0"));
}
@Test
public void testRegisterAllocationLimitLeadingRange() throws Exception {
- testForR8(Backend.CF)
- .addProgramClasses(TryRangeTestLimitRange.class)
- .addKeepMainRule(TryRangeTestLimitRange.class)
- .setMode(CompilationMode.RELEASE)
- .minification(false)
- .noTreeShaking()
- .enableInliningAnnotations()
- .addOptionsModification(
- o -> {
- o.testing.disallowLoadStoreOptimization = true;
- o.testing.irModifier = this::processIR;
- // TODO(mkroghj) Remove this option entirely when splittingExceptionalEdges is moved.
- o.testing.noSplittingExceptionalEdges = true;
- })
- .run(TryRangeTestLimitRange.class)
- .assertFailure();
+ CodeInspector inspector =
+ testForR8(Backend.CF)
+ .addProgramClasses(TryRangeTestLimitRange.class)
+ .addKeepMainRule(TryRangeTestLimitRange.class)
+ .setMode(CompilationMode.RELEASE)
+ .minification(false)
+ .noTreeShaking()
+ .enableInliningAnnotations()
+ .addOptionsModification(
+ o -> {
+ o.testing.disallowLoadStoreOptimization = true;
+ o.testing.irModifier = this::processIR;
+ })
+ .run(TryRangeTestLimitRange.class)
+ .assertSuccessWithOutput("")
+ .inspector();
+ // Assert that we do not have any register-modifying instructions in the throwing block:
+ // L0: ; locals:
+ // iload 1;
+ // invokestatic com.android.tools.r8.cf.TryRangeTestLimitRange.doSomething(I)F
+ // L1: ; locals:
+ // 11: pop
+ ClassSubject clazz = inspector.clazz("com.android.tools.r8.cf.TryRangeTestLimitRange");
+ CfCode cfCode = clazz.uniqueMethodWithName("main").getMethod().getCode().asCfCode();
+ List<CfInstruction> instructions = cfCode.getInstructions();
+ CfLabel startLabel = cfCode.getTryCatchRanges().get(0).start;
+ int index = 0;
+ while (instructions.get(index) != startLabel) {
+ index++;
+ }
+ assert instructions.get(index + 1) instanceof CfLoad;
+ assert instructions.get(index + 2) instanceof CfInvoke;
+ assert instructions.get(index + 3) == cfCode.getTryCatchRanges().get(0).end;
+ assert instructions.get(index + 4) instanceof CfStackInstruction;
}
private void processIR(IRCode code) {
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
index da0bc9e..62c6bc8 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
@@ -17,8 +17,6 @@
private String proguardMap1 = null;
private String proguardMap2 = null;
- @Rule public final ExpectedException exception = ExpectedException.none();
-
@Test
public void buildAndTreeShakeFromDeployJar() throws Exception {
// TODO(tamaskenez): set hasReference = true when we have the noshrink file for V10
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
new file mode 100644
index 0000000..1144491
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningAfterClassInitializationTest.java
@@ -0,0 +1,373 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.inliner;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.KeepConstantArguments;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+
+public class InliningAfterClassInitializationTest extends TestBase {
+
+ @Test
+ public void testClass1() throws Exception {
+ Class<TestClass1> mainClass = TestClass1.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines("In A.<clinit>()", "In A.notInlineable()", "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ assertThat(notInlineableMethod, isPresent());
+
+ MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
+ assertThat(testMethod, isPresent());
+ assertThat(testMethod, invokesMethod(notInlineableMethod));
+ }
+
+ @Test
+ public void testClass2() throws Exception {
+ Class<TestClass2> mainClass = TestClass2.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines("In A.<clinit>()", "Field A.staticField", "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+ }
+
+ @Test
+ public void testClass3() throws Exception {
+ Class<TestClass3> mainClass = TestClass3.class;
+ CodeInspector inspector =
+ buildAndRun(mainClass, StringUtils.lines("In A.<clinit>()", "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+ }
+
+ @Test
+ public void testClass4() throws Exception {
+ Class<TestClass4> mainClass = TestClass4.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines("In A.<clinit>()", "Field A.instanceField", "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+ }
+
+ @Test
+ public void testClass5() throws Exception {
+ Class<TestClass5> mainClass = TestClass5.class;
+ CodeInspector inspector =
+ buildAndRun(mainClass, StringUtils.lines("In A.<clinit>()", "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+ }
+
+ @Test
+ public void testClass6() throws Exception {
+ Class<TestClass6> mainClass = TestClass6.class;
+ CodeInspector inspector =
+ buildAndRun(mainClass, StringUtils.lines("In A.<clinit>()", "In A.notInlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ assertThat(notInlineableMethod, isPresent());
+
+ MethodSubject testMethod = inspector.clazz(mainClass).uniqueMethodWithName("test");
+ assertThat(testMethod, isPresent());
+ assertThat(testMethod, invokesMethod(notInlineableMethod));
+ }
+
+ @Test
+ public void testClass7() throws Exception {
+ Class<TestClass7> mainClass = TestClass7.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines(
+ "Caught NullPointerException",
+ "In A.<clinit>()",
+ "Field A.instanceField",
+ "In A.inlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject inlineableMethod = classA.uniqueMethodWithName("inlineable");
+ assertThat(inlineableMethod, not(isPresent()));
+ }
+
+ @Test
+ public void testClass8() throws Exception {
+ Class<TestClass8> mainClass = TestClass8.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines(
+ "In A.<clinit>()", "In A.notInlineable()", "In A.alsoNotInlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ assertThat(notInlineableMethod, isPresent());
+
+ MethodSubject alsoNotInlineableMethod = classA.uniqueMethodWithName("alsoNotInlineable");
+ assertThat(alsoNotInlineableMethod, isPresent());
+
+ MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
+ assertThat(testMethod, isPresent());
+ assertThat(testMethod, invokesMethod(notInlineableMethod));
+ assertThat(testMethod, invokesMethod(alsoNotInlineableMethod));
+ }
+
+ @Test
+ public void testClass9() throws Exception {
+ Class<TestClass9> mainClass = TestClass9.class;
+ CodeInspector inspector =
+ buildAndRun(
+ mainClass,
+ StringUtils.lines("In A.<clinit>()", "Field A.staticField", "In A.notInlineable()"));
+
+ ClassSubject classA = inspector.clazz(A.class);
+ assertThat(classA, isPresent());
+
+ MethodSubject notInlineableMethod = classA.uniqueMethodWithName("notInlineable");
+ assertThat(notInlineableMethod, isPresent());
+
+ MethodSubject testMethod = inspector.clazz(mainClass).mainMethod();
+ assertThat(testMethod, isPresent());
+ assertThat(testMethod, invokesMethod(notInlineableMethod));
+ }
+
+ private CodeInspector buildAndRun(Class<?> mainClass, String expectedOutput) throws Exception {
+ testForJvm().addTestClasspath().run(mainClass).assertSuccessWithOutput(expectedOutput);
+
+ return testForR8(Backend.DEX)
+ .addInnerClasses(InliningAfterClassInitializationTest.class)
+ .addKeepMainRule(mainClass)
+ .enableConstantArgumentAnnotations()
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .run(mainClass)
+ .assertSuccessWithOutput(expectedOutput)
+ .inspector();
+ }
+
+ static class TestClass1 {
+
+ public static void main(String[] args) {
+ A.notInlineable();
+
+ // Since the previous call will cause the initializer of A to run, we can safely inline this
+ // call.
+ A.inlineable();
+ }
+ }
+
+ static class TestClass2 {
+
+ public static void main(String[] args) {
+ System.out.println(A.staticField);
+
+ // Since the previous instruction will cause the initializer of A to run, we can safely inline
+ // this call.
+ A.inlineable();
+ }
+ }
+
+ static class TestClass3 {
+
+ public static void main(String[] args) {
+ A.staticField = "Hello world!";
+
+ // Since the previous instruction will cause the initializer of A to run, we can safely inline
+ // this call.
+ A.inlineable();
+
+ // Make sure the field is read to prevent the static-put instruction from being removed
+ // (b/123553485).
+ spuriousFieldRead();
+ }
+
+ private static void spuriousFieldRead() {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(A.staticField);
+ }
+ }
+ }
+
+ static class TestClass4 {
+
+ public static void main(String[] args) {
+ test(new A());
+ }
+
+ @NeverInline
+ private static void test(A obj) {
+ System.out.println(obj.instanceField);
+
+ // Since the previous instruction will cause the initializer of A to run, we can safely inline
+ // this call.
+ A.inlineable();
+ }
+ }
+
+ static class TestClass5 {
+
+ public static void main(String[] args) {
+ test(new A());
+ }
+
+ @NeverInline
+ private static void test(A obj) {
+ obj.instanceField = "Hello world!";
+
+ // Since the previous instruction will cause the initializer of A to run, we can safely inline
+ // this call.
+ A.inlineable();
+
+ // Make sure the field is read to prevent the instance-put instruction from being removed.
+ spuriousFieldRead(obj);
+ }
+
+ private static void spuriousFieldRead(A obj) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(obj.instanceField);
+ }
+ }
+ }
+
+ static class TestClass6 {
+
+ public static void main(String[] args) {
+ test(null);
+ }
+
+ @KeepConstantArguments
+ @NeverInline
+ private static void test(A obj) {
+ try {
+ String value = obj.instanceField;
+ System.out.println(value);
+ } catch (NullPointerException e) {
+ // Ignore.
+ }
+
+ // This call cannot be inlined because `obj.field` may throw a NullPointerException, in which
+ // case A is not guaranteed to be initialized.
+ A.notInlineable();
+ }
+ }
+
+ static class TestClass7 {
+
+ public static void main(String[] args) {
+ test(null);
+ test(new A());
+ }
+
+ @NeverInline
+ private static void test(A obj) {
+ try {
+ String value = obj.instanceField;
+ System.out.println(value);
+ } catch (NullPointerException e) {
+ // Ignore.
+ System.out.println("Caught NullPointerException");
+ return;
+ }
+
+ // Due to the `return` in the catch handler above, A is guaranteed to be initialized if we
+ // reach this line.
+ A.inlineable();
+ }
+ }
+
+ static class TestClass8 {
+
+ public static void main(String[] args) {
+ try {
+ A.notInlineable();
+ } catch (ExceptionInInitializerError e) {
+ System.out.println("Caught ExceptionInInitializerError");
+ }
+
+ A.alsoNotInlineable();
+ }
+ }
+
+ static class TestClass9 {
+
+ public static void main(String[] args) {
+ try {
+ String value = A.staticField;
+ System.out.println(value);
+ } catch (ExceptionInInitializerError e) {
+ System.out.println("Caught ExceptionInInitializerError");
+ }
+
+ A.notInlineable();
+ }
+ }
+
+ static class A {
+
+ public String instanceField = "Field A.instanceField";
+ public static String staticField =
+ System.currentTimeMillis() >= 0 ? "Field A.staticField" : null;
+
+ static {
+ System.out.println("In A.<clinit>()");
+ }
+
+ static void notInlineable() {
+ System.out.println("In A.notInlineable()");
+ }
+
+ static void alsoNotInlineable() {
+ System.out.println("In A.alsoNotInlineable()");
+ }
+
+ static void inlineable() {
+ System.out.println("In A.inlineable()");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
index 71c5fbe..d581291 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningFromCurrentClassTest.java
@@ -16,12 +16,10 @@
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import org.junit.Ignore;
import org.junit.Test;
public class InliningFromCurrentClassTest extends TestBase {
- @Ignore("b/123327416")
@Test
public void test() throws Exception {
String expectedOutput =
@@ -65,8 +63,6 @@
MethodSubject testMethod = classB.uniqueMethodWithName("test");
assertThat(testMethod, isPresent());
- assertThat(testMethod, not(invokesMethod(inlineable1Method)));
- assertThat(testMethod, not(invokesMethod(inlineable2Method)));
assertThat(testMethod, invokesMethod(notInlineableMethod));
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
index 9691149..a264d15 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningWithClassInitializerTest.java
@@ -16,16 +16,13 @@
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import org.junit.Ignore;
import org.junit.Test;
public class InliningWithClassInitializerTest extends TestBase {
- @Ignore("b/123327413")
@Test
public void test() throws Exception {
- String expectedOutput =
- StringUtils.lines("In A.<clinit>()", "In B.inlineable()", "In B.other()");
+ String expectedOutput = StringUtils.lines("In A.<clinit>()", "In B.<clinit>()", "In B.other()");
testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expectedOutput);
@@ -74,8 +71,11 @@
static class B extends A {
+ static {
+ System.out.println("In B.<clinit>()");
+ }
+
static void inlineable() {
- System.out.println("In B.inlineable()");
other();
}
diff --git a/tools/as_utils.py b/tools/as_utils.py
index 10fb29f..5f224a6 100644
--- a/tools/as_utils.py
+++ b/tools/as_utils.py
@@ -126,6 +126,9 @@
for line in lines:
if '-printconfiguration' not in line:
f.write(line)
+ # Check that there is a line-break at the end of the file or insert one.
+ if lines[-1].strip():
+ f.write('\n')
f.write('-printconfiguration {}\n'.format(destination))
def FindProguardConfigurationFile(app, config, checkout_dir):
