diff --git a/src/main/java/com/android/tools/r8/JdkClassFileProvider.java b/src/main/java/com/android/tools/r8/JdkClassFileProvider.java
new file mode 100644
index 0000000..5e35cf0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/JdkClassFileProvider.java
@@ -0,0 +1,172 @@
+// 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;
+
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.FileUtils;
+import java.io.Closeable;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Lazy Java class file resource provider loading class files from a JDK.
+ *
+ * <p>The descriptor index is built eagerly upon creating the provider and subsequent requests for
+ * resources in the descriptor set will then force the read of JDK content.
+ *
+ * <p>Currently only JDK's of version 9 or higher with a lib/jrt-fs.jar file present is supported.
+ */
+@Keep
+public class JdkClassFileProvider implements ClassFileResourceProvider, Closeable {
+  private Origin origin;
+  private final Set<String> descriptors = new HashSet<>();
+  private final Map<String, String> descriptorToModule = new HashMap<>();
+  private URLClassLoader jrtFsJarLoader;
+  private FileSystem jrtFs;
+
+  /**
+   * Creates a lazy class-file program-resource provider for the system modules of the running Java
+   * VM.
+   *
+   * <p>Only supported if the current VM is of version 9 or higher.
+   */
+  public static ClassFileResourceProvider fromSystemJdk() throws IOException {
+    return new JdkClassFileProvider();
+  }
+
+  /**
+   * Creates a lazy class-file program-resource provider for the system modules of a JDK.
+   *
+   * @param home Location of the JDK to read the program-resources from.
+   *     <p>Only supported if the JDK to read is of version 9 or higher.
+   */
+  public static ClassFileResourceProvider fromSystemModulesJdk(Path home) throws IOException {
+    Path jrtFsJar = home.resolve("lib").resolve("jrt-fs.jar");
+    if (!Files.exists(jrtFsJar)) {
+      throw new NoSuchFileException(jrtFsJar.toString());
+    }
+    return new JdkClassFileProvider(home);
+  }
+
+  /**
+   * Creates a lazy class-file program-resource provider for the runtime of a JDK.
+   *
+   * <p>This will load the program-resources form the system modules for JDK of version 9 or higher.
+   *
+   * <p>This will load <code>rt.jar</code> for JDK of version 8 and lower.
+   *
+   * @param home Location of the JDK to read the program-resources from.
+   */
+  public static ClassFileResourceProvider fromJdkHome(Path home) throws IOException {
+    Path jrtFsJar = home.resolve("lib").resolve("jrt-fs.jar");
+    if (Files.exists(jrtFsJar)) {
+      return JdkClassFileProvider.fromSystemModulesJdk(home);
+    }
+    // JDK has rt.jar in jre/lib/rt.jar.
+    Path rtJar = home.resolve("jre").resolve("lib").resolve("rt.jar");
+    if (Files.exists(rtJar)) {
+      return fromJavaRuntimeJar(rtJar);
+    }
+    // JRE has rt.jar in lib/rt.jar.
+    rtJar = home.resolve("lib").resolve("rt.jar");
+    if (Files.exists(rtJar)) {
+      return fromJavaRuntimeJar(rtJar);
+    }
+    throw new IOException("Path " + home + " does not look like a Java home");
+  }
+
+  public static ClassFileResourceProvider fromJavaRuntimeJar(Path archive) throws IOException {
+    return new ArchiveClassFileProvider(archive);
+  }
+
+  private JdkClassFileProvider() throws IOException {
+    origin = Origin.unknown();
+    collectDescriptors(FileSystems.newFileSystem(URI.create("jrt:/"), Collections.emptyMap()));
+  }
+
+  /**
+   * Creates a lazy class-file program-resource provider for the system modules of a JDK.
+   *
+   * @param home Location of the JDK to read the program-resources from.
+   *     <p>Only supported if the JDK to read is of version 9 or higher.
+   */
+  private JdkClassFileProvider(Path home) throws IOException {
+    origin = new PathOrigin(home);
+    Path jrtFsJar = home.resolve("lib").resolve("jrt-fs.jar");
+    assert Files.exists(jrtFsJar);
+    jrtFsJarLoader = new URLClassLoader(new URL[] {jrtFsJar.toUri().toURL()});
+    FileSystem jrtFs =
+        FileSystems.newFileSystem(URI.create("jrt:/"), Collections.emptyMap(), jrtFsJarLoader);
+    collectDescriptors(jrtFs);
+  }
+
+  private void collectDescriptors(FileSystem jrtFs) throws IOException {
+    this.jrtFs = jrtFs;
+    Files.walk(jrtFs.getPath("/modules"))
+        .forEach(
+            path -> {
+              if (FileUtils.isClassFile(path)) {
+                DescriptorUtils.ModuleAndDescriptor moduleAndDescriptor =
+                    DescriptorUtils.guessJrtModuleAndTypeDescriptor(path.toString());
+                descriptorToModule.put(
+                    moduleAndDescriptor.getDescriptor(), moduleAndDescriptor.getModule());
+                descriptors.add(moduleAndDescriptor.getDescriptor());
+              }
+            });
+  }
+
+  @Override
+  public Set<String> getClassDescriptors() {
+    return Collections.unmodifiableSet(descriptors);
+  }
+
+  @Override
+  public ProgramResource getProgramResource(String descriptor) {
+    if (!descriptors.contains(descriptor)) {
+      return null;
+    }
+    try {
+      return ProgramResource.fromBytes(
+          Origin.unknown(),
+          ProgramResource.Kind.CF,
+          Files.readAllBytes(
+              jrtFs.getPath(
+                  "modules",
+                  descriptorToModule.get(descriptor),
+                  DescriptorUtils.getPathFromDescriptor(descriptor))),
+          Collections.singleton(descriptor));
+    } catch (IOException e) {
+      throw new CompilationError("Failed to read '" + descriptor, origin);
+    }
+  }
+
+  @Override
+  protected void finalize() throws Throwable {
+    close();
+    super.finalize();
+  }
+
+  @Override
+  public void close() throws IOException {
+    jrtFs.close();
+    if (jrtFsJarLoader != null) {
+      jrtFsJarLoader.close();
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
index af056a8..adbaad4 100644
--- a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.utils;
 
 import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
+import static com.android.tools.r8.utils.FileUtils.MODULES_PREFIX;
 
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unreachable;
@@ -429,6 +430,46 @@
     return 'L' + descriptor + ';';
   }
 
+  public static class ModuleAndDescriptor {
+    private final String module;
+    private final String descriptor;
+
+    ModuleAndDescriptor(String module, String descriptor) {
+      this.module = module;
+      this.descriptor = descriptor;
+    }
+
+    public String getModule() {
+      return module;
+    }
+
+    public String getDescriptor() {
+      return descriptor;
+    }
+  }
+
+  /**
+   * Guess module and class descriptor from the location of a class file in a jrt file system.
+   *
+   * @param name the location in a jrt file system of the class file to convert to descriptor
+   * @return module and java class descriptor
+   */
+  public static ModuleAndDescriptor guessJrtModuleAndTypeDescriptor(String name) {
+    assert name != null;
+    assert name.endsWith(CLASS_EXTENSION)
+        : "Name " + name + " must have " + CLASS_EXTENSION + " suffix";
+    assert name.startsWith(MODULES_PREFIX)
+        : "Name " + name + " must have " + MODULES_PREFIX + " prefix";
+    assert name.charAt(MODULES_PREFIX.length()) == '/';
+    int moduleNameEnd = name.indexOf('/', MODULES_PREFIX.length() + 1);
+    String module = name.substring(MODULES_PREFIX.length() + 1, moduleNameEnd);
+    String descriptor = name.substring(moduleNameEnd + 1, name.length() - CLASS_EXTENSION.length());
+    if (descriptor.indexOf(JAVA_PACKAGE_SEPARATOR) != -1) {
+      throw new CompilationError("Unexpected class file name: " + name);
+    }
+    return new ModuleAndDescriptor(module, 'L' + descriptor + ';');
+  }
+
   public static String getPathFromDescriptor(String descriptor) {
     // We are quite loose on names here to support testing illegal names, too.
     assert descriptor.startsWith("L");
diff --git a/src/main/java/com/android/tools/r8/utils/FileUtils.java b/src/main/java/com/android/tools/r8/utils/FileUtils.java
index 24c35fb..19fc10a 100644
--- a/src/main/java/com/android/tools/r8/utils/FileUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/FileUtils.java
@@ -30,6 +30,7 @@
   public static final String JAVA_EXTENSION = ".java";
   public static final String KT_EXTENSION = ".kt";
   public static final String MODULE_INFO_CLASS = "module-info.class";
+  public static final String MODULES_PREFIX = "/modules";
 
   public static final boolean isAndroid =
       System.getProperty("java.vm.name").equalsIgnoreCase("Dalvik");
diff --git a/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
new file mode 100644
index 0000000..1754bff
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/CompileWithJdkClassFileProviderTest.java
@@ -0,0 +1,655 @@
+package com.android.tools.r8;
+
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.util.List;
+import org.hamcrest.core.StringContains;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+@RunWith(Parameterized.class)
+public class CompileWithJdkClassFileProviderTest extends TestBase implements Opcodes {
+
+  @Parameters(name = "{0}, library: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withAllRuntimes().build(), CfVm.values());
+  }
+
+  private final TestParameters parameters;
+  private final CfVm library;
+
+  public CompileWithJdkClassFileProviderTest(TestParameters parameters, CfVm library) {
+    this.parameters = parameters;
+    this.library = library;
+  }
+
+  @Test
+  public void compileSimpleCodeWithJdkLibrary() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJdkHome(TestRuntime.getCheckedInJDKHome(library));
+
+    testForR8(parameters.getBackend())
+        .addLibraryProvider(provider)
+        .addProgramClasses(TestRunner.class)
+        .addKeepMainRule(TestRunner.class)
+        .setMinApi(AndroidApiLevel.B)
+        .run(parameters.getRuntime(), TestRunner.class)
+        .assertSuccessWithOutputLines("Hello, world!");
+
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void compileSimpleCodeWithSystemJdk() throws Exception {
+    // Don't run duplicate tests (library is not used by the test).
+    assumeTrue(library == CfVm.JDK8);
+
+    ClassFileResourceProvider provider = JdkClassFileProvider.fromSystemJdk();
+
+    testForR8(parameters.getBackend())
+        .addLibraryProvider(provider)
+        .addProgramClasses(TestRunner.class)
+        .addKeepMainRule(TestRunner.class)
+        .setMinApi(AndroidApiLevel.B)
+        .run(parameters.getRuntime(), TestRunner.class)
+        .assertSuccessWithOutputLines("Hello, world!");
+
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void compileCodeWithJava9APIUsage() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJdkHome(TestRuntime.getCheckedInJDKHome(library));
+
+    TestShrinkerBuilder<?, ?, ?, ?, ?> testBuilder =
+        testForR8(parameters.getBackend())
+            .addLibraryProvider(provider)
+            .addProgramClassFileData(dumpClassWhichUseJava9Flow())
+            .addKeepMainRule("MySubscriber");
+
+    if (library == CfVm.JDK8) {
+      try {
+        // java.util.concurrent.Flow$Subscriber is not present in JDK8 rt.jar.
+        testBuilder.compileWithExpectedDiagnostics(
+            diagnotics -> {
+              diagnotics.assertErrorsCount(1);
+              diagnotics.assertWarningsCount(1);
+              diagnotics.assertInfosCount(0);
+              assertThat(
+                  diagnotics.getErrors().get(0).getDiagnosticMessage(),
+                  StringContains.containsString("java.util.concurrent.Flow$Subscriber"));
+              assertThat(
+                  diagnotics.getWarnings().get(0).getDiagnosticMessage(),
+                  StringContains.containsString("java.util.concurrent.Flow$Subscriber"));
+            });
+      } catch (CompilationFailedException e) {
+        return;
+      }
+      fail("Expected compilation error");
+    } else {
+      if (parameters.getRuntime().isDex()) {
+        // java.util.concurrent.Flow$Subscriber is not present on Android.
+        testBuilder
+            .run(parameters.getRuntime(), "MySubscriber")
+            .assertFailureWithErrorThatMatches(
+                anyOf(
+                    // Dalvik 4.0.4
+                    containsString("java.lang.NoClassDefFoundError: MySubscriber"),
+                    // Other Dalviks.
+                    containsString(
+                        "java.lang.ClassNotFoundException: Didn't find class \"MySubscriber\""),
+                    // Art.
+                    containsString(
+                        "java.lang.NoClassDefFoundError: "
+                            + "Failed resolution of: Ljava/util/concurrent/Flow$Subscriber;")));
+      } else {
+        if (parameters.getRuntime().asCf().getVm() == CfVm.JDK8) {
+          // java.util.concurrent.Flow$Subscriber not present in JDK8.
+          testBuilder
+              .run(parameters.getRuntime(), "MySubscriber")
+              .assertFailureWithErrorThatMatches(
+                  containsString("Could not find or load main class MySubscriber"));
+
+        } else {
+          // java.util.concurrent.Flow$Subscriber present in JDK9+.
+          testBuilder
+              .run(parameters.getRuntime(), "MySubscriber")
+              .disassemble()
+              .assertSuccessWithOutputLines("Got : 1", "Got : 2", "Got : 3", "Done");
+        }
+      }
+    }
+
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  /*
+   * The code below is from compiling the following source with javac from OpenJDK 9.0.4 with
+   * options:
+   *
+   *    -source 1.8 -target 1.8
+   *
+   * Note that -source 1.8 on on Java 9 will use the builtin boot class path (including
+   * java.util.concurrent.Flow) if no explicit boot classpath is specified.
+   *
+   * import java.util.List;
+   * import java.lang.Thread;
+   * import java.util.concurrent.Flow.Subscriber;
+   * import java.util.concurrent.Flow.Subscription;
+   * import java.util.concurrent.SubmissionPublisher;
+   * import java.util.concurrent.locks.Condition;
+   * import java.util.concurrent.locks.Lock;
+   * import java.util.concurrent.locks.ReentrantLock;
+   *
+   * public class MySubscriber<T> implements Subscriber<T> {
+   *   final static Lock lock = new ReentrantLock();
+   *   final static Condition done  = lock.newCondition();
+   *
+   *   private Subscription subscription;
+   *
+   *   @Override
+   *   public void onSubscribe(Subscription subscription) {
+   *     this.subscription = subscription;
+   *     subscription.request(1);
+   *   }
+   *
+   *   @Override
+   *   public void onNext(T item) {
+   *     System.out.println("Got : " + item);
+   *     subscription.request(1);
+   *   }
+   *   @Override
+   *   public void onError(Throwable t) {
+   *     t.printStackTrace();
+   *   }
+   *
+   *   @Override
+   *   public void onComplete() {
+   *     System.out.println("Done");
+   *     signalCondition(done);
+   *   }
+   *
+   *   public static void awaitCondition(Condition condition) throws Exception {
+   *     lock.lock();
+   *     try {
+   *       condition.await();
+   *     } finally {
+   *       lock.unlock();
+   *     }
+   *   }
+   *
+   *   public static void signalCondition(Condition condition) {
+   *     lock.lock();
+   *     try {
+   *       condition.signal();
+   *     } finally {
+   *       lock.unlock();
+   *     }
+   *   }
+   *
+   *   public static void main(String[] args) throws Exception {
+   *     SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
+   *     MySubscriber<String> subscriber = new MySubscriber<>();
+   *     publisher.subscribe(subscriber);
+   *     List<String> items = List.of("1", "2", "3");
+   *
+   *     items.forEach(publisher::submit);
+   *     publisher.close();
+   *
+   *     awaitCondition(done);
+   *   }
+   * }
+   *
+   */
+  public static byte[] dumpClassWhichUseJava9Flow() {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    FieldVisitor fieldVisitor;
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(
+        V1_8,
+        ACC_PUBLIC | ACC_SUPER,
+        "MySubscriber",
+        "<T:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/concurrent/Flow$Subscriber<TT;>;",
+        "java/lang/Object",
+        new String[] {"java/util/concurrent/Flow$Subscriber"});
+
+    classWriter.visitSource("MySubscriber.java", null);
+
+    classWriter.visitInnerClass(
+        "java/util/concurrent/Flow$Subscription",
+        "java/util/concurrent/Flow",
+        "Subscription",
+        ACC_PUBLIC | ACC_STATIC | ACC_ABSTRACT | ACC_INTERFACE);
+
+    classWriter.visitInnerClass(
+        "java/util/concurrent/Flow$Subscriber",
+        "java/util/concurrent/Flow",
+        "Subscriber",
+        ACC_PUBLIC | ACC_STATIC | ACC_ABSTRACT | ACC_INTERFACE);
+
+    classWriter.visitInnerClass(
+        "java/lang/invoke/MethodHandles$Lookup",
+        "java/lang/invoke/MethodHandles",
+        "Lookup",
+        ACC_PUBLIC | ACC_FINAL | ACC_STATIC);
+
+    {
+      fieldVisitor =
+          classWriter.visitField(
+              ACC_FINAL | ACC_STATIC, "lock", "Ljava/util/concurrent/locks/Lock;", null, null);
+      fieldVisitor.visitEnd();
+    }
+    {
+      fieldVisitor =
+          classWriter.visitField(
+              ACC_FINAL | ACC_STATIC, "done", "Ljava/util/concurrent/locks/Condition;", null, null);
+      fieldVisitor.visitEnd();
+    }
+    {
+      fieldVisitor =
+          classWriter.visitField(
+              ACC_PRIVATE, "subscription", "Ljava/util/concurrent/Flow$Subscription;", null, null);
+      fieldVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(10, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC, "onSubscribe", "(Ljava/util/concurrent/Flow$Subscription;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(18, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitFieldInsn(
+          PUTFIELD, "MySubscriber", "subscription", "Ljava/util/concurrent/Flow$Subscription;");
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(19, label1);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitInsn(LCONST_1);
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/Flow$Subscription", "request", "(J)V", true);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(20, label2);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(3, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(ACC_PUBLIC, "onNext", "(Ljava/lang/Object;)V", "(TT;)V", null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(24, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitTypeInsn(NEW, "java/lang/StringBuilder");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(
+          INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);
+      methodVisitor.visitLdcInsn("Got : ");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/lang/StringBuilder",
+          "append",
+          "(Ljava/lang/String;)Ljava/lang/StringBuilder;",
+          false);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/lang/StringBuilder",
+          "append",
+          "(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
+          false);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(25, label1);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitFieldInsn(
+          GETFIELD, "MySubscriber", "subscription", "Ljava/util/concurrent/Flow$Subscription;");
+      methodVisitor.visitInsn(LCONST_1);
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/Flow$Subscription", "request", "(J)V", true);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(26, label2);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(3, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(ACC_PUBLIC, "onError", "(Ljava/lang/Throwable;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(29, label0);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/lang/Throwable", "printStackTrace", "()V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(30, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "onComplete", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(34, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitLdcInsn("Done");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(35, label1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "done", "Ljava/util/concurrent/locks/Condition;");
+      methodVisitor.visitMethodInsn(
+          INVOKESTATIC,
+          "MySubscriber",
+          "signalCondition",
+          "(Ljava/util/concurrent/locks/Condition;)V",
+          false);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(36, label2);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC,
+              "awaitCondition",
+              "(Ljava/util/concurrent/locks/Condition;)V",
+              null,
+              new String[] {"java/lang/Exception"});
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      Label label1 = new Label();
+      Label label2 = new Label();
+      methodVisitor.visitTryCatchBlock(label0, label1, label2, null);
+      Label label3 = new Label();
+      methodVisitor.visitLabel(label3);
+      methodVisitor.visitLineNumber(39, label3);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "lock", "()V", true);
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(41, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Condition", "await", "()V", true);
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(43, label1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "unlock", "()V", true);
+      Label label4 = new Label();
+      methodVisitor.visitLabel(label4);
+      methodVisitor.visitLineNumber(44, label4);
+      Label label5 = new Label();
+      methodVisitor.visitJumpInsn(GOTO, label5);
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(43, label2);
+      methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/Throwable"});
+      methodVisitor.visitVarInsn(ASTORE, 1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "unlock", "()V", true);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitInsn(ATHROW);
+      methodVisitor.visitLabel(label5);
+      methodVisitor.visitLineNumber(45, label5);
+      methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC,
+              "signalCondition",
+              "(Ljava/util/concurrent/locks/Condition;)V",
+              null,
+              null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      Label label1 = new Label();
+      Label label2 = new Label();
+      methodVisitor.visitTryCatchBlock(label0, label1, label2, null);
+      Label label3 = new Label();
+      methodVisitor.visitLabel(label3);
+      methodVisitor.visitLineNumber(48, label3);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "lock", "()V", true);
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(50, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Condition", "signal", "()V", true);
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(52, label1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "unlock", "()V", true);
+      Label label4 = new Label();
+      methodVisitor.visitLabel(label4);
+      methodVisitor.visitLineNumber(53, label4);
+      Label label5 = new Label();
+      methodVisitor.visitJumpInsn(GOTO, label5);
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(52, label2);
+      methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/Throwable"});
+      methodVisitor.visitVarInsn(ASTORE, 1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/concurrent/locks/Lock", "unlock", "()V", true);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitInsn(ATHROW);
+      methodVisitor.visitLabel(label5);
+      methodVisitor.visitLineNumber(54, label5);
+      methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 2);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor =
+          classWriter.visitMethod(
+              ACC_PUBLIC | ACC_STATIC,
+              "main",
+              "([Ljava/lang/String;)V",
+              null,
+              new String[] {"java/lang/Exception"});
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(57, label0);
+      methodVisitor.visitTypeInsn(NEW, "java/util/concurrent/SubmissionPublisher");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(
+          INVOKESPECIAL, "java/util/concurrent/SubmissionPublisher", "<init>", "()V", false);
+      methodVisitor.visitVarInsn(ASTORE, 1);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(58, label1);
+      methodVisitor.visitTypeInsn(NEW, "MySubscriber");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "MySubscriber", "<init>", "()V", false);
+      methodVisitor.visitVarInsn(ASTORE, 2);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(59, label2);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitVarInsn(ALOAD, 2);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/util/concurrent/SubmissionPublisher",
+          "subscribe",
+          "(Ljava/util/concurrent/Flow$Subscriber;)V",
+          false);
+      Label label3 = new Label();
+      methodVisitor.visitLabel(label3);
+      methodVisitor.visitLineNumber(60, label3);
+      methodVisitor.visitLdcInsn("1");
+      methodVisitor.visitLdcInsn("2");
+      methodVisitor.visitLdcInsn("3");
+      methodVisitor.visitMethodInsn(
+          INVOKESTATIC,
+          "java/util/List",
+          "of",
+          "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/List;",
+          true);
+      methodVisitor.visitVarInsn(ASTORE, 3);
+      Label label4 = new Label();
+      methodVisitor.visitLabel(label4);
+      methodVisitor.visitLineNumber(62, label4);
+      methodVisitor.visitVarInsn(ALOAD, 3);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(
+          INVOKESTATIC,
+          "java/util/Objects",
+          "requireNonNull",
+          "(Ljava/lang/Object;)Ljava/lang/Object;",
+          false);
+      methodVisitor.visitInsn(POP);
+      methodVisitor.visitInvokeDynamicInsn(
+          "accept",
+          "(Ljava/util/concurrent/SubmissionPublisher;)Ljava/util/function/Consumer;",
+          new Handle(
+              Opcodes.H_INVOKESTATIC,
+              "java/lang/invoke/LambdaMetafactory",
+              "metafactory",
+              "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
+              false),
+          new Object[] {
+            Type.getType("(Ljava/lang/Object;)V"),
+            new Handle(
+                Opcodes.H_INVOKEVIRTUAL,
+                "java/util/concurrent/SubmissionPublisher",
+                "submit",
+                "(Ljava/lang/Object;)I",
+                false),
+            Type.getType("(Ljava/lang/String;)V")
+          });
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE, "java/util/List", "forEach", "(Ljava/util/function/Consumer;)V", true);
+      Label label5 = new Label();
+      methodVisitor.visitLabel(label5);
+      methodVisitor.visitLineNumber(63, label5);
+      methodVisitor.visitVarInsn(ALOAD, 1);
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/util/concurrent/SubmissionPublisher", "close", "()V", false);
+      Label label6 = new Label();
+      methodVisitor.visitLabel(label6);
+      methodVisitor.visitLineNumber(65, label6);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "done", "Ljava/util/concurrent/locks/Condition;");
+      methodVisitor.visitMethodInsn(
+          INVOKESTATIC,
+          "MySubscriber",
+          "awaitCondition",
+          "(Ljava/util/concurrent/locks/Condition;)V",
+          false);
+      Label label7 = new Label();
+      methodVisitor.visitLabel(label7);
+      methodVisitor.visitLineNumber(66, label7);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(3, 4);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(11, label0);
+      methodVisitor.visitTypeInsn(NEW, "java/util/concurrent/locks/ReentrantLock");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(
+          INVOKESPECIAL, "java/util/concurrent/locks/ReentrantLock", "<init>", "()V", false);
+      methodVisitor.visitFieldInsn(
+          PUTSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(12, label1);
+      methodVisitor.visitFieldInsn(
+          GETSTATIC, "MySubscriber", "lock", "Ljava/util/concurrent/locks/Lock;");
+      methodVisitor.visitMethodInsn(
+          INVOKEINTERFACE,
+          "java/util/concurrent/locks/Lock",
+          "newCondition",
+          "()Ljava/util/concurrent/locks/Condition;",
+          true);
+      methodVisitor.visitFieldInsn(
+          PUTSTATIC, "MySubscriber", "done", "Ljava/util/concurrent/locks/Condition;");
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 0);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+
+  public static class TestRunner {
+    public static void main(String[] args) {
+      System.out.println("Hello, world!");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/JdkClassFileProviderTest.java b/src/test/java/com/android/tools/r8/JdkClassFileProviderTest.java
new file mode 100644
index 0000000..d6f38af
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/JdkClassFileProviderTest.java
@@ -0,0 +1,120 @@
+package com.android.tools.r8;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import org.junit.Test;
+import org.objectweb.asm.Opcodes;
+
+public class JdkClassFileProviderTest extends TestBase implements Opcodes {
+
+  @Test
+  public void testInvalid8RuntimeClassPath() throws Exception {
+    Path path = temp.newFolder().toPath();
+    try {
+      JdkClassFileProvider.fromJdkHome(path);
+      fail("Not supposed to succeed");
+    } catch (IOException e) {
+      assertThat(e.toString(), containsString(path.toString()));
+      assertThat(e.toString(), containsString("does not look like a Java home"));
+    }
+  }
+
+  @Test
+  public void testJdk8JavHome() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJdkHome(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK8));
+    assertJavaLangObject(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void testJdk8RuntimeClassPath() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJavaRuntimeJar(
+            ToolHelper.getJavaHome(TestRuntime.CfVm.JDK8)
+                .resolve("jre")
+                .resolve("lib")
+                .resolve("rt.jar"));
+    assertJavaLangObject(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void testJdk8SystemModules() throws Exception {
+    try {
+      JdkClassFileProvider.fromSystemModulesJdk(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK8));
+      fail("Not supposed to succeed");
+    } catch (NoSuchFileException e) {
+      assertThat(e.toString(), containsString("lib/jrt-fs.jar"));
+    }
+  }
+
+  @Test
+  public void testJdk9JavaHome() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJdkHome(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK9));
+    assertJavaLangObject(provider);
+    assertJavaUtilConcurrentFlowSubscriber(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void testJdk9SystemModules() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromSystemModulesJdk(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK9));
+    assertJavaLangObject(provider);
+    assertJavaUtilConcurrentFlowSubscriber(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void testJdk11JavaHome() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromJdkHome(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK11));
+    assertJavaLangObject(provider);
+    assertJavaUtilConcurrentFlowSubscriber(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  @Test
+  public void testJdk11SystemModules() throws Exception {
+    ClassFileResourceProvider provider =
+        JdkClassFileProvider.fromSystemModulesJdk(ToolHelper.getJavaHome(TestRuntime.CfVm.JDK11));
+    assertJavaLangObject(provider);
+    assertJavaUtilConcurrentFlowSubscriber(provider);
+    assert provider instanceof AutoCloseable;
+    ((AutoCloseable) provider).close();
+  }
+
+  private void assertJavaLangObject(ClassFileResourceProvider provider) throws Exception {
+    assertTrue(provider.getClassDescriptors().contains("Ljava/lang/Object;"));
+    assertTrue(
+        ByteStreams.toByteArray(provider.getProgramResource("Ljava/lang/Object;").getByteStream())
+                .length
+            > 0);
+  }
+
+  private void assertJavaUtilConcurrentFlowSubscriber(ClassFileResourceProvider provider)
+      throws Exception {
+    assertTrue(provider.getClassDescriptors().contains("Ljava/util/concurrent/Flow$Subscriber;"));
+    assertTrue(
+        ByteStreams.toByteArray(
+                    provider
+                        .getProgramResource("Ljava/util/concurrent/Flow$Subscriber;")
+                        .getByteStream())
+                .length
+            > 0);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestRuntime.java b/src/test/java/com/android/tools/r8/TestRuntime.java
index 4c17ac7..d834ebc 100644
--- a/src/test/java/com/android/tools/r8/TestRuntime.java
+++ b/src/test/java/com/android/tools/r8/TestRuntime.java
@@ -69,6 +69,10 @@
       return this.ordinal() <= other.ordinal();
     }
 
+    public boolean hasModularRuntime() {
+      return this != JDK8;
+    }
+
     @Override
     public String toString() {
       return name;
@@ -109,10 +113,12 @@
     return CHECKED_IN_JDKS.containsKey(jdk);
   }
 
-  public static Path getCheckInJDKPathFor(CfVm jdk) {
-    return Paths.get("third_party", "openjdk")
-        .resolve(CHECKED_IN_JDKS.get(jdk))
-        .resolve(Paths.get("bin", "java"));
+  public static Path getCheckedInJDKHome(CfVm jdk) {
+    return Paths.get("third_party", "openjdk").resolve(CHECKED_IN_JDKS.get(jdk));
+  }
+
+  public static Path getCheckedInJDKPathFor(CfVm jdk) {
+    return getCheckedInJDKHome(jdk).resolve(Paths.get("bin", "java"));
   }
 
   public static TestRuntime getDefaultJavaRuntime() {
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 38fb7c7..0445166 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -1273,8 +1273,7 @@
       List<String> extraOptions,
       Path... filesToCompile)
       throws IOException {
-    String jvm = runtime == null ? getSystemJavaExecutable() : getJavaExecutable(runtime);
-    List<String> cmdline = new ArrayList<String>(Arrays.asList(jvm));
+    List<String> cmdline = new ArrayList<>(Arrays.asList(getJavaExecutable(runtime)));
     cmdline.add("-jar");
     cmdline.add(KT_PRELOADER);
     cmdline.add("org.jetbrains.kotlin.preloading.Preloader");
@@ -1419,7 +1418,7 @@
 
   public static String getJavaExecutable(CfVm runtime) {
     if (TestRuntime.isCheckedInJDK(runtime)) {
-      return TestRuntime.getCheckInJDKPathFor(runtime).toString();
+      return TestRuntime.getCheckedInJDKPathFor(runtime).toString();
     } else {
       // TODO(b/127785410): Always assume a non-null runtime.
       assert runtime == null || TestParametersBuilder.isSystemJdk(runtime);
@@ -1427,6 +1426,10 @@
     }
   }
 
+  public static Path getJavaHome(CfVm runtime) {
+    return TestRuntime.getCheckedInJDKHome(runtime);
+  }
+
   public static ProcessResult runArtRaw(ArtCommandBuilder builder) throws IOException {
     return runArtProcessRaw(builder);
   }