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");
+    }
+  }
+}