diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 20ca7f5..f244e33 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.5.49";
+  public static final String LABEL = "1.5.50";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index b62bcaa..928cb27 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -14,6 +14,7 @@
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
 import com.google.common.collect.Sets;
+import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -726,6 +727,14 @@
     return false;
   }
 
+  public boolean isResolvable(AppView<?> appView) {
+    if (!isProgramClass()
+        && !appView.dexItemFactory().libraryTypesAssumedToBePresent.contains(type)) {
+      return false;
+    }
+    return Streams.stream(allImmediateSupertypes()).allMatch(type -> type.isResolvable(appView));
+  }
+
   public boolean isSerializable(AppView<? extends AppInfoWithSubtyping> appView) {
     return appView.appInfo().isSerializable(type);
   }
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 38a926c..2a931f0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -194,6 +194,7 @@
   public final DexString proxyDescriptor = createString("Ljava/lang/reflect/Proxy;");
   public final DexString serviceLoaderDescriptor = createString("Ljava/util/ServiceLoader;");
   public final DexString listDescriptor = createString("Ljava/util/List;");
+  public final DexString callableDescriptor = createString("Ljava/util/concurrent/Callable;");
 
   public final DexString throwableDescriptor = createString(throwableDescriptorString);
   public final DexString illegalAccessErrorDescriptor =
@@ -201,6 +202,8 @@
   public final DexString icceDescriptor = createString("Ljava/lang/IncompatibleClassChangeError;");
   public final DexString exceptionInInitializerErrorDescriptor =
       createString("Ljava/lang/ExceptionInInitializerError;");
+  public final DexString noClassDefFoundErrorDescriptor =
+      createString("Ljava/lang/NoClassDefFoundError;");
   public final DexString noSuchFieldErrorDescriptor = createString("Ljava/lang/NoSuchFieldError;");
   public final DexString npeDescriptor = createString("Ljava/lang/NullPointerException;");
   public final DexString reflectiveOperationExceptionDescriptor =
@@ -266,12 +269,14 @@
   public final DexType proxyType = createType(proxyDescriptor);
   public final DexType serviceLoaderType = createType(serviceLoaderDescriptor);
   public final DexType listType = createType(listDescriptor);
+  public final DexType callableType = createType(callableDescriptor);
 
   public final DexType throwableType = createType(throwableDescriptor);
   public final DexType illegalAccessErrorType = createType(illegalAccessErrorDescriptor);
   public final DexType icceType = createType(icceDescriptor);
   public final DexType exceptionInInitializerErrorType =
       createType(exceptionInInitializerErrorDescriptor);
+  public final DexType noClassDefFoundErrorType = createType(noClassDefFoundErrorDescriptor);
   public final DexType noSuchFieldErrorType = createType(noSuchFieldErrorDescriptor);
   public final DexType npeType = createType(npeDescriptor);
   public final DexType reflectiveOperationExceptionType =
@@ -417,7 +422,7 @@
           .build();
 
   public Set<DexType> libraryTypesAssumedToBePresent =
-      ImmutableSet.of(objectType, stringBufferType, stringBuilderType);
+      ImmutableSet.of(objectType, callableType, stringBufferType, stringBuilderType);
 
   public final Set<DexType> libraryTypesWithoutStaticInitialization =
       ImmutableSet.of(
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 801d6f8..d42caf4 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -258,6 +258,11 @@
     return clazz != null && clazz.isProgramClass();
   }
 
