diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index 60dc9ae..5a71add 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -9,13 +9,15 @@
 import com.android.tools.r8.JctfTestSpecifications.Outcome;
 import com.android.tools.r8.TestCondition.Runtime;
 import com.android.tools.r8.TestCondition.RuntimeSet;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.TestRuntime.DexRuntime;
 import com.android.tools.r8.ToolHelper.ArtCommandBuilder;
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.ToolHelper.DexVm.Kind;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.ArtErrorParser;
 import com.android.tools.r8.utils.ArtErrorParser.ArtErrorInfo;
@@ -46,6 +48,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.function.BiFunction;
@@ -1526,19 +1529,53 @@
     runArtTest(ToolHelper.getDexVm(), compilerUnderTest);
   }
 
+  private static class CompilationOptions {
+    private final boolean disableInlining;
+    private final boolean disableClassInlining;
+    private final boolean disableUninstantiatedTypeOptimization;
+    private final boolean hasMissingClasses;
+
+    private CompilationOptions(TestSpecification spec) {
+      this.disableInlining = spec.disableInlining;
+      this.disableClassInlining = spec.disableClassInlining;
+      this.disableUninstantiatedTypeOptimization = spec.disableUninstantiatedTypeOptimization;
+      this.hasMissingClasses = spec.hasMissingClasses;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      CompilationOptions options = (CompilationOptions) o;
+      return disableInlining == options.disableInlining
+          && disableClassInlining == options.disableClassInlining
+          && disableUninstantiatedTypeOptimization == options.disableUninstantiatedTypeOptimization
+          && hasMissingClasses == options.hasMissingClasses;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(
+          disableInlining,
+          disableClassInlining,
+          disableUninstantiatedTypeOptimization,
+          hasMissingClasses);
+    }
+  }
+
   private void executeCompilerUnderTest(
       CompilerUnderTest compilerUnderTest,
       Collection<String> fileNames,
       String resultPath,
       CompilationMode compilationMode,
-      boolean disableInlining,
-      boolean disableClassInlining,
-      boolean disableUninstantiatedTypeOptimization,
-      boolean hasMissingClasses)
+      CompilationOptions compilationOptions)
       throws CompilationFailedException {
-    executeCompilerUnderTest(compilerUnderTest, fileNames, resultPath, compilationMode, null,
-        disableInlining, disableClassInlining, disableUninstantiatedTypeOptimization,
-        hasMissingClasses);
+    executeCompilerUnderTest(
+        compilerUnderTest, fileNames, resultPath, compilationMode, null, compilationOptions);
   }
 
   private void executeCompilerUnderTest(
@@ -1547,10 +1584,7 @@
       String resultPath,
       CompilationMode mode,
       String keepRulesFile,
-      boolean disableInlining,
-      boolean disableClassInlining,
-      boolean disableUninstantiatedTypeOptimization,
-      boolean hasMissingClasses)
+      CompilationOptions compilationOptions)
       throws CompilationFailedException {
     assert mode != null;
     switch (compilerUnderTest) {
@@ -1698,20 +1732,20 @@
           ToolHelper.runR8(
               builder.build(),
               options -> {
-                if (disableInlining) {
+                if (compilationOptions.disableInlining) {
                   options.enableInlining = false;
                 }
-                if (disableClassInlining) {
+                if (compilationOptions.disableClassInlining) {
                   options.enableClassInlining = false;
                 }
-                if (disableUninstantiatedTypeOptimization) {
+                if (compilationOptions.disableUninstantiatedTypeOptimization) {
                   options.enableUninstantiatedTypeOptimization = false;
                 }
                 // Make sure we don't depend on this settings.
                 options.classInliningInstructionLimit = 10000;
                 options.lineNumberOptimization = LineNumberOptimization.OFF;
                 // Some tests actually rely on missing classes for what they test.
-                options.ignoreMissingClasses = hasMissingClasses;
+                options.ignoreMissingClasses = compilationOptions.hasMissingClasses;
               });
           break;
         }
@@ -1794,15 +1828,38 @@
             noInlining);
   }
 
-  protected void runJctfTest(CompilerUnderTest compilerUnderTest, String classFilePath,
-      String fullClassName)
-      throws IOException, ProguardRuleParserException, ExecutionException,
-      CompilationFailedException {
-    Runtime runtime;
-    if (compilerUnderTest == CompilerUnderTest.R8CF) {
-      runtime = Runtime.JAVA;
+  private static Runtime getRuntime(TestRuntime vm) {
+    if (vm.isCf()) {
+      return Runtime.JAVA;
+    } else if (vm.isDex()) {
+      return Runtime.fromDexVmVersion(vm.asDex().getVm().getVersion());
     } else {
-      runtime = Runtime.fromDexVmVersion(ToolHelper.getDexVm().getVersion());
+      throw new Unreachable();
+    }
+  }
+
+  private static class VmSpec {
+    final TestRuntime vm;
+    final TestSpecification spec;
+
+    private VmSpec(TestRuntime vm, TestSpecification testSpecification) {
+      this.vm = vm;
+      this.spec = testSpecification;
+    }
+  }
+
+  protected void runJctfTest(
+      CompilerUnderTest compilerUnderTest, String classFilePath, String fullClassName)
+      throws IOException, CompilationFailedException {
+    List<TestRuntime> vms = new ArrayList<>();
+    if (compilerUnderTest == CompilerUnderTest.R8CF) {
+      for (CfVm vm : TestParametersBuilder.getAvailableCfVms()) {
+        vms.add(new TestRuntime.CfRuntime(vm));
+      }
+    } else {
+      for (DexVm vm : TestParametersBuilder.getAvailableDexVms()) {
+        vms.add(new DexRuntime(vm));
+      }
     }
 
     CompilerUnderTest firstCompilerUnderTest =
@@ -1811,19 +1868,28 @@
             : compilerUnderTest;
     CompilationMode compilationMode = defaultCompilationMode(compilerUnderTest);
 
-    File resultDir = temp.newFolder(firstCompilerUnderTest.toString().toLowerCase() + "-output");
+    List<VmSpec> vmSpecs = new ArrayList<>();
+    for (TestRuntime vm : vms) {
+      File resultDir =
+          temp.newFolder(
+              firstCompilerUnderTest.toString().toLowerCase() + "-output-" + vm.toString());
 
-    TestSpecification specification =
-        JctfTestSpecifications.getExpectedOutcome(
-            name,
-            firstCompilerUnderTest,
-            runtime,
-            compilationMode,
-            compilerUnderTest == CompilerUnderTest.R8CF
-                ? jctfOutcomeToSpecificationJava(name, resultDir)
-                : jctfOutcomeToSpecification(name, DexTool.NONE, resultDir, ToolHelper.getDexVm()));
+      TestSpecification specification =
+          JctfTestSpecifications.getExpectedOutcome(
+              name,
+              firstCompilerUnderTest,
+              getRuntime(vm),
+              compilationMode,
+              compilerUnderTest == CompilerUnderTest.R8CF
+                  ? jctfOutcomeToSpecificationJava(name, resultDir)
+                  : jctfOutcomeToSpecification(name, DexTool.NONE, resultDir, vm.asDex().getVm()));
 
-    if (specification.skipTest) {
+      if (!specification.skipTest) {
+        vmSpecs.add(new VmSpec(vm, specification));
+      }
+    }
+
+    if (vmSpecs.isEmpty()) {
       return;
     }
 
@@ -1887,62 +1953,82 @@
     }
 
     if (compilerUnderTest == CompilerUnderTest.R8CF) {
-      runJctfTestDoRunOnJava(fileNames, specification, fullClassName, compilationMode, resultDir);
-    } else {
-
-      runJctfTestDoRunOnArt(
-          fileNames,
-          specification,
-          firstCompilerUnderTest,
-          fullClassName,
-          compilationMode,
-          ToolHelper.getDexVm(),
-          resultDir);
+      assert vmSpecs.size() == 1
+          : "Running the same test on multiple JVMs should share the same build.";
+      for (VmSpec vmSpec : vmSpecs) {
+        runJctfTestDoRunOnJava(
+            fileNames, vmSpec.spec, fullClassName, compilationMode, vmSpec.vm.asCf().getVm());
+      }
+      return;
     }
 
-    // second pass if D8_R8Debug
-    if (compilerUnderTest == CompilerUnderTest.R8_AFTER_D8) {
-      List<String> d8OutputFileNames =
-          Files.list(resultDir.toPath())
-              .filter(FileUtils::isDexFile)
-              .map(Path::toString)
-              .collect(Collectors.toList());
-      File r8ResultDir = temp.newFolder("r8-output");
-      compilationMode = CompilationMode.DEBUG;
-      specification =
+    CompilationOptions compilationOptions = null;
+    File compiledDir = temp.newFolder();
+    for (VmSpec vmSpec : vmSpecs) {
+      CompilationOptions thisOptions = new CompilationOptions(vmSpec.spec);
+      if (compilationOptions == null) {
+        compilationOptions = thisOptions;
+        executeCompilerUnderTest(
+            firstCompilerUnderTest,
+            fileNames,
+            compiledDir.getAbsolutePath(),
+            compilationMode,
+            compilationOptions);
+      } else {
+        // For now compile options don't change across vms.
+        assert compilationOptions.equals(thisOptions);
+      }
+      Files.copy(
+          compiledDir.toPath().resolve("classes.dex"),
+          vmSpec.spec.directory.toPath().resolve("classes.dex"));
+      runJctfTestDoRunOnArt(fileNames, vmSpec.spec, fullClassName, vmSpec.vm.asDex().getVm());
+    }
+
+    if (compilerUnderTest != CompilerUnderTest.R8_AFTER_D8) {
+      return;
+    }
+
+    // Second pass (R8), if R8_AFTER_D8.
+    CompilationOptions r8CompilationOptions = null;
+    File r8CompiledDir = temp.newFolder();
+    for (VmSpec vmSpec : vmSpecs) {
+      File r8ResultDir = temp.newFolder("r8-output-" + vmSpec.vm.toString());
+      TestSpecification specification =
           JctfTestSpecifications.getExpectedOutcome(
               name,
               CompilerUnderTest.R8_AFTER_D8,
-              runtime,
-              compilationMode,
-              jctfOutcomeToSpecification(name, DexTool.DX, r8ResultDir, ToolHelper.getDexVm()));
+              getRuntime(vmSpec.vm),
+              CompilationMode.RELEASE,
+              jctfOutcomeToSpecification(name, DexTool.DX, r8ResultDir, vmSpec.vm.asDex().getVm()));
       if (specification.skipTest) {
-        return;
+        continue;
       }
-      runJctfTestDoRunOnArt(
-          d8OutputFileNames,
-          specification,
-          CompilerUnderTest.R8,
-          fullClassName,
-          compilationMode,
-          ToolHelper.getDexVm(),
-          r8ResultDir);
+      CompilationOptions thisOptions = new CompilationOptions(vmSpec.spec);
+      if (r8CompilationOptions == null) {
+        r8CompilationOptions = thisOptions;
+        executeCompilerUnderTest(
+            CompilerUnderTest.R8,
+            Collections.singletonList(compiledDir.toPath().resolve("classes.dex").toString()),
+            r8CompiledDir.getAbsolutePath(),
+            CompilationMode.RELEASE,
+            r8CompilationOptions);
+      } else {
+        // For now compile options don't change across vms.
+        assert r8CompilationOptions.equals(thisOptions);
+      }
+      Files.copy(
+          r8CompiledDir.toPath().resolve("classes.dex"),
+          specification.directory.toPath().resolve("classes.dex"));
+      runJctfTestDoRunOnArt(fileNames, specification, fullClassName, vmSpec.vm.asDex().getVm());
     }
   }
 
   private void runJctfTestDoRunOnArt(
       Collection<String> fileNames,
       TestSpecification specification,
-      CompilerUnderTest compilerUnderTest,
       String fullClassName,
-      CompilationMode mode,
-      DexVm dexVm,
-      File resultDir)
-      throws IOException, CompilationFailedException {
-    executeCompilerUnderTest(compilerUnderTest, fileNames, resultDir.getAbsolutePath(), mode,
-        specification.disableInlining, specification.disableClassInlining,
-        specification.disableUninstantiatedTypeOptimization, specification.hasMissingClasses);
-
+      DexVm dexVm)
+      throws IOException {
     if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
       return;
     }
@@ -1951,16 +2037,9 @@
 
     // Collect the generated dex files.
     File[] outputFiles =
-        resultDir.listFiles((File file) -> file.getName().endsWith(".dex"));
-    if (outputFiles.length == 1) {
-      // Just run Art on classes.dex.
-      processedFile = outputFiles[0];
-    } else {
-      // Run Art on JAR file with multiple dex files.
-      processedFile
-          = temp.getRoot().toPath().resolve(specification.name + ".jar").toFile();
-      buildJar(outputFiles, processedFile);
-    }
+        specification.directory.listFiles((File file) -> file.getName().endsWith(".dex"));
+    assert outputFiles.length == 1;
+    processedFile = outputFiles[0];
 
     boolean compileOnly = System.getProperty("jctf_compile_only", "0").equals("1");
     if (compileOnly || specification.skipRun) {
@@ -1976,7 +2055,7 @@
     if (dexVm.isNewerThan(DexVm.ART_4_4_4_HOST)) {
       builder.appendArtOption("-Ximage:/system/non/existent/image.art");
     }
-    for (String s : ToolHelper.getBootLibs()) {
+    for (String s : ToolHelper.getBootLibs(dexVm)) {
       builder.appendBootClassPath(new File(s).getCanonicalPath());
     }
     builder.setMainClass(JUNIT_TEST_RUNNER);
@@ -2003,20 +2082,18 @@
       TestSpecification specification,
       String fullClassName,
       CompilationMode mode,
-      File resultDir)
+      CfVm vm)
       throws IOException, CompilationFailedException {
+    assert TestParametersBuilder.isSystemJdk(vm);
     if (JctfTestSpecifications.compilationFailsWithAsmMethodTooLarge.contains(specification.name)) {
       expectException(org.objectweb.asm.MethodTooLargeException.class);
     }
     executeCompilerUnderTest(
         CompilerUnderTest.R8CF,
         fileNames,
-        resultDir.getAbsolutePath(),
+        specification.directory.getAbsolutePath(),
         mode,
-        specification.disableInlining,
-        specification.disableClassInlining,
-        specification.disableUninstantiatedTypeOptimization,
-        specification.hasMissingClasses);
+        new CompilationOptions(specification));
 
     boolean compileOnly = System.getProperty("jctf_compile_only", "0").equals("1");
 
@@ -2033,7 +2110,7 @@
     // running the test.
     ProcessResult result =
         ToolHelper.runJava(
-            resultDir.toPath(),
+            specification.directory.toPath(),
             "-Xmx" + ToolHelper.BOT_MAX_HEAP_SIZE,
             JUNIT_TEST_RUNNER,
             fullClassName);
@@ -2168,9 +2245,11 @@
       expectException(CompilationError.class);
       try {
         executeCompilerUnderTest(
-            compilerUnderTest, fileNames, resultDir.getCanonicalPath(), compilationMode,
-            specification.disableInlining, specification.disableClassInlining,
-            specification.disableUninstantiatedTypeOptimization, specification.hasMissingClasses);
+            compilerUnderTest,
+            fileNames,
+            resultDir.getCanonicalPath(),
+            compilationMode,
+            new CompilationOptions(specification));
       } catch (CompilationFailedException e) {
         throw new CompilationError(e.getMessage(), e);
       }
@@ -2179,16 +2258,20 @@
     } else if (specification.failsWithX8) {
       expectException(Throwable.class);
       executeCompilerUnderTest(
-          compilerUnderTest, fileNames, resultDir.getCanonicalPath(), compilationMode,
-          specification.disableInlining, specification.disableClassInlining,
-          specification.disableUninstantiatedTypeOptimization, specification.hasMissingClasses);
+          compilerUnderTest,
+          fileNames,
+          resultDir.getCanonicalPath(),
+          compilationMode,
+          new CompilationOptions(specification));
       System.err.println("Should have failed R8/D8 compilation with an exception.");
       return;
     } else {
       executeCompilerUnderTest(
-          compilerUnderTest, fileNames, resultDir.getCanonicalPath(), compilationMode,
-          specification.disableInlining, specification.disableClassInlining,
-          specification.disableUninstantiatedTypeOptimization, specification.hasMissingClasses);
+          compilerUnderTest,
+          fileNames,
+          resultDir.getCanonicalPath(),
+          compilationMode,
+          new CompilationOptions(specification));
     }
 
     if (!specification.skipRun
diff --git a/src/test/java/com/android/tools/r8/TestParametersBuilder.java b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
index 8059f21..4cefe0c 100644
--- a/src/test/java/com/android/tools/r8/TestParametersBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
@@ -158,7 +158,7 @@
     return isSystemJdk(vm);
   }
 
-  private static List<CfVm> getAvailableCfVms() {
+  public static List<CfVm> getAvailableCfVms() {
     String cfVmsProperty = System.getProperty("cf_vms");
     if (cfVmsProperty != null) {
       return Arrays.stream(cfVmsProperty.split(":"))
@@ -174,7 +174,7 @@
     }
   }
 
-  private static List<DexVm> getAvailableDexVms() {
+  public static List<DexVm> getAvailableDexVms() {
     String dexVmsProperty = System.getProperty("dex_vms");
     if (dexVmsProperty != null) {
       return Arrays.stream(dexVmsProperty.split(":"))
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 7467bfa..1ab645d 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -704,10 +704,10 @@
     }
   }
 
-  public static List<String> getBootLibs() {
-    String prefix = getArtDir(getDexVm()) + "/";
+  public static List<String> getBootLibs(DexVm dexVm) {
+    String prefix = getArtDir(dexVm) + "/";
     List<String> result = new ArrayList<>();
-    BOOT_LIBS.get(getDexVm()).stream().forEach(x -> result.add(prefix + "framework/" + x));
+    BOOT_LIBS.get(dexVm).stream().forEach(x -> result.add(prefix + "framework/" + x));
     return result;
   }
 
diff --git a/tools/create_jctf_tests.py b/tools/create_jctf_tests.py
index 28dde99..bc065d9 100755
--- a/tools/create_jctf_tests.py
+++ b/tools/create_jctf_tests.py
@@ -129,7 +129,6 @@
     relative_package = package[idx + len(dot_java_dot):]
 
     generate_test(class_name, 'd8', 'R8_AFTER_D8', relative_package)
-    generate_test(class_name, 'r8', 'R8', relative_package)
     generate_test(class_name, 'r8cf', 'R8CF', relative_package)
 
 
diff --git a/tools/test.py b/tools/test.py
index 899337a..6f664eb 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -257,12 +257,13 @@
 
   # Now run tests on selected runtime(s).
   vms_to_test = [options.dex_vm] if options.dex_vm != "all" else ALL_ART_VMS
-  # TODO(126683699): remove once we have single run
-  if options.dex_vm == 'all' and options.only_jctf:
-    vms_to_test = ["default",  "5.1.1"]
 
   # The full set of VMs is configured in the first run, then set to empty below.
   dex_vms_property = ':'.join(vms_to_test)
+
+  if options.only_jctf:
+    vms_to_test = ['default']
+
   for art_vm in vms_to_test:
     vm_suffix = "_" + options.dex_vm_kind if art_vm != "default" else ""
     return_code = gradle.RunGradle(