Disable call site optimization for library method overrides.
Bug: 141900913, 142742950, 139246447
Change-Id: Icbcc6470af1ad7c0105f2f75a81f669429d7c8f3
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index 4826545..31add54 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -140,6 +140,11 @@
if (appView.appInfo().isPinned(target.method)) {
return;
}
+ // If the method overrides a library method, it is unsure how the method would be invoked by
+ // that library.
+ if (target.isLibraryMethodOverride().isTrue()) {
+ return;
+ }
// If the program already has illegal accesses, method resolution results will reflect that too.
// We should avoid recording arguments in that case. E.g., b/139823850: static methods can be a
// result of virtual call targets, if that's the only method that matches name and signature.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java
new file mode 100644
index 0000000..6e890de
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/nullability/LibraryMethodOverridesTest.java
@@ -0,0 +1,113 @@
+// 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.callsites.nullability;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.function.Predicate;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class LibraryMethodOverridesTest extends TestBase {
+ private static final Class<?> MAIN = TestClass.class;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withCfRuntimes()
+ // java.util.function.Predicate is not available prior to API level 24 (V7.0).
+ .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
+ .build();
+ }
+
+ private final TestParameters parameters;
+
+ public LibraryMethodOverridesTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ R8TestCompileResult libraryCompileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(LibClass.class)
+ .addKeepClassAndMembersRules(LibClass.class)
+ .setMinApi(parameters.getRuntime())
+ .compile();
+ testForR8(parameters.getBackend())
+ .addProgramClasses(TestClass.class, CustomPredicate.class)
+ .addClasspathClasses(LibClass.class)
+ .addKeepMainRule(MAIN)
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getRuntime())
+ .compile()
+ .addRunClasspathFiles(libraryCompileResult.writeToZip())
+ .run(parameters.getRuntime(), MAIN)
+ .assertSuccessWithOutputLines("Live", "Also live")
+ .inspect(this::inspect);
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject customPredicate = inspector.clazz(CustomPredicate.class);
+ assertThat(customPredicate, isPresent());
+
+ MethodSubject m = customPredicate.uniqueMethodWithName("test");
+ // Should not optimize branches since the method is overriding a library method.
+ assertTrue(m.streamInstructions().anyMatch(InstructionSubject::isIf));
+ }
+
+ static class TestClass {
+ public static void main(String[] args) {
+ CustomPredicate predicate = new CustomPredicate();
+ // calls CustomPredicate#test with non-null arg.
+ predicate.test(new Object());
+ // escapes to library
+ LibClass.spuriousAccess(predicate);
+ }
+ }
+
+ static class LibClass {
+ public static void spuriousAccess(Predicate<Object> p) {
+ // calls CustomPredicate#test with null arg.
+ p.test(null);
+ }
+ }
+
+ static class CustomPredicate implements Predicate<Object> {
+ @Override
+ public boolean test(Object o) {
+ if (o != null) {
+ live();
+ return true;
+ } else {
+ alsoLive();
+ return false;
+ }
+ }
+
+ @NeverInline
+ private void live() {
+ System.out.println("Live");
+ }
+
+ @NeverInline
+ private void alsoLive() {
+ System.out.println("Also live");
+ }
+ }
+}