+  public boolean isResolvable(AppView<?> appView) {
+    DexClass clazz = appView.definitionFor(this);
+    return clazz != null && clazz.isResolvable(appView);
+  }
+
   public int elementSizeForPrimitiveArrayType() {
     assert isPrimitiveArrayType();
     switch (descriptor.content[1]) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
index 3077daf..b122429 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.AbstractError;
 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;
@@ -82,29 +83,47 @@
 
   @Override
   public boolean instructionInstanceCanThrow() {
-    // TODO(christofferqa): Should return false in R8 if the class is in the program.
     return true;
   }
 
   @Override
-  public boolean instructionMayHaveSideEffects(AppView<?> appView, DexType context) {
+  public AbstractError instructionInstanceCanThrow(AppView<?> appView, DexType context) {
     DexType baseType = getValue().toBaseType(appView.dexItemFactory());
     if (baseType.isPrimitiveType()) {
-      return false;
+      return AbstractError.bottom();
     }
 
-    if (appView.enableWholeProgramOptimizations()) {
-      DexClass clazz = appView.definitionFor(baseType);
-      if (clazz != null && clazz.isProgramClass()) {
-        return false;
-      }
-    } else {
+    // Not applicable for D8.
+    if (!appView.enableWholeProgramOptimizations()) {
+      // Unless the type of interest is same as the context.
       if (baseType == context) {
-        return false;
+        return AbstractError.bottom();
       }
+      return AbstractError.top();
     }
 
-    return true;
+    DexClass clazz = appView.definitionFor(baseType);
+
+    if (clazz == null) {
+      return AbstractError.specific(appView.dexItemFactory().noClassDefFoundErrorType);
+    }
+    // * NoClassDefFoundError (resolution failure).
+    if (!clazz.isResolvable(appView)) {
+      return AbstractError.specific(appView.dexItemFactory().noClassDefFoundErrorType);
+    }
+    // * IllegalAccessError (not visible from the access context).
+    ConstraintWithTarget classVisibility =
+        ConstraintWithTarget.deriveConstraint(context, baseType, clazz.accessFlags, appView);
+    if (classVisibility == ConstraintWithTarget.NEVER) {
+      return AbstractError.specific(appView.dexItemFactory().illegalAccessErrorType);
+    }
+
+    return AbstractError.bottom();
+  }
+
+  @Override
+  public boolean instructionMayHaveSideEffects(AppView<?> appView, DexType context) {
+    return instructionInstanceCanThrow(appView, context).isThrowing();
   }
 
   @Override
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTest.java
new file mode 100644
index 0000000..88e9d07
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTest.java
@@ -0,0 +1,114 @@
+// 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.canonicalization;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.Streams;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+// Will be changed to different package.
+class PackagePrivateClass {
+}
+
+// Will be changed to use the above class in a different package.
+class FakePackagePrivateClassConsumer {
+  public static void main(String... args) {
+    if (System.currentTimeMillis() < -2) {
+      System.out.println(PackagePrivateClass.class.getName());
+    } else if (System.currentTimeMillis() < -1) {
+      System.out.println(PackagePrivateClass.class.getSimpleName());
+    } else {
+      System.out.println("No need to load any classes");
+    }
+  }
+}
+
+@RunWith(Parameterized.class)
+public class IllegalAccessConstClassTest extends TestBase {
+  private static final Class<?> MAIN = FakePackagePrivateClassConsumer.class;
+  private static final String JAVA_OUTPUT = StringUtils.lines(
+      "No need to load any classes"
+  );
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  private final TestParameters parameters;
+
+  public IllegalAccessConstClassTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVMOutput() throws Exception {
+    assumeTrue("Only run JVM reference on CF runtimes", parameters.isCfRuntime());
+    testForJvm()
+        .addTestClasspath()
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue("Only run D8 for Dex backend", parameters.isDexRuntime());
+
+    testForD8()
+        .release()
+        .addProgramClassFileData(
+            IllegalAccessConstClassTestDump.PackagePrivateClassDump.dump())
+        .addProgramClassFileData(
+            IllegalAccessConstClassTestDump.FakePackagePrivateClassConsumerDump.dump())
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(
+            IllegalAccessConstClassTestDump.PackagePrivateClassDump.dump())
+        .addProgramClassFileData(
+            IllegalAccessConstClassTestDump.FakePackagePrivateClassConsumerDump.dump())
+        .addKeepMainRule(MAIN)
+        .noMinification()
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject prvClass = inspector.clazz("PackagePrivateClass");
+    assertThat(prvClass, isPresent());
+
+    ClassSubject mainClass = inspector.clazz(MAIN);
+    assertThat(mainClass, isPresent());
+    MethodSubject mainMethod = mainClass.mainMethod();
+    assertThat(mainMethod, isPresent());
+    // No canonicalization of const-class instructions.
+    assertEquals(
+        2,
+        Streams.stream(mainMethod.iterateInstructions(InstructionSubject::isConstClass)).count());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTestDump.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTestDump.java
new file mode 100644
index 0000000..ea11c78
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/IllegalAccessConstClassTestDump.java
@@ -0,0 +1,169 @@
+// 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.canonicalization;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+class IllegalAccessConstClassTestDump {
+
+  // Originated from the following code snippet:
+  //
+  //   class ...PackagePrivateClass {}
+  //
+  // then repackaged to the top-level.
+  static class PackagePrivateClassDump implements Opcodes {
+
+    public static byte[] dump () throws Exception {
+
+      ClassWriter classWriter = new ClassWriter(0);
+      MethodVisitor methodVisitor;
+
+      classWriter.visit(V1_8, ACC_SUPER, "PackagePrivateClass", null, "java/lang/Object", null);
+
+      classWriter.visitSource("IllegalAccessConstClassTest.java", null);
+
+      {
+        methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+        methodVisitor.visitCode();
+        Label label0 = new Label();
+        methodVisitor.visitLabel(label0);
+        methodVisitor.visitLineNumber(25, label0);
+        methodVisitor.visitVarInsn(ALOAD, 0);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        methodVisitor.visitInsn(RETURN);
+        Label label1 = new Label();
+        methodVisitor.visitLabel(label1);
+        methodVisitor.visitLocalVariable("this", "LPackagePrivateClass;", null, label0, label1, 0);
+        methodVisitor.visitMaxs(1, 1);
+        methodVisitor.visitEnd();
+      }
+      classWriter.visitEnd();
+
+      return classWriter.toByteArray();
+    }
+  }
+
+  // Originated from the following code snippet:
+  //
+  //   class FakePackagePrivateClassConsumer {
+  //     public static void main(String... args) {
+  //       if (System.currentTimeMillis() < -2) {
+  //         System.out.println(PackagePrivateClass.class.getName());
+  //       } else if (System.currentTimeMillis() < -1) {
+  //         System.out.println(PackagePrivateClass.class.getSimpleName());
+  //       } else {
+  //         System.out.println("No need to load any classes");
+  //       }
+  //     }
+  //   }
+  //
+  // then rewritten to use the repackaged PackagePrivateClass instead.
+  static class FakePackagePrivateClassConsumerDump implements Opcodes {
+
+    public static byte[] dump () throws Exception {
+
+      ClassWriter classWriter = new ClassWriter(0);
+      MethodVisitor methodVisitor;
+
+      classWriter.visit(
+          V1_8,
+          ACC_SUPER,
+          "com/android/tools/r8/ir/optimize/canonicalization/FakePackagePrivateClassConsumer",
+          null,
+          "java/lang/Object",
+          null);
+
+      classWriter.visitSource("IllegalAccessConstClassTest.java", null);
+
+      {
+        methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+        methodVisitor.visitCode();
+        Label label0 = new Label();
+        methodVisitor.visitLabel(label0);
+        methodVisitor.visitLineNumber(28, label0);
+        methodVisitor.visitVarInsn(ALOAD, 0);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        methodVisitor.visitInsn(RETURN);
+        Label label1 = new Label();
+        methodVisitor.visitLabel(label1);
+        methodVisitor.visitLocalVariable(
+            "this",
+            "Lcom/android/tools/r8/ir/optimize/canonicalization/FakePackagePrivateClassConsumer;",
+            null,
+            label0,
+            label1,
+            0);
+        methodVisitor.visitMaxs(1, 1);
+        methodVisitor.visitEnd();
+      }
+      {
+        methodVisitor = classWriter.visitMethod(
+            ACC_PUBLIC | ACC_STATIC | ACC_VARARGS, "main", "([Ljava/lang/String;)V", null, null);
+        methodVisitor.visitCode();
+        Label label0 = new Label();
+        methodVisitor.visitLabel(label0);
+        methodVisitor.visitLineNumber(30, label0);
+        methodVisitor.visitMethodInsn(
+            INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
+        methodVisitor.visitLdcInsn(new Long(-2L));
+        methodVisitor.visitInsn(LCMP);
+        Label label1 = new Label();
+        methodVisitor.visitJumpInsn(IFGE, label1);
+        Label label2 = new Label();
+        methodVisitor.visitLabel(label2);
+        methodVisitor.visitLineNumber(31, label2);
+        methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+        methodVisitor.visitLdcInsn(Type.getType("LPackagePrivateClass;"));
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/lang/Class", "getName", "()Ljava/lang/String;", false);
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+        Label label3 = new Label();
+        methodVisitor.visitJumpInsn(GOTO, label3);
+        methodVisitor.visitLabel(label1);
+        methodVisitor.visitLineNumber(32, label1);
+        methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        methodVisitor.visitMethodInsn(
+            INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
+        methodVisitor.visitLdcInsn(new Long(-1L));
+        methodVisitor.visitInsn(LCMP);
+        Label label4 = new Label();
+        methodVisitor.visitJumpInsn(IFGE, label4);
+        Label label5 = new Label();
+        methodVisitor.visitLabel(label5);
+        methodVisitor.visitLineNumber(33, label5);
+        methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+        methodVisitor.visitLdcInsn(Type.getType("LPackagePrivateClass;"));
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/lang/Class", "getSimpleName", "()Ljava/lang/String;", false);
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+        methodVisitor.visitJumpInsn(GOTO, label3);
+        methodVisitor.visitLabel(label4);
+        methodVisitor.visitLineNumber(35, label4);
+        methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+        methodVisitor.visitLdcInsn("No need to load any classes");
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+        methodVisitor.visitLabel(label3);
+        methodVisitor.visitLineNumber(37, label3);
+        methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        methodVisitor.visitInsn(RETURN);
+        Label label6 = new Label();
+        methodVisitor.visitLabel(label6);
+        methodVisitor.visitLocalVariable("args", "[Ljava/lang/String;", null, label0, label6, 0);
+        methodVisitor.visitMaxs(4, 1);
+        methodVisitor.visitEnd();
+      }
+      classWriter.visitEnd();
+
+      return classWriter.toByteArray();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java
new file mode 100644
index 0000000..7d98e26
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/UnresolvableLibraryConstClassTest.java
@@ -0,0 +1,141 @@
+// 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.canonicalization;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+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.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.Streams;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+class LibraryClass {
+}
+
+@NeverMerge
+class ProgramClass1 extends LibraryClass {
+}
+
+class ProgramSubClass extends ProgramClass1 {
+}
+
+interface LibraryInterface {
+  void foo();
+}
+
+class ProgramClass2 implements LibraryInterface {
+  @Override
+  public void foo() {
+    System.out.println("ProgramClass2::foo");
+  }
+}
+
+class TestMain {
+  public static void main(String... args) {
+    if (System.currentTimeMillis() < -6) {
+      System.out.println(ProgramSubClass.class.getName());
+    } else if (System.currentTimeMillis() < -5) {
+      System.out.println(ProgramSubClass.class.getSimpleName());
+    } else if (System.currentTimeMillis() < -4) {
+      System.out.println(ProgramClass1.class.getName());
+    } else if (System.currentTimeMillis() < -3) {
+      System.out.println(ProgramClass1.class.getSimpleName());
+    } else if (System.currentTimeMillis() < -2) {
+      System.out.println(ProgramClass2.class.getName());
+    } else if (System.currentTimeMillis() < -1) {
+      System.out.println(ProgramClass2.class.getSimpleName());
+    } else {
+      System.out.println("No need to load any classes");
+    }
+  }
+}
+
+@RunWith(Parameterized.class)
+public class UnresolvableLibraryConstClassTest extends TestBase {
+  private static final Class<?> MAIN = TestMain.class;
+  private static final String JAVA_OUTPUT = StringUtils.lines(
+      "No need to load any classes"
+  );
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  private final TestParameters parameters;
+
+  public UnresolvableLibraryConstClassTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVMOutput() throws Exception {
+    assumeTrue("Only run JVM reference on CF runtimes", parameters.isCfRuntime());
+    testForJvm()
+        .addTestClasspath()
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue("Only run D8 for Dex backend", parameters.isDexRuntime());
+
+    testForD8()
+        .release()
+        .addProgramClasses(ProgramClass1.class, ProgramClass2.class, ProgramSubClass.class, MAIN)
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addLibraryClasses(LibraryClass.class, LibraryInterface.class)
+        .addLibraryFiles(ToolHelper.getDefaultAndroidJar())
+        .addProgramClasses(ProgramClass1.class, ProgramClass2.class, ProgramSubClass.class, MAIN)
+        .addKeepMainRule(MAIN)
+        .noMinification()
+        .enableMergeAnnotations()
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject programClass1 = inspector.clazz(ProgramClass1.class);
+    assertThat(programClass1, isPresent());
+    ClassSubject programSubClass = inspector.clazz(ProgramSubClass.class);
+    assertThat(programSubClass, isPresent());
+    ClassSubject programClass2 = inspector.clazz(ProgramClass2.class);
+    assertThat(programClass2, isPresent());
+
+    ClassSubject mainClass = inspector.clazz(MAIN);
+    assertThat(mainClass, isPresent());
+    MethodSubject mainMethod = mainClass.mainMethod();
+    assertThat(mainMethod, isPresent());
+    // No canonicalization of const-class instructions.
+    assertEquals(
+        6,
+        Streams.stream(mainMethod.iterateInstructions(InstructionSubject::isConstClass)).count());
+  }
+}