diff --git a/.gitignore b/.gitignore
index 2ece82e3..86f3139 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,36 +22,24 @@
 third_party/android_jar/lib.tar.gz
 third_party/android_jar/lib-v[0-9][0-9]
 third_party/android_jar/lib-v[0-9][0-9].tar.gz
-third_party/gmscore/v4
-third_party/gmscore/v4.tar.gz
-third_party/gmscore/v5
-third_party/gmscore/v5.tar.gz
-third_party/gmscore/v6
-third_party/gmscore/v6.tar.gz
-third_party/gmscore/v7
-third_party/gmscore/v7.tar.gz
-third_party/gmscore/v8
-third_party/gmscore/v8.tar.gz
-third_party/gmscore/gmscore_v9
-third_party/gmscore/gmscore_v9.tar.gz
-third_party/gmscore/gmscore_v10
-third_party/gmscore/gmscore_v10.tar.gz
+third_party/gmail/*
+!third_party/gmail/*.sha1
+third_party/gmscore/*
+!third_party/gmscore/*.sha1
 third_party/gradle/gradle.tar.gz
 third_party/gradle/gradle
 third_party/jasmin.tar.gz
 third_party/jasmin
 third_party/jdwp-tests.tar.gz
 third_party/jdwp-tests
-third_party/proguard/proguard5.2.1.tar.gz
-third_party/proguard/proguard5.2.1
+third_party/photos/*
+!third_party/photos/*.sha1
+third_party/proguard/*
+!third_party/proguard/*.sha1
 third_party/proguardsettings.tar.gz
 third_party/proguardsettings/
-third_party/youtube/youtube.android_11.47
-third_party/youtube/youtube.android_11.47.tar.gz
-third_party/youtube/youtube.android_12.10
-third_party/youtube/youtube.android_12.10.tar.gz
-third_party/youtube/youtube.android_12.17/
-third_party/youtube/youtube.android_12.17.tar.gz
+third_party/youtube/*
+!third_party/youtube/*sha1
 third_party/jctf
 third_party/jctf.tar.gz
 third_party/android_cts_baseline
@@ -63,3 +51,4 @@
 #*#
 *~
 .#*
+
diff --git a/README.md b/README.md
index 9d93bc2..1bd795c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,83 @@
-The R8 repo contains two tools.
+# D8 dexer and R8 shrinker
 
-1. D8 is a dexer that converts java byte code to dex code.
+The R8 repo contains two tools:
 
-2. R8 is a java program shrinking and minification tool.
+- D8 is a dexer that converts java byte code to dex code.
+- R8 is a java program shrinking and minification tool that converts java byte
+  code to optimized dex code.
+
+D8 is a replacement for the DX dexer and R8 is a replacement for
+the [Proguard](https://www.guardsquare.com/en/proguard) shrinking and
+minification tool.
+
+## Downloading and building
+
+The R8 project uses [`depot_tools`](https://www.chromium.org/developers/how-tos/install-depot-tools)
+from the chromium project to manage dependencies. Install `depot_tools` and add it to
+your path before proceeding.
+
+The R8 project uses Java 8 language features and requires a Java 8 compiler
+and runtime system.
+
+Typical steps to download and build:
+
+
+    $ git clone https://r8.googlesource.com/r8
+    $ cd r8
+    $ tools/gradle.py d8 r8
+
+The `tools/gradle.py` script will bootstrap using depot_tools to download
+a version of gradle to use for building on the first run. This will produce
+two jar files: `build/libs/d8.jar` and `build/libs/r8.jar`.
+
+## Running D8
+
+The D8 dexer has a simple command-line interface with only a few options.
+
+The most important option is whether to build in debug or release mode.  Debug
+is the default mode and includes debugging information in the resulting dex
+files. Debugging information contains information about local variables used
+when debugging dex code. This information is not useful when shipping final
+Android apps to users and therefore, final builds should use the `--release`
+flag to remove this debugging information to produce smaller dex files.
+
+Typical invocations of D8 to produce dex file(s) in the out directoy:
+
+Debug mode build:
+
+    $ java -jar build/libs/d8.jar --output out input.jar
+
+Release mode build:
+
+    $ java -jar build/libs/d8.jar --release --output out input.jar
+
+The full set of D8 options can be obtained by running the command line tool with
+the `--help` option.
+
+## Running R8
+
+R8 is a [Proguard](https://www.guardsquare.com/en/proguard) replacement for
+whole-program optimization, shrinking and minification. R8 uses the Proguard
+keep rule format for specifying the entry points for an application.
+
+Typical invocations of R8 to produce optimized dex file(s) in the out directory:
+
+    $ java -jar build/libs/r8.jar --release --output out --pg-conf proguard.cfg input.jar
+
+The full set of R8 options can be obtained by running the command line tool with
+the `--help` option.
+
+## Testing
+
+Typical steps to run tests:
+
+    $ tools/test.py --no_internal
+
+The `tools/test.py` script will use depot_tools to download a lot of tests
+and test dependencies on the first run. This includes prebuilt version of the
+art runtime on which to validate the produced dex code.
+
+## Getting help
+
+For questions, bug reports and other issues reach out to us at
+r8-dev@googlegroups.com.
diff --git a/build.gradle b/build.gradle
index eb09333..d8402bc 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,7 +1,8 @@
 // Copyright (c) 2016, 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.
-import org.gradle.internal.os.OperatingSystem;
+import org.gradle.internal.os.OperatingSystem
+import utils.Utils;
 
 apply plugin: 'java'
 apply plugin: 'idea'
@@ -98,7 +99,8 @@
     examplesAndroidOCompile group: 'org.ow2.asm', name: 'asm', version: '5.1'
 }
 
-def osString = OperatingSystem.current().isLinux() ? "linux" : "mac"
+def osString = OperatingSystem.current().isLinux() ? "linux" :
+        OperatingSystem.current().isMacOsX() ? "mac" : "windows"
 
 def cloudDependencies = [
         "tests"      : [
@@ -107,6 +109,7 @@
         "third_party": [
                 "android_jar/lib-v14.tar.gz",
                 "android_jar/lib-v19.tar.gz",
+                "android_jar/lib-v21.tar.gz",
                 "android_jar/lib-v24.tar.gz",
                 "android_jar/lib-v25.tar.gz",
                 "android_jar/lib-v26.tar.gz",
@@ -136,14 +139,21 @@
             def sha1File = "${gzFile}.sha1"
             inputs.file sha1File
             outputs.file gzFile
-            executable "bash"
-            args "-c", "download_from_google_storage -n -b r8-deps -u -s ${sha1File}"
+            List<String> dlFromStorageArgs = ["-n", "-b", "r8-deps", "-u", "-s", "${sha1File}"]
+            if (OperatingSystem.current().isWindows()) {
+                executable "download_from_google_storage.bat"
+                args dlFromStorageArgs
+            } else {
+                executable "bash"
+                args "-c", "download_from_google_storage " + String.join(" ", dlFromStorageArgs)
+            }
         }
     }
 }
 
 def x20Dependencies = [
     "third_party": [
+        "gmail/gmail_android_170604.16.tar.gz",
         "gmscore/v4.tar.gz",
         "gmscore/v5.tar.gz",
         "gmscore/v6.tar.gz",
@@ -151,11 +161,13 @@
         "gmscore/v8.tar.gz",
         "gmscore/gmscore_v9.tar.gz",
         "gmscore/gmscore_v10.tar.gz",
+        "gmscore/latest.tar.gz",
         "photos/2017-06-06.tar.gz",
-        "youtube/youtube.android_11.47.tar.gz",
         "youtube/youtube.android_12.10.tar.gz",
         "youtube/youtube.android_12.17.tar.gz",
+        "youtube/youtube.android_12.22.tar.gz",
         "proguardsettings.tar.gz",
+        "proguard/proguard_internal_159423826.tar.gz",
     ],
 ]
 
@@ -370,7 +382,11 @@
     }
     task "dex_debuginfo_examples"(type: Exec,
             dependsOn: ["jar_debuginfo_examples", "downloadDeps"]) {
-        executable file("tools/linux/dx/bin/dx");
+        if (OperatingSystem.current().isWindows()) {
+            executable file("tools/windows/dx/bin/dx.bat")
+        } else {
+            executable file("tools/linux/dx/bin/dx");
+        }
         args "--dex"
         args "--output=build/test/${hostDexJar}"
         args "build/test/${hostJar}"
@@ -421,7 +437,12 @@
 task buildExampleJars {
     dependsOn downloadProguard
     def examplesDir = file("src/test/examples")
-    def proguardScript = "third_party/proguard/proguard5.2.1/bin/proguard.sh"
+    def proguardScript
+    if (OperatingSystem.current().isWindows()) {
+        proguardScript = "third_party/proguard/proguard5.2.1/bin/proguard.bat"
+    } else {
+        proguardScript = "third_party/proguard/proguard5.2.1/bin/proguard.sh"
+    }
     task "compile_examples"(type: JavaCompile) {
         source = fileTree(dir: examplesDir, include: '**/*.java')
         destinationDir = file("build/test/examples/classes")
@@ -453,11 +474,17 @@
                 // Enable these to get stdout and stderr redirected to files...
                 // standardOutput = new FileOutputStream('proguard.stdout')
                 // errorOutput = new FileOutputStream('proguard.stderr')
-                executable "bash"
-                args "-c", "${proguardScript} '-verbose -dontwarn java.** -injars ${jarPath}" +
+                def proguardArguments = "-verbose -dontwarn java.** -injars ${jarPath}" +
                         " -outjars ${proguardJarPath}" +
                         " -include ${proguardConfigPath}" +
-                        " -printmapping ${proguardMapPath}'"
+                        " -printmapping ${proguardMapPath}"
+                if (OperatingSystem.current().isWindows()) {
+                    executable "${proguardScript}"
+                    args "${proguardArguments}"
+                } else {
+                    executable "bash"
+                    args "-c", "${proguardScript} '${proguardArguments}'"
+                }
                 outputs.file proguardJarPath
             }
         } else {
@@ -560,11 +587,12 @@
 }
 
 task buildExamples {
-    if (OperatingSystem.current().isMacOsX()) {
-        logger.lifecycle("WARNING: Testing (including building examples) is only partially supported on Mac OS.")
+    if (OperatingSystem.current().isMacOsX() || OperatingSystem.current().isWindows()) {
+        logger.lifecycle("WARNING: Testing (including building examples) is only partially supported on your " +
+                "platform (" + OperatingSystem.current().getName() + ").")
     } else if (!OperatingSystem.current().isLinux()) {
       logger.lifecycle("WARNING: Testing (including building examples) is not supported on your platform. " +
-          "It is fully supported on Linux and partially supported on Mac OS")
+          "It is fully supported on Linux and partially supported on Mac OS and Windows")
       return;
     }
     dependsOn buildDebugTestResourcesJars
@@ -659,6 +687,9 @@
     forkEvery = 0
     // Use the Concurrent Mark Sweep GC (CMS) to keep memory usage at a resonable level.
     jvmArgs = ["-XX:+UseConcMarkSweepGC"]
+    if (project.hasProperty('disable_assertions')) {
+        enableAssertions = false
+    }
 }
 
 task buildPreNJdwpTestsJar(type: Jar) {
@@ -725,12 +756,18 @@
         systemProperty 'jctf_compile_only', '1'
     }
 
-    if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {
+    if (OperatingSystem.current().isLinux()
+            || OperatingSystem.current().isMacOsX()
+            || OperatingSystem.current().isWindows()) {
         if (OperatingSystem.current().isMacOsX()) {
             logger.lifecycle("WARNING: Testing in only partially supported on Mac OS. " +
                 "Art only runs on Linux and tests requiring Art runs in a Docker container, which must be present. " +
                 "See tools/docker/README.md for details.")
         }
+        if (OperatingSystem.current().isWindows()) {
+            logger.lifecycle("WARNING: Testing in only partially supported on Windows. " +
+                    "Art only runs on Linux and tests requiring Art will be skipped")
+        }
         dependsOn downloadDeps
         dependsOn buildExamples
         dependsOn buildSmali
@@ -740,7 +777,7 @@
         dependsOn buildPreNJdwpTestsJar
     } else {
         logger.lifecycle("WARNING: Testing in not supported on your platform. Testing is only fully supported on " +
-            "Linux and partially supported on Mac OS. Art does not run on other platforms.")
+            "Linux and partially supported on Mac OS and Windows. Art does not run on other platforms.")
     }
 }
 
@@ -953,7 +990,7 @@
     def artTestDir = file("${androidCheckoutDir}/art/test")
     def artRunTestScript = file("${artTestDir}/run-test")
     def dxExecutable = new File("tools/linux/dx/bin/dx");
-    def dexMergerExecutable = new File("tools/linux/dx/bin/dexmerger");
+    def dexMergerExecutable = Utils.dexMergerExecutable()
     def dexToolName = dexTool == DexTool.DX ? "dx" : "jack"
 
     def name = dir.getName();
diff --git a/buildSrc/src/main/java/dx/DexMerger.java b/buildSrc/src/main/java/dx/DexMerger.java
index 39a4bfb..d3d8427 100644
--- a/buildSrc/src/main/java/dx/DexMerger.java
+++ b/buildSrc/src/main/java/dx/DexMerger.java
@@ -53,7 +53,7 @@
       public void execute(ExecSpec execSpec) {
         try {
           if (dexMergerExecutable == null) {
-            dexMergerExecutable = new File("tools/" + Utils.toolsDir() + "/dx/bin/dexmerger");
+            dexMergerExecutable = Utils.dexMergerExecutable();
           }
           execSpec.setExecutable(dexMergerExecutable);
           execSpec.args(destination.getCanonicalPath());
diff --git a/buildSrc/src/main/java/dx/Dx.java b/buildSrc/src/main/java/dx/Dx.java
index e4b89c4..86d1bce 100644
--- a/buildSrc/src/main/java/dx/Dx.java
+++ b/buildSrc/src/main/java/dx/Dx.java
@@ -64,7 +64,8 @@
       public void execute(ExecSpec execSpec) {
         try {
           if (dxExecutable == null) {
-            dxExecutable = new File("tools/" + Utils.toolsDir() + "/dx/bin/dx");
+            String dxExecutableName = Utils.toolsDir().equals("windows") ? "dx.bat" : "dx";
+            dxExecutable = new File("tools/" + Utils.toolsDir() + "/dx/bin/" + dxExecutableName);
           }
           execSpec.setExecutable(dxExecutable);
           execSpec.args("--dex");
diff --git a/buildSrc/src/main/java/utils/Utils.java b/buildSrc/src/main/java/utils/Utils.java
index 5e5e9d7..7158e80 100644
--- a/buildSrc/src/main/java/utils/Utils.java
+++ b/buildSrc/src/main/java/utils/Utils.java
@@ -3,8 +3,22 @@
 // BSD-style license that can be found in the LICENSE file.
 package utils;
 
+import java.io.File;
+
 public class Utils {
   public static String toolsDir() {
-    return System.getProperty("os.name").equals("Mac OS X") ? "mac" : "linux";
+    String osName = System.getProperty("os.name");
+    if (osName.equals("Mac OS X")) {
+      return "mac";
+    } else if (osName.contains("Windows")) {
+      return "windows";
+    } else {
+      return "linux";
+    }
   }
-}
+
+  public static File dexMergerExecutable() {
+    String executableName = Utils.toolsDir().equals("windows") ? "dexmerger.bat" : "dexmerger";
+    return new File("tools/" + Utils.toolsDir() + "/dx/bin/" + executableName);
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/com/android/tools/r8/BaseCommand.java b/src/main/java/com/android/tools/r8/BaseCommand.java
index 3497778..85c430a 100644
--- a/src/main/java/com/android/tools/r8/BaseCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCommand.java
@@ -5,13 +5,12 @@
 
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.OutputMode;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
-import java.util.List;
 
 abstract class BaseCommand {
 
@@ -147,7 +146,7 @@
     }
 
     /** Add library file resources. */
-    public B addLibraryFiles(List<Path> files) throws IOException {
+    public B addLibraryFiles(Collection<Path> files) throws IOException {
       app.addLibraryFiles(files);
       return self();
     }
diff --git a/src/main/java/com/android/tools/r8/BaseOutput.java b/src/main/java/com/android/tools/r8/BaseOutput.java
index cb4d473..a1fbb8e 100644
--- a/src/main/java/com/android/tools/r8/BaseOutput.java
+++ b/src/main/java/com/android/tools/r8/BaseOutput.java
@@ -49,6 +49,7 @@
    * Write the output resources to a zip-archive or directory.
    *
    * @param output Path to existing directory or non-existing zip-archive.
+   * @param overwrite true to allow overwriting existing files with outputs.
    */
-  abstract public void write(Path output) throws IOException;
+  abstract public void write(Path output, boolean overwrite) throws IOException;
 }
diff --git a/src/main/java/com/android/tools/r8/ClassFileResourceProvider.java b/src/main/java/com/android/tools/r8/ClassFileResourceProvider.java
new file mode 100644
index 0000000..7dbb420
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ClassFileResourceProvider.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2017, 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 java.util.Set;
+
+/**
+ * Represents a provider for application resources of class file kind.
+ *
+ * Note that the classes will only be created for resources provided by
+ * resource providers on-demand when they are needed by the tool. If
+ * never needed, the resource will never be loaded.
+ */
+public interface ClassFileResourceProvider {
+  /** Returns all class descriptors. */
+  Set<String> getClassDescriptors();
+
+  /**
+   * Get the class resource associated with the descriptor, or null if
+   * this provider does not have one.
+   *
+   * Method may be called several times for the same resource, and should
+   * support concurrent calls from different threads.
+   */
+  Resource getResource(String descriptor);
+}
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 0a0c976..522f6f0 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -7,6 +7,7 @@
 
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.dex.ApplicationWriter;
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.ir.conversion.IRConverter;
@@ -59,11 +60,12 @@
    * @return the compilation result.
    */
   public static D8Output run(D8Command command) throws IOException {
-    CompilationResult result = runForTesting(command.getInputApp(), command.getInternalOptions());
+    InternalOptions options = command.getInternalOptions();
+    CompilationResult result = runForTesting(command.getInputApp(), options);
     assert result != null;
     D8Output output = new D8Output(result.androidApp, command.getOutputMode());
     if (command.getOutputPath() != null) {
-      output.write(command.getOutputPath());
+      output.write(command.getOutputPath(), options.overwriteOutputs);
     }
     return output;
   }
@@ -79,12 +81,13 @@
    * @return the compilation result.
    */
   public static D8Output run(D8Command command, ExecutorService executor) throws IOException {
+    InternalOptions options = command.getInternalOptions();
     CompilationResult result = runForTesting(
-        command.getInputApp(), command.getInternalOptions(), executor);
+        command.getInputApp(), options, executor);
     assert result != null;
     D8Output output = new D8Output(result.androidApp, command.getOutputMode());
     if (command.getOutputPath() != null) {
-      output.write(command.getOutputPath());
+      output.write(command.getOutputPath(), options.overwriteOutputs);
     }
     return output;
   }
@@ -162,7 +165,7 @@
       app = optimize(app, appInfo, options);
 
       // If a method filter is present don't produce output since the application is likely partial.
-      if (!options.methodsFilter.isEmpty()) {
+      if (options.hasMethodsFilter()) {
         System.out.println("Finished compilation with method filter: ");
         options.methodsFilter.forEach((m) -> System.out.println("  - " + m));
         return null;
@@ -178,13 +181,17 @@
       options.printWarnings();
       return output;
     } catch (ExecutionException e) {
-      throw new RuntimeException(e.getMessage(), e.getCause());
+      if (e.getCause() instanceof CompilationError) {
+        throw (CompilationError) e.getCause();
+      } else {
+        throw new RuntimeException(e.getMessage(), e.getCause());
+      }
     }
   }
 
   private static DexApplication optimize(
       DexApplication application, AppInfo appInfo, InternalOptions options)
-      throws IOException, ExecutionException {
+      throws IOException {
     final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
 
     IRConverter converter = new IRConverter(application, appInfo, options, printer);
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 0ad793c..62cb5a5 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -3,15 +3,20 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static com.android.tools.r8.utils.FileUtils.isArchive;
+
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
 import com.android.tools.r8.utils.OutputMode;
+import com.android.tools.r8.utils.PreloadedClassFileProvider;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
 
 /**
  * Immutable command structure for an invocation of the {@code D8} compiler.
@@ -39,12 +44,46 @@
       super(app, CompilationMode.DEBUG);
     }
 
-    public Builder addClasspathResourceProvider(ResourceProvider provider) {
+    /** Add classpath file resources. */
+    public Builder addClasspathFiles(Path... files) throws IOException {
+      return addClasspathFiles(Arrays.asList(files));
+    }
+
+    /** Add classpath file resources. */
+    public Builder addClasspathFiles(Collection<Path> files) throws IOException {
+      for (Path file : files) {
+        if (isArchive(file)) {
+          addClasspathResourceProvider(PreloadedClassFileProvider.fromArchive(file));
+        } else {
+          super.addClasspathFiles(file);
+        }
+      }
+      return this;
+    }
+
+    /** Add library file resources. */
+    public Builder addLibraryFiles(Path... files) throws IOException {
+      return addLibraryFiles(Arrays.asList(files));
+    }
+
+    /** Add library file resources. */
+    public Builder addLibraryFiles(Collection<Path> files) throws IOException {
+      for (Path file : files) {
+        if (isArchive(file)) {
+          addLibraryResourceProvider(PreloadedClassFileProvider.fromArchive(file));
+        } else {
+          super.addLibraryFiles(file);
+        }
+      }
+      return this;
+    }
+
+    public Builder addClasspathResourceProvider(ClassFileResourceProvider provider) {
       getAppBuilder().addClasspathResourceProvider(provider);
       return this;
     }
 
-    public Builder addLibraryResourceProvider(ResourceProvider provider) {
+    public Builder addLibraryResourceProvider(ClassFileResourceProvider provider) {
       getAppBuilder().addLibraryResourceProvider(provider);
       return this;
     }
@@ -155,7 +194,7 @@
     assert !internal.debug;
     internal.debug = getMode() == CompilationMode.DEBUG;
     internal.minApiLevel = getMinApiLevel();
-    internal.fillDexFiles = true;
+    internal.overwriteOutputs = true;
     // Assert and fixup defaults.
     assert !internal.skipMinification;
     internal.skipMinification = true;
@@ -171,8 +210,6 @@
     internal.removeSwitchMaps = false;
     assert internal.outline.enabled;
     internal.outline.enabled = false;
-    internal.lazyClasspathLoading = true;
-    internal.lazyLibraryLoading = true;
     internal.outputMode = getOutputMode();
     return internal;
   }
diff --git a/src/main/java/com/android/tools/r8/D8Output.java b/src/main/java/com/android/tools/r8/D8Output.java
index 1910e9b..4ba7067 100644
--- a/src/main/java/com/android/tools/r8/D8Output.java
+++ b/src/main/java/com/android/tools/r8/D8Output.java
@@ -16,7 +16,7 @@
   }
 
   @Override
-  public void write(Path output) throws IOException {
-    getAndroidApp().write(output, getOutputMode());
+  public void write(Path output, boolean overwrite) throws IOException {
+    getAndroidApp().write(output, getOutputMode(), overwrite);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/Disassemble.java b/src/main/java/com/android/tools/r8/Disassemble.java
index 71daa5c..b183ecc 100644
--- a/src/main/java/com/android/tools/r8/Disassemble.java
+++ b/src/main/java/com/android/tools/r8/Disassemble.java
@@ -4,19 +4,145 @@
 package com.android.tools.r8;
 
 import com.android.tools.r8.shaking.ProguardRuleParserException;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.OutputMode;
+import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.List;
 import java.util.concurrent.ExecutionException;
-import java.util.stream.Collectors;
 
 public class Disassemble {
+  public static class DisassembleCommand extends BaseCommand {
+
+    public static class Builder
+        extends BaseCommand.Builder<DisassembleCommand, DisassembleCommand.Builder> {
+      private boolean useSmali = false;
+
+      private Builder() {
+        super(CompilationMode.RELEASE);
+      }
+
+      @Override
+      DisassembleCommand.Builder self() {
+        return this;
+      }
+
+      public DisassembleCommand.Builder setProguardMapFile(Path path) {
+        getAppBuilder().setProguardMapFile(path);
+        return this;
+      }
+
+      public DisassembleCommand.Builder setUseSmali(boolean useSmali) {
+        this.useSmali = useSmali;
+        return this;
+      }
+
+      @Override
+      public DisassembleCommand build() throws CompilationException, IOException {
+        // If printing versions ignore everything else.
+        if (isPrintHelp() || isPrintVersion()) {
+          return new DisassembleCommand(isPrintHelp(), isPrintVersion());
+        }
+
+        return new DisassembleCommand(
+            getAppBuilder().build(),
+            getOutputPath(),
+            getOutputMode(),
+            getMode(),
+            getMinApiLevel(),
+            useSmali);
+      }
+    }
+
+    static final String USAGE_MESSAGE = String.join("\n", ImmutableList.of(
+        "Usage: disasm [options] <input-files>",
+        " where <input-files> are dex files",
+        " and options are:",
+        "  --smali                 # Disassemble using smali syntax.",
+        "  --pg-map <file>         # Proguard map <file> for mapping names.",
+        "  --version               # Print the version of r8.",
+        "  --help                  # Print this message."));
+
+
+    private final boolean useSmali;
+
+    public static DisassembleCommand.Builder builder() {
+      return new DisassembleCommand.Builder();
+    }
+
+    public static DisassembleCommand.Builder parse(String[] args)
+        throws CompilationException, IOException {
+      DisassembleCommand.Builder builder = builder();
+      parse(args, builder);
+      return builder;
+    }
+
+    private static void parse(String[] args, DisassembleCommand.Builder builder)
+        throws CompilationException, IOException {
+      for (int i = 0; i < args.length; i++) {
+        String arg = args[i].trim();
+        if (arg.length() == 0) {
+          continue;
+        } else if (arg.equals("--help")) {
+          builder.setPrintHelp(true);
+        } else if (arg.equals("--version")) {
+          builder.setPrintVersion(true);
+        } else if (arg.equals("--smali")) {
+          builder.setUseSmali(true);
+        } else if (arg.equals("--pg-map")) {
+          builder.setProguardMapFile(Paths.get(args[++i]));
+        } else {
+          if (arg.startsWith("--")) {
+            throw new CompilationException("Unknown option: " + arg);
+          }
+          builder.addProgramFiles(Paths.get(arg));
+        }
+      }
+    }
+
+    private DisassembleCommand(
+        AndroidApp inputApp,
+        Path outputPath,
+        OutputMode outputMode,
+        CompilationMode mode,
+        int minApiLevel,
+        boolean useSmali) {
+      super(inputApp, outputPath, outputMode, mode, minApiLevel);
+      //assert getOutputMode() == OutputMode.Indexed : "Only regular mode is supported in R8";
+      this.useSmali = useSmali;
+    }
+
+    private DisassembleCommand(boolean printHelp, boolean printVersion) {
+      super(printHelp, printVersion);
+      this.useSmali = false;
+    }
+
+    public boolean useSmali() {
+      return useSmali;
+    }
+
+    @Override
+    InternalOptions getInternalOptions() {
+      InternalOptions internal = new InternalOptions();
+      internal.useSmaliSyntax = useSmali;
+      return internal;
+    }
+  }
+
   public static void main(String[] args)
       throws IOException, ProguardRuleParserException, CompilationException, ExecutionException {
-    List<Path> files = Arrays.stream(args).map(s -> Paths.get(s)).collect(Collectors.toList());
-    R8Command command = R8Command.builder().addProgramFiles(files).build();
+    DisassembleCommand.Builder builder = DisassembleCommand.parse(args);
+    DisassembleCommand command = builder.build();
+    if (command.isPrintHelp()) {
+      System.out.println(DisassembleCommand.USAGE_MESSAGE);
+      return;
+    }
+    if (command.isPrintVersion()) {
+      System.out.println("R8 v0.0.1");
+      return;
+    }
     R8.disassemble(command);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 390e752..11cc9bc 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -39,14 +39,12 @@
 import com.android.tools.r8.utils.CfgPrinter;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.AttributeRemovalOptions;
-import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.PackageDistribution;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Closer;
 import java.io.ByteArrayOutputStream;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
@@ -55,6 +53,7 @@
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
@@ -145,7 +144,8 @@
     return result;
   }
 
-  public static void disassemble(R8Command command) throws IOException, ExecutionException {
+  public static void disassemble(Disassemble.DisassembleCommand command)
+      throws IOException, ExecutionException {
     Path output = command.getOutputPath();
     AndroidApp app = command.getInputApp();
     InternalOptions options = command.getInternalOptions();
@@ -172,7 +172,7 @@
   }
 
   static CompilationResult runForTesting(AndroidApp app, InternalOptions options)
-      throws ProguardRuleParserException, ExecutionException, IOException {
+      throws ProguardRuleParserException, IOException {
     ExecutorService executor = ThreadUtils.getExecutorService(options);
     try {
       return runForTesting(app, options, executor);
@@ -185,12 +185,12 @@
       AndroidApp app,
       InternalOptions options,
       ExecutorService executor)
-      throws ProguardRuleParserException, ExecutionException, IOException {
+      throws ProguardRuleParserException, IOException {
     return new R8(options).run(app, executor);
   }
 
   private CompilationResult run(AndroidApp inputApp, ExecutorService executorService)
-      throws IOException, ExecutionException, ProguardRuleParserException {
+      throws IOException, ProguardRuleParserException {
     if (options.quiet) {
       System.setOut(new PrintStream(ByteStreams.nullOutputStream()));
     }
@@ -207,7 +207,6 @@
       RootSet rootSet;
       byte[] proguardSeedsData = null;
       timing.begin("Strip unused code");
-      Set<DexType> mainDexBaseClasses = null;
       try {
         Set<DexType> missingClasses = appInfo.getMissingClasses();
         missingClasses = filterMissingClasses(missingClasses, options.dontWarnPatterns);
@@ -281,7 +280,7 @@
         // Lets find classes which may have code executed before secondary dex files installation.
         RootSet mainDexRootSet =
             new RootSetBuilder(application, appInfo, options.mainDexKeepRules).run(executorService);
-        mainDexBaseClasses = enqueuer.traceMainDex(mainDexRootSet, timing);
+        Set<DexType> mainDexBaseClasses = enqueuer.traceMainDex(mainDexRootSet, timing);
 
         // Calculate the automatic main dex list according to legacy multidex constraints.
         // Add those classes to an eventual manual list of classes.
@@ -324,7 +323,7 @@
       timing.end();
 
       // If a method filter is present don't produce output since the application is likely partial.
-      if (!options.methodsFilter.isEmpty()) {
+      if (options.hasMethodsFilter()) {
         System.out.println("Finished compilation with method filter: ");
         options.methodsFilter.forEach((m) -> System.out.println("  - " + m));
         return null;
@@ -348,21 +347,14 @@
               packageDistribution,
               options);
 
-      if (options.printMapping && androidApp.hasProguardMap() && !options.skipMinification) {
-        Path mapOutput = options.printMappingFile;
-        try (Closer closer = Closer.create()) {
-          OutputStream mapOut;
-          if (mapOutput == null) {
-            mapOut = System.out;
-          } else {
-            mapOut = new FileOutputStream(mapOutput.toFile());
-            closer.register(mapOut);
-          }
-          androidApp.writeProguardMap(closer, mapOut);
-        }
-      }
       options.printWarnings();
       return new CompilationResult(androidApp, application, appInfo);
+    } catch (ExecutionException e) {
+      if (e.getCause() instanceof CompilationError) {
+        throw (CompilationError) e.getCause();
+      } else {
+        throw new RuntimeException(e.getMessage(), e.getCause());
+      }
     } finally {
       // Dump timings.
       if (options.printTimes) {
@@ -381,13 +373,66 @@
    * @return the compilation result.
    */
   public static AndroidApp run(R8Command command)
-      throws IOException, CompilationException, ExecutionException, ProguardRuleParserException {
-    AndroidApp outputApp =
-        runForTesting(command.getInputApp(), command.getInternalOptions()).androidApp;
-    if (command.getOutputPath() != null) {
-      outputApp.write(command.getOutputPath(), OutputMode.Indexed);
+      throws IOException, CompilationException, ProguardRuleParserException {
+    ExecutorService executorService = ThreadUtils.getExecutorService(command.getInternalOptions());
+    try {
+      return run(command, executorService);
+    } finally {
+      executorService.shutdown();
     }
-    return outputApp;
+  }
+
+  static void writeOutputs(R8Command command, InternalOptions options, AndroidApp outputApp)
+      throws IOException {
+    if (command.getOutputPath() != null) {
+      outputApp.write(command.getOutputPath(), options.outputMode, options.overwriteOutputs);
+    }
+
+    if (options.printMapping && !options.skipMinification) {
+      assert outputApp.hasProguardMap();
+      try (Closer closer = Closer.create()) {
+        OutputStream mapOut = openPathWithDefault(
+            closer,
+            options.printMappingFile,
+            options.overwriteOutputs,
+            System.out);
+        outputApp.writeProguardMap(closer, mapOut);
+      }
+    }
+    if (options.printSeeds) {
+      assert outputApp.hasProguardSeeds();
+      try (Closer closer = Closer.create()) {
+        OutputStream seedsOut =
+            openPathWithDefault(closer, options.seedsFile, options.overwriteOutputs, System.out);
+        outputApp.writeProguardSeeds(closer, seedsOut);
+      }
+    }
+    if (options.printMainDexList && outputApp.hasMainDexList()) {
+      try (Closer closer = Closer.create()) {
+        OutputStream mainDexOut =
+            openPathWithDefault(closer, options.printMainDexListFile, true, System.out);
+        outputApp.writeMainDexList(closer, mainDexOut);
+      }
+    }
+  }
+
+  private static OutputStream openPathWithDefault(Closer closer,
+      Path file,
+      boolean allowOverwrite,
+      PrintStream defaultOutput) throws IOException {
+    OutputStream mapOut;
+    if (file == null) {
+      mapOut = defaultOutput;
+    } else {
+      if (!allowOverwrite) {
+        mapOut = Files.newOutputStream(file, StandardOpenOption.CREATE_NEW);
+      } else {
+        mapOut = Files.newOutputStream(file,
+            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+      }
+      closer.register(mapOut);
+    }
+    return mapOut;
   }
 
   /**
@@ -401,17 +446,16 @@
    * @return the compilation result.
    */
   public static AndroidApp run(R8Command command, ExecutorService executor)
-      throws IOException, CompilationException, ExecutionException, ProguardRuleParserException {
+      throws IOException, CompilationException, ProguardRuleParserException {
+    InternalOptions options = command.getInternalOptions();
     AndroidApp outputApp =
-        runForTesting(command.getInputApp(), command.getInternalOptions(), executor).androidApp;
-    if (command.getOutputPath() != null) {
-      outputApp.write(command.getOutputPath(), OutputMode.Indexed);
-    }
+        runForTesting(command.getInputApp(), options, executor).androidApp;
+    writeOutputs(command, options, outputApp);
     return outputApp;
   }
 
   private static void run(String[] args)
-      throws ExecutionException, IOException, ProguardRuleParserException, CompilationException {
+      throws IOException, ProguardRuleParserException, CompilationException {
     R8Command.Builder builder = R8Command.parse(args);
     if (builder.getOutputPath() == null) {
       builder.setOutputPath(Paths.get("."));
@@ -442,7 +486,7 @@
     } catch (ProguardRuleParserException e) {
       System.err.println("Failed parsing proguard keep rules: " + e.getMessage());
       System.exit(1);
-    } catch (RuntimeException | ExecutionException e) {
+    } catch (RuntimeException e) {
       System.err.println("Compilation failed with an internal error.");
       Throwable cause = e.getCause() == null ? e : e.getCause();
       cause.printStackTrace();
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 9b44546..06ebe60 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -26,6 +26,7 @@
   public static class Builder extends BaseCommand.Builder<R8Command, Builder> {
 
     private final List<Path> mainDexRules = new ArrayList<>();
+    private boolean minimalMainDex = false;
     private final List<Path> proguardConfigFiles = new ArrayList<>();
     private Optional<Boolean> treeShaking = Optional.empty();
     private Optional<Boolean> minification = Optional.empty();
@@ -77,6 +78,16 @@
     }
 
     /**
+     * Request minimal main dex generated when main dex rules are used.
+     *
+     * The main purpose of this is to verify that the main dex rules are sufficient
+     * for running on a platform without native multi dex support.
+     */
+    public Builder setMinimalMainDex(boolean value) {
+      minimalMainDex = value;
+      return this;
+    }
+    /**
      * Add proguard configuration file resources.
      */
     public Builder addProguardConfigurationFiles(Path... paths) {
@@ -161,6 +172,7 @@
           getOutputPath(),
           getOutputMode(),
           mainDexKeepRules,
+          minimalMainDex,
           configuration,
           getMode(),
           getMinApiLevel(),
@@ -196,6 +208,7 @@
       "  --help                  # Print this message."));
 
   private final ImmutableList<ProguardConfigurationRule> mainDexKeepRules;
+  private final boolean minimalMainDex;
   private final ProguardConfiguration proguardConfiguration;
   private final boolean useTreeShaking;
   private final boolean useMinification;
@@ -259,6 +272,8 @@
         builder.setMinification(false);
       } else if (arg.equals("--multidex-rules")) {
         builder.addMainDexRules(Paths.get(args[++i]));
+      } else if (arg.equals("--minimal-maindex")) {
+        builder.setMinimalMainDex(true);
       } else if (arg.equals("--pg-conf")) {
         builder.addProguardConfigurationFiles(Paths.get(args[++i]));
       } else if (arg.equals("--pg-map")) {
@@ -300,6 +315,7 @@
       Path outputPath,
       OutputMode outputMode,
       ImmutableList<ProguardConfigurationRule> mainDexKeepRules,
+      boolean minimalMainDex,
       ProguardConfiguration proguardConfiguration,
       CompilationMode mode,
       int minApiLevel,
@@ -311,6 +327,7 @@
     assert mainDexKeepRules != null;
     assert getOutputMode() == OutputMode.Indexed : "Only regular mode is supported in R8";
     this.mainDexKeepRules = mainDexKeepRules;
+    this.minimalMainDex = minimalMainDex;
     this.proguardConfiguration = proguardConfiguration;
     this.useTreeShaking = useTreeShaking;
     this.useMinification = useMinification;
@@ -320,6 +337,7 @@
   private R8Command(boolean printHelp, boolean printVersion) {
     super(printHelp, printVersion);
     mainDexKeepRules = ImmutableList.of();
+    minimalMainDex = false;
     proguardConfiguration = null;
     useTreeShaking = false;
     useMinification = false;
@@ -346,6 +364,7 @@
     internal.useTreeShaking = useTreeShaking();
     assert !internal.ignoreMissingClasses;
     internal.ignoreMissingClasses = ignoreMissingClasses;
+    internal.overwriteOutputs = true;
 
     // TODO(zerny): Consider which other proguard options should be given flags.
     assert internal.packagePrefix.length() == 0;
@@ -375,6 +394,7 @@
     internal.classObfuscationDictionary = proguardConfiguration.getClassObfuscationDictionary();
     internal.obfuscationDictionary = proguardConfiguration.getObfuscationDictionary();
     internal.mainDexKeepRules = mainDexKeepRules;
+    internal.minimalMainDex = minimalMainDex;
     internal.keepRules = proguardConfiguration.getRules();
     internal.dontWarnPatterns = proguardConfiguration.getDontWarnPatterns();
     internal.outputMode = getOutputMode();
diff --git a/src/main/java/com/android/tools/r8/ReadMainDexList.java b/src/main/java/com/android/tools/r8/ReadMainDexList.java
new file mode 100644
index 0000000..3a76c1f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ReadMainDexList.java
@@ -0,0 +1,58 @@
+// Copyright (c) 2017, 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.naming.ClassNameMapper;
+import com.android.tools.r8.naming.ProguardMapReader;
+import com.android.tools.r8.utils.FileUtils;
+import java.nio.file.Paths;
+import java.util.stream.Collectors;
+
+/**
+ * Utility for applying proguard map and sorting the main dex list.
+ */
+public class ReadMainDexList {
+
+  private String DOT_CLASS = ".class";
+
+  private String stripDotClass(String name) {
+    return name.endsWith(DOT_CLASS) ? name.substring(0, name.length() - DOT_CLASS.length()) : name;
+  }
+
+  private String addDotClass(String name) {
+    return name + DOT_CLASS;
+  }
+
+  private String deobfuscateClassName(String name, ClassNameMapper mapper) {
+    if (mapper == null) {
+      return name;
+    }
+    return mapper.deobfuscateClassName(name);
+  }
+
+  private void run(String[] args) throws Exception {
+    if (args.length != 1 && args.length != 2) {
+      System.out.println("Usage: command <main_dex_list> [<proguard_map>]");
+      System.exit(0);
+    }
+
+    final ClassNameMapper mapper =
+        args.length == 2 ? ProguardMapReader.mapperFromFile(Paths.get(args[1])) : null;
+
+    FileUtils.readTextFile(Paths.get(args[0]))
+        .stream()
+        .map(this::stripDotClass)
+        .map(name -> name.replace('/', '.'))
+        .map(name -> deobfuscateClassName(name, mapper))
+        .map(name -> name.replace('.', '/'))
+        .map(this::addDotClass)
+        .sorted()
+        .collect(Collectors.toList())
+        .forEach(System.out::println);
+  }
+
+  public static void main(String[] args) throws Exception {
+    new ReadMainDexList().run(args);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ResourceProvider.java b/src/main/java/com/android/tools/r8/ResourceProvider.java
deleted file mode 100644
index 2a5b0dc..0000000
--- a/src/main/java/com/android/tools/r8/ResourceProvider.java
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) 2017, 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;
-
-/**
- * Represents a provider for application resources. All resources returned
- * via this provider should be class file resources and will be loaded on-demand
- * or not loaded at all.
- *
- * NOTE: currently only resources representing Java class files can be loaded
- * with lazy resource providers.
- */
-public interface ResourceProvider {
-  /** Get the class resource associated with the descriptor, or null. */
-  Resource getResource(String descriptor);
-}
diff --git a/src/main/java/com/android/tools/r8/bisect/BisectState.java b/src/main/java/com/android/tools/r8/bisect/BisectState.java
index 945578a..148c167 100644
--- a/src/main/java/com/android/tools/r8/bisect/BisectState.java
+++ b/src/main/java/com/android/tools/r8/bisect/BisectState.java
@@ -8,8 +8,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexApplication.Builder;
-import com.android.tools.r8.graph.DexClassPromise;
-import com.android.tools.r8.graph.DexLibraryClass;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.NamingLens;
@@ -24,7 +22,6 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -261,23 +258,20 @@
     System.out.println("Next bisection range: " + nextRange);
     int goodClasses = 0;
     int badClasses = 0;
-    Map<DexType, DexClassPromise> classes = new HashMap<>();
-    for (DexLibraryClass clazz : badApp.libraryClasses()) {
-      classes.put(clazz.type, clazz);
-    }
+    List<DexProgramClass> programClasses = new ArrayList<>();
     for (DexProgramClass clazz : badApp.classes()) {
       DexProgramClass goodClass = getGoodClass(clazz);
       if (goodClass != null) {
-        classes.put(goodClass.type, goodClass);
+        programClasses.add(goodClass);
         ++goodClasses;
       } else {
-        classes.put(clazz.type, clazz);
+        programClasses.add(clazz);
         assert !nextRange.isEmpty();
         ++badClasses;
       }
     }
     System.out.println("Class split is good: " + goodClasses + ", bad: " + badClasses);
-    return new Builder(badApp, classes).build();
+    return new Builder(badApp).replaceProgramClasses(programClasses).build();
   }
 
   private DexProgramClass getGoodClass(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
index c174a31..4a499ec 100644
--- a/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
+++ b/src/main/java/com/android/tools/r8/compatdx/CompatDx.java
@@ -484,7 +484,7 @@
       }
       writeZipWithClasses(inputs, result, output);
     } else {
-      result.write(output);
+      result.write(output, true);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index af6bebe..c7a66c2 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -8,22 +8,29 @@
 import static com.android.tools.r8.dex.Constants.ANDROID_O_API;
 import static com.android.tools.r8.dex.Constants.ANDROID_O_DEX_VERSION;
 import static com.android.tools.r8.dex.Constants.DEFAULT_ANDROID_API;
+import static com.android.tools.r8.graph.ClassKind.CLASSPATH;
+import static com.android.tools.r8.graph.ClassKind.LIBRARY;
+import static com.android.tools.r8.graph.ClassKind.PROGRAM;
 import static com.android.tools.r8.utils.FileUtils.DEFAULT_DEX_FILENAME;
 
+import com.android.tools.r8.ClassFileResourceProvider;
 import com.android.tools.r8.Resource;
-import com.android.tools.r8.ResourceProvider;
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.ClassKind;
 import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClasspathClass;
 import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexLibraryClass;
+import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.JarApplicationReader;
 import com.android.tools.r8.graph.JarClassFileReader;
-import com.android.tools.r8.graph.LazyClassFileLoader;
 import com.android.tools.r8.naming.ProguardMapReader;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.ClassProvider;
+import com.android.tools.r8.utils.ClasspathClassCollection;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.LazyClassCollection;
+import com.android.tools.r8.utils.LibraryClassCollection;
 import com.android.tools.r8.utils.MainDexList;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -32,7 +39,8 @@
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -67,107 +75,25 @@
     final DexApplication.Builder builder = new DexApplication.Builder(itemFactory, timing);
     try (Closer closer = Closer.create()) {
       List<Future<?>> futures = new ArrayList<>();
+      // Still preload some of the classes, primarily for two reasons:
+      // (a) class lazy loading is not supported for DEX files
+      //     now and current implementation of parallel DEX file
+      //     loading will be lost with on-demand class loading.
+      // (b) some of the class file resources don't provide information
+      //     about class descriptor.
+      // TODO: try and preload less classes.
       readProguardMap(builder, executorService, futures, closer);
       readMainDexList(builder, executorService, futures, closer);
-      readDexSources(builder, executorService, futures, closer);
-      readClassSources(builder, closer);
-      initializeLazyClassCollection(builder);
+      ClassReader classReader = new ClassReader(executorService, futures, closer);
+      classReader.readSources();
       ThreadUtils.awaitFutures(futures);
-    } catch (ExecutionException e) {
-      // If the reading failed with a valid compilation error, rethrow the unwrapped exception.
-      Throwable cause = e.getCause();
-      if (cause != null && cause instanceof CompilationError) {
-        throw (CompilationError) cause;
-      }
-      throw e;
+      classReader.initializeLazyClassCollection(builder);
     } finally {
       timing.end();
     }
     return builder.build();
   }
 
-  private void readClassSources(DexApplication.Builder builder, Closer closer)
-      throws IOException, ExecutionException {
-    JarApplicationReader application = new JarApplicationReader(options);
-    JarClassFileReader reader = new JarClassFileReader(
-        application, builder::addClassIgnoringLibraryDuplicates);
-    for (Resource input : inputApp.getClassProgramResources()) {
-      reader.read(DEFAULT_DEX_FILENAME, ClassKind.PROGRAM, input.getStream(closer));
-    }
-    for (Resource input : inputApp.getClassClasspathResources()) {
-      if (options.lazyClasspathLoading && getResourceClassDescriptorOrNull(input) != null) {
-        addLazyLoader(application, ClassKind.CLASSPATH, builder, input);
-      } else {
-        reader.read(DEFAULT_DEX_FILENAME, ClassKind.CLASSPATH, input.getStream(closer));
-      }
-    }
-    for (Resource input : inputApp.getClassLibraryResources()) {
-      if (options.lazyLibraryLoading && getResourceClassDescriptorOrNull(input) != null) {
-        addLazyLoader(application, ClassKind.LIBRARY, builder, input);
-      } else {
-        reader.read(DEFAULT_DEX_FILENAME, ClassKind.LIBRARY, input.getStream(closer));
-      }
-    }
-  }
-
-  private void initializeLazyClassCollection(DexApplication.Builder builder) {
-    List<ResourceProvider> classpathProviders = inputApp.getClasspathResourceProviders();
-    List<ResourceProvider> libraryProviders = inputApp.getLibraryResourceProviders();
-    if (!classpathProviders.isEmpty() || !libraryProviders.isEmpty()) {
-      builder.setLazyClassCollection(new LazyClassCollection(
-          new JarApplicationReader(options), classpathProviders, libraryProviders));
-    }
-  }
-
-  private void addLazyLoader(JarApplicationReader application,
-      ClassKind classKind, DexApplication.Builder builder, Resource resource) {
-    // Generate expected DEX type.
-    String classDescriptor = getResourceClassDescriptorOrNull(resource);
-    assert classDescriptor != null;
-    DexType type = options.itemFactory.createType(classDescriptor);
-    LazyClassFileLoader newLoader = new LazyClassFileLoader(type, resource, classKind, application);
-    builder.addClassPromise(newLoader, true);
-  }
-
-  private void readDexSources(DexApplication.Builder builder, ExecutorService executorService,
-      List<Future<?>> futures, Closer closer)
-      throws IOException, ExecutionException {
-    List<Resource> dexProgramSources = inputApp.getDexProgramResources();
-    List<Resource> dexClasspathSources = inputApp.getDexClasspathResources();
-    List<Resource> dexLibrarySources = inputApp.getDexLibraryResources();
-    int numberOfFiles = dexProgramSources.size()
-        + dexLibrarySources.size() + dexClasspathSources.size();
-    if (numberOfFiles > 0) {
-      List<DexFileReader> fileReaders = new ArrayList<>(numberOfFiles);
-      int computedMinApiLevel = options.minApiLevel;
-      for (Resource input : dexProgramSources) {
-        DexFile file = new DexFile(input.getStream(closer));
-        computedMinApiLevel = verifyOrComputeMinApiLevel(computedMinApiLevel, file);
-        fileReaders.add(new DexFileReader(file, ClassKind.PROGRAM, itemFactory));
-      }
-      for (Resource input : dexClasspathSources) {
-        DexFile file = new DexFile(input.getStream(closer));
-        fileReaders.add(new DexFileReader(file, ClassKind.CLASSPATH, itemFactory));
-      }
-      for (Resource input : dexLibrarySources) {
-        DexFile file = new DexFile(input.getStream(closer));
-        computedMinApiLevel = verifyOrComputeMinApiLevel(computedMinApiLevel, file);
-        fileReaders.add(new DexFileReader(file, ClassKind.LIBRARY, itemFactory));
-      }
-      options.minApiLevel = computedMinApiLevel;
-      for (DexFileReader reader : fileReaders) {
-        DexFileReader.populateIndexTables(reader);
-      }
-      // Read the DexCode items and DexProgramClass items in parallel.
-      for (DexFileReader reader : fileReaders) {
-        futures.add(executorService.submit(() -> {
-          reader.addCodeItemsTo();  // Depends on Everything for parsing.
-          reader.addClassDefsTo(builder::addClassPromise);  // Depends on Methods, Code items etc.
-        }));
-      }
-    }
-  }
-
   private int verifyOrComputeMinApiLevel(int computedMinApiLevel, DexFile file) {
     int version = file.getDexVersion();
     if (options.minApiLevel == DEFAULT_ANDROID_API) {
@@ -232,9 +158,110 @@
     }
   }
 
-  private static String getResourceClassDescriptorOrNull(Resource resource) {
-    Set<String> descriptors = resource.getClassDescriptors();
-    return (descriptors == null) || (descriptors.size() != 1)
-        ? null : descriptors.iterator().next();
+  private final class ClassReader {
+    private final ExecutorService executorService;
+    private final List<Future<?>> futures;
+    private final Closer closer;
+
+    // We use concurrent queues to collect classes
+    // since the classes can be collected concurrently.
+    private final Queue<DexProgramClass> programClasses = new ConcurrentLinkedQueue<>();
+    private final Queue<DexClasspathClass> classpathClasses = new ConcurrentLinkedQueue<>();
+    private final Queue<DexLibraryClass> libraryClasses = new ConcurrentLinkedQueue<>();
+    // Jar application reader to share across all class readers.
+    private final JarApplicationReader application = new JarApplicationReader(options);
+
+    ClassReader(ExecutorService executorService, List<Future<?>> futures, Closer closer) {
+      this.executorService = executorService;
+      this.futures = futures;
+      this.closer = closer;
+    }
+
+    private <T extends DexClass> void readDexSources(List<Resource> dexSources,
+        ClassKind classKind, Queue<T> classes) throws IOException, ExecutionException {
+      if (dexSources.size() > 0) {
+        List<DexFileReader> fileReaders = new ArrayList<>(dexSources.size());
+        int computedMinApiLevel = options.minApiLevel;
+        for (Resource input : dexSources) {
+          DexFile file = new DexFile(input.getStream(closer));
+          computedMinApiLevel = verifyOrComputeMinApiLevel(computedMinApiLevel, file);
+          fileReaders.add(new DexFileReader(file, classKind, itemFactory));
+        }
+        options.minApiLevel = computedMinApiLevel;
+        for (DexFileReader reader : fileReaders) {
+          DexFileReader.populateIndexTables(reader);
+        }
+        // Read the DexCode items and DexProgramClass items in parallel.
+        for (DexFileReader reader : fileReaders) {
+          futures.add(executorService.submit(() -> {
+            reader.addCodeItemsTo();  // Depends on Everything for parsing.
+            reader.addClassDefsTo(
+                classKind.bridgeConsumer(classes::add)); // Depends on Methods, Code items etc.
+          }));
+        }
+      }
+    }
+
+    private <T extends DexClass> void readClassSources(List<Resource> classSources,
+        ClassKind classKind, Queue<T> classes) throws IOException, ExecutionException {
+      JarClassFileReader reader = new JarClassFileReader(
+          application, classKind.bridgeConsumer(classes::add));
+      for (Resource input : classSources) {
+        reader.read(DEFAULT_DEX_FILENAME, classKind, input.getStream(closer));
+      }
+    }
+
+    void readSources() throws IOException, ExecutionException {
+      readDexSources(inputApp.getDexProgramResources(), PROGRAM, programClasses);
+      readDexSources(inputApp.getDexClasspathResources(), CLASSPATH, classpathClasses);
+      readDexSources(inputApp.getDexLibraryResources(), LIBRARY, libraryClasses);
+      readClassSources(inputApp.getClassProgramResources(), PROGRAM, programClasses);
+      readClassSources(inputApp.getClassClasspathResources(), CLASSPATH, classpathClasses);
+      readClassSources(inputApp.getClassLibraryResources(), LIBRARY, libraryClasses);
+    }
+
+    private <T extends DexClass> ClassProvider<T> buildClassProvider(ClassKind classKind,
+        Queue<T> preloadedClasses, List<ClassFileResourceProvider> resourceProviders,
+        JarApplicationReader reader) {
+      List<ClassProvider<T>> providers = new ArrayList<>();
+
+      // Preloaded classes.
+      if (!preloadedClasses.isEmpty()) {
+        providers.add(ClassProvider.forPreloadedClasses(classKind, preloadedClasses));
+      }
+
+      // Class file resource providers.
+      for (ClassFileResourceProvider provider : resourceProviders) {
+        providers.add(ClassProvider.forClassFileResources(classKind, provider, reader));
+      }
+
+      // Combine if needed.
+      if (providers.isEmpty()) {
+        return null;
+      }
+      return providers.size() == 1 ? providers.get(0)
+          : ClassProvider.combine(classKind, providers);
+    }
+
+    void initializeLazyClassCollection(DexApplication.Builder builder) {
+      // Add all program classes to the builder.
+      for (DexProgramClass clazz : programClasses) {
+        builder.addProgramClass(clazz.asProgramClass());
+      }
+
+      // Create classpath class collection if needed.
+      ClassProvider<DexClasspathClass> classpathClassProvider = buildClassProvider(CLASSPATH,
+          classpathClasses, inputApp.getClasspathResourceProviders(), application);
+      if (classpathClassProvider != null) {
+        builder.setClasspathClassCollection(new ClasspathClassCollection(classpathClassProvider));
+      }
+
+      // Create library class collection if needed.
+      ClassProvider<DexLibraryClass> libraryClassProvider = buildClassProvider(LIBRARY,
+          libraryClasses, inputApp.getLibraryResourceProviders(), application);
+      if (libraryClassProvider != null) {
+        builder.setLibraryClassCollection(new LibraryClassCollection(libraryClassProvider));
+      }
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index db264ca..1636c56 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -3,6 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.dex;
 
+import com.android.tools.r8.dex.VirtualFile.FilePerClassDistributor;
+import com.android.tools.r8.dex.VirtualFile.FillFilesDistributor;
+import com.android.tools.r8.dex.VirtualFile.PackageMapDistributor;
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexAnnotationSet;
@@ -12,12 +16,15 @@
 import com.android.tools.r8.graph.DexDebugInfo;
 import com.android.tools.r8.graph.DexEncodedArray;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.naming.MinifiedNameMapPrinter;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.PackageDistribution;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -111,13 +118,38 @@
       application.dexItemFactory.sort(namingLens);
       SortAnnotations sortAnnotations = new SortAnnotations();
       application.classes().forEach((clazz) -> clazz.addDependencies(sortAnnotations));
-      Map<Integer, VirtualFile> newFiles =
-          VirtualFile.fileSetFrom(this, packageDistribution, executorService);
 
-      // Write the dex files and the Proguard mapping file in parallel.
+      // Distribute classes into dex files.
+      VirtualFile.Distributor distributor = null;
+      if (options.outputMode == OutputMode.FilePerClass) {
+        assert packageDistribution == null :
+            "Cannot combine package distribution definition with file-per-class option.";
+        distributor = new FilePerClassDistributor(this);
+      } else if (options.minApiLevel < Constants.ANDROID_L_API
+            && options.mainDexKeepRules.isEmpty()
+            && application.mainDexList.isEmpty()) {
+        if (packageDistribution != null) {
+          throw new CompilationError("Cannot apply package distribution. Multidex is not"
+              + " supported with API level " + options.minApiLevel +"."
+              + " For API level < " + Constants.ANDROID_L_API + ", main dex classes list or"
+              + " rules must be specified.");
+        }
+        distributor = new VirtualFile.MonoDexDistributor(this);
+      } else if (packageDistribution != null) {
+        assert !options.minimalMainDex :
+            "Cannot combine package distribution definition with minimal-main-dex option.";
+        distributor = new PackageMapDistributor(this, packageDistribution, executorService);
+      } else {
+        distributor = new FillFilesDistributor(this, options.minimalMainDex);
+      }
+      Map<Integer, VirtualFile> newFiles = distributor.run();
+
+      // Write the dex files and the Proguard mapping file in parallel. Use a linked hash map
+      // as the order matters when addDexProgramData is called below.
       LinkedHashMap<VirtualFile, Future<byte[]>> dexDataFutures = new LinkedHashMap<>();
-      for (Integer index : newFiles.keySet()) {
-        VirtualFile newFile = newFiles.get(index);
+      for (int i = 0; i < newFiles.size(); i++) {
+        VirtualFile newFile = newFiles.get(i);
+        assert newFile.getId() == i;
         if (!newFile.isEmpty()) {
           dexDataFutures.put(newFile, executorService.submit(() -> writeDexFile(newFile)));
         }
@@ -141,6 +173,10 @@
       if (proguardSeedsData != null) {
         builder.setProguardSeedsData(proguardSeedsData);
       }
+      byte[] mainDexList = writeMainDexList();
+      if (mainDexList != null) {
+        builder.setMainDexListData(mainDexList);
+      }
       return builder.build();
     } finally {
       application.timing.end();
@@ -177,4 +213,22 @@
     }
     return null;
   }
+
+  private String mapMainDexListName(DexType type) {
+    return DescriptorUtils.descriptorToJavaType(namingLens.lookupDescriptor(type).toString())
+        .replace('.', '/') + ".class";
+  }
+
+  private byte[] writeMainDexList() throws IOException {
+    if (application.mainDexList.isEmpty()) {
+      return null;
+    }
+    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+    PrintWriter writer = new PrintWriter(bytes);
+    application.mainDexList.forEach(
+        type -> writer.println(mapMainDexListName(type))
+    );
+    writer.flush();
+    return bytes.toByteArray();
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/dex/Constants.java b/src/main/java/com/android/tools/r8/dex/Constants.java
index 201fc82..3ea63bb 100644
--- a/src/main/java/com/android/tools/r8/dex/Constants.java
+++ b/src/main/java/com/android/tools/r8/dex/Constants.java
@@ -10,6 +10,7 @@
 
   public static final int ANDROID_O_API = 26;
   public static final int ANDROID_N_API = 24;
+  public static final int ANDROID_L_API = 21;
   public static final int ANDROID_K_API = 19;
   public static final int DEFAULT_ANDROID_API = 1;
 
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index 07fce3a..0e89d4a 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -23,11 +23,10 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.PackageDistribution;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.google.common.collect.Iterators;
+import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
@@ -55,6 +54,19 @@
 
 public class VirtualFile {
 
+  // The fill strategy determine how to distribute classes into dex files.
+  enum FillStrategy {
+    // Only put classes matches by the main dex rules into the first dex file. Distribute remaining
+    // classes in additional dex files filling each dex file as much as possible.
+    MINIMAL_MAIN_DEX,
+    // Distribute classes in as few dex files as possible filling each dex file as much as possible.
+    FILL_MAX,
+    // Distribute classes keeping some space for future growth. This is mainly useful together with
+    // the package map distribution.
+    LEAVE_SPACE_FOR_GROWTH,
+    // TODO(sgjesse): Does "minimal main dex" combined with "leave space for growth" make sense?
+  }
+
   private static final int MAX_ENTRIES = (Short.MAX_VALUE << 1) + 1;
   /**
    * When distributing classes across files we aim to leave some space. The amount of space left is
@@ -72,6 +84,10 @@
     this.transaction = new IndexedItemTransaction(indexedItems, namingLens);
   }
 
+  public int getId() {
+    return id;
+  }
+
   public Set<String> getClassDescriptors() {
     Set<String> classDescriptors = new HashSet<>();
     for (DexProgramClass clazz : indexedItems.classes) {
@@ -81,119 +97,6 @@
     return classDescriptors;
   }
 
-  public static Map<Integer, VirtualFile> fileSetFrom(
-      ApplicationWriter writer,
-      PackageDistribution packageDistribution,
-      ExecutorService executorService)
-      throws ExecutionException, IOException {
-    // Strategy for distributing classes for write out:
-    // 1. Place all files in the package distribution file in the proposed files (if any).
-    // 2. Place the remaining files based on their packages in sorted order.
-    DexApplication application = writer.application;
-    InternalOptions options = writer.options;
-    Map<Integer, VirtualFile> nameToFileMap = new LinkedHashMap<>();
-
-    if (options.outputMode == OutputMode.FilePerClass) {
-      assert packageDistribution == null :
-          "Cannot combine package distribution definition with file-per-class option.";
-      // Assign dedicated virtual files for all program classes.
-      for (DexProgramClass clazz : application.classes()) {
-        VirtualFile file = new VirtualFile(nameToFileMap.size(), writer.namingLens);
-        nameToFileMap.put(nameToFileMap.size(), file);
-        file.addClass(clazz);
-        file.commitTransaction();
-      }
-      return nameToFileMap;
-    }
-
-    if (packageDistribution != null) {
-      int maxReferencedIndex = packageDistribution.maxReferencedIndex();
-      for (int index = 0; index <= maxReferencedIndex; index++) {
-        VirtualFile file = new VirtualFile(index, writer.namingLens);
-        nameToFileMap.put(index, file);
-      }
-    } else {
-      // If we had no map we default to 1 file, the package populator will add more if needed.
-      nameToFileMap.put(0, new VirtualFile(0, writer.namingLens));
-    }
-    Set<DexProgramClass> classes = Sets.newHashSet(application.classes());
-
-    // Compute the original names.
-    Map<DexProgramClass, String> originalNames = computeOriginalNameMapping(classes,
-        application.getProguardMap());
-
-    if (application.mainDexList != null) {
-      VirtualFile mainDexFile = nameToFileMap.get(0);
-      for (DexType type : application.mainDexList) {
-        DexClass clazz = application.definitionFor(type);
-        if (clazz != null && clazz.isProgramClass()) {
-          DexProgramClass programClass = (DexProgramClass) clazz;
-          mainDexFile.addClass(programClass);
-          if (mainDexFile.isFull()) {
-            throw new CompilationError("Cannot fit requested classes in main-dex file.");
-          }
-          classes.remove(programClass);
-        } else {
-          System.out.println(
-              "WARNING: Application does not contain `"
-                  + type.toDescriptorString()
-                  + "` as referenced in main-dex-list.");
-        }
-        mainDexFile.commitTransaction();
-      }
-    }
-
-    // Sort the classes based on the original names.
-    // This with make classes from the same package be adjacent.
-    classes = sortClassesByPackage(classes, originalNames);
-
-    Set<String> usedPrefixes = null;
-    if (packageDistribution != null) {
-      ArrayList<Future<List<DexProgramClass>>> futures = new ArrayList<>(nameToFileMap.size());
-      usedPrefixes = packageDistribution.getFiles();
-      for (VirtualFile file : nameToFileMap.values()) {
-        PackageMapPopulator populator =
-            new PackageMapPopulator(file, classes, packageDistribution, originalNames);
-        futures.add(executorService.submit(populator));
-      }
-      ThreadUtils.awaitFutures(futures).forEach(classes::removeAll);
-    }
-
-    // TODO(zerny): Add the package map to AndroidApp and refactor its generation.
-    Path newPackageMap = Paths.get("package.map");
-    Map<String, Integer> newAssignments;
-    if (classes.isEmpty()) {
-      newAssignments = Collections.emptyMap();
-    } else {
-      newAssignments =
-          new PackageSplitPopulator(
-              nameToFileMap, classes, originalNames, usedPrefixes, application.dexItemFactory,
-              options, writer.namingLens)
-              .call();
-      if (!newAssignments.isEmpty() && nameToFileMap.size() > 1) {
-        if (packageDistribution == null) {
-          System.out.println(" * Consider using a package map to improve patch sizes.");
-        } else {
-          System.err.println(" * The used package map is missing entries. The following default "
-              + "mappings have been used:");
-          Writer output = new OutputStreamWriter(System.err);
-          for (Entry<String, Integer> entry : newAssignments.entrySet()) {
-            output.write("    ");
-            PackageDistribution.formatEntry(entry, output);
-            output.write("\n");
-          }
-          output.flush();
-          System.err.println(" * Consider updating the map.");
-        }
-      }
-    }
-    if (packageDistribution != null || nameToFileMap.size() > 1) {
-      System.out.println(" - " + newPackageMap.toString());
-      PackageDistribution.writePackageToFileMap(newPackageMap, newAssignments, packageDistribution);
-    }
-    return nameToFileMap;
-  }
-
   public static String deriveCommonPrefixAndSanityCheck(List<String> fileNames) {
     Iterator<String> nameIterator = fileNames.iterator();
     String first = nameIterator.next();
@@ -228,38 +131,6 @@
     return originalNames;
   }
 
-  private static TreeSet<DexProgramClass> sortClassesByPackage(Set<DexProgramClass> classes,
-      Map<DexProgramClass, String> originalNames) {
-    TreeSet<DexProgramClass> sortedClasses = new TreeSet<>(
-        (DexProgramClass a, DexProgramClass b) -> {
-      String originalA = originalNames.get(a);
-      String originalB = originalNames.get(b);
-      int indexA = originalA.lastIndexOf('.');
-      int indexB = originalB.lastIndexOf('.');
-      if (indexA == -1 && indexB == -1) {
-        // Empty package, compare the class names.
-        return originalA.compareTo(originalB);
-      }
-      if (indexA == -1) {
-        // Empty package name comes first.
-        return -1;
-      }
-      if (indexB == -1) {
-        // Empty package name comes first.
-        return 1;
-      }
-      String prefixA = originalA.substring(0, indexA);
-      String prefixB = originalB.substring(0, indexB);
-      int result = prefixA.compareTo(prefixB);
-      if (result != 0) {
-        return result;
-      }
-      return originalA.compareTo(originalB);
-    });
-    sortedClasses.addAll(classes);
-    return sortedClasses;
-  }
-
   private static String extractPrefixToken(int prefixLength, String className, boolean addStar) {
     int index = 0;
     int lastIndex = 0;
@@ -303,11 +174,11 @@
     return isFull(transaction.getNumberOfMethods(), transaction.getNumberOfFields(), MAX_ENTRIES);
   }
 
-  private boolean isFilledEnough(InternalOptions options) {
+  private boolean isFilledEnough(FillStrategy fillStrategy) {
     return isFull(
         transaction.getNumberOfMethods(),
         transaction.getNumberOfFields(),
-        options.fillDexFiles ? MAX_ENTRIES : MAX_PREFILL_ENTRIES);
+        fillStrategy == FillStrategy.FILL_MAX ? MAX_ENTRIES : MAX_PREFILL_ENTRIES);
   }
 
   public void abortTransaction() {
@@ -326,6 +197,240 @@
     return indexedItems.classes;
   }
 
+  public abstract static class Distributor {
+    protected final DexApplication application;
+    protected final ApplicationWriter writer;
+    protected final Map<Integer, VirtualFile> nameToFileMap = new HashMap<>();
+
+    public Distributor(ApplicationWriter writer) {
+      this.application = writer.application;
+      this.writer = writer;
+    }
+
+    public abstract Map<Integer, VirtualFile> run() throws ExecutionException, IOException;
+  }
+
+  public static class FilePerClassDistributor extends Distributor {
+
+    public FilePerClassDistributor(ApplicationWriter writer) {
+      super(writer);
+    }
+
+    public Map<Integer, VirtualFile> run() throws ExecutionException, IOException {
+      // Assign dedicated virtual files for all program classes.
+      for (DexProgramClass clazz : application.classes()) {
+        VirtualFile file = new VirtualFile(nameToFileMap.size(), writer.namingLens);
+        nameToFileMap.put(nameToFileMap.size(), file);
+        file.addClass(clazz);
+        file.commitTransaction();
+      }
+      return nameToFileMap;
+    }
+  }
+
+  public abstract static class DistributorBase extends Distributor {
+    protected Set<DexProgramClass> classes;
+    protected Map<DexProgramClass, String> originalNames;
+
+    public DistributorBase(ApplicationWriter writer) {
+      super(writer);
+
+      classes = Sets.newHashSet(application.classes());
+      originalNames = computeOriginalNameMapping(classes, application.getProguardMap());
+    }
+
+    protected void fillForMainDexList(Set<DexProgramClass> classes) {
+      if (application.mainDexList != null) {
+        VirtualFile mainDexFile = nameToFileMap.get(0);
+        for (DexType type : application.mainDexList) {
+          DexClass clazz = application.definitionFor(type);
+          if (clazz != null && clazz.isProgramClass()) {
+            DexProgramClass programClass = (DexProgramClass) clazz;
+            mainDexFile.addClass(programClass);
+            if (mainDexFile.isFull()) {
+              throw new CompilationError("Cannot fit requested classes in main-dex file.");
+            }
+            classes.remove(programClass);
+          } else {
+            System.out.println(
+                "WARNING: Application does not contain `"
+                    + type.toSourceString()
+                    + "` as referenced in main-dex-list.");
+          }
+          mainDexFile.commitTransaction();
+        }
+      }
+    }
+
+    TreeSet<DexProgramClass> sortClassesByPackage(Set<DexProgramClass> classes,
+        Map<DexProgramClass, String> originalNames) {
+      TreeSet<DexProgramClass> sortedClasses = new TreeSet<>(
+          (DexProgramClass a, DexProgramClass b) -> {
+            String originalA = originalNames.get(a);
+            String originalB = originalNames.get(b);
+            int indexA = originalA.lastIndexOf('.');
+            int indexB = originalB.lastIndexOf('.');
+            if (indexA == -1 && indexB == -1) {
+              // Empty package, compare the class names.
+              return originalA.compareTo(originalB);
+            }
+            if (indexA == -1) {
+              // Empty package name comes first.
+              return -1;
+            }
+            if (indexB == -1) {
+              // Empty package name comes first.
+              return 1;
+            }
+            String prefixA = originalA.substring(0, indexA);
+            String prefixB = originalB.substring(0, indexB);
+            int result = prefixA.compareTo(prefixB);
+            if (result != 0) {
+              return result;
+            }
+            return originalA.compareTo(originalB);
+          });
+      sortedClasses.addAll(classes);
+      return sortedClasses;
+    }
+  }
+
+  public static class FillFilesDistributor extends DistributorBase {
+    private final FillStrategy fillStrategy;
+
+    public FillFilesDistributor(ApplicationWriter writer, boolean minimalMainDex) {
+      super(writer);
+      this.fillStrategy = minimalMainDex ? FillStrategy.MINIMAL_MAIN_DEX : FillStrategy.FILL_MAX;
+    }
+
+    public Map<Integer, VirtualFile> run() throws ExecutionException, IOException {
+      // Strategy for distributing classes for write out:
+      // 1. Place the remaining files based on their packages in sorted order.
+
+      // Start with 1 file. The package populator will add more if needed.
+      nameToFileMap.put(0, new VirtualFile(0, writer.namingLens));
+
+      // First fill required classes into the main dex file.
+      fillForMainDexList(classes);
+
+      // Sort the remaining classes based on the original names.
+      // This with make classes from the same package be adjacent.
+      classes = sortClassesByPackage(classes, originalNames);
+
+      new PackageSplitPopulator(
+          nameToFileMap, classes, originalNames, null, application.dexItemFactory,
+          fillStrategy, writer.namingLens)
+          .call();
+      return nameToFileMap;
+    }
+  }
+
+  public static class MonoDexDistributor extends DistributorBase {
+    public MonoDexDistributor(ApplicationWriter writer) {
+      super(writer);
+    }
+
+    @Override
+    public Map<Integer, VirtualFile> run() throws ExecutionException, IOException {
+      VirtualFile mainDexFile = new VirtualFile(0, writer.namingLens);
+      nameToFileMap.put(0, mainDexFile);
+
+      for (DexProgramClass programClass : classes) {
+        mainDexFile.addClass(programClass);
+        if (mainDexFile.isFull()) {
+          throw new CompilationError("Cannot fit all classes in a single dex file.");
+        }
+      }
+      mainDexFile.commitTransaction();
+      return nameToFileMap;
+    }
+  }
+
+  public static class PackageMapDistributor extends DistributorBase {
+    private final PackageDistribution packageDistribution;
+    private final ExecutorService executorService;
+
+    public PackageMapDistributor(
+        ApplicationWriter writer,
+        PackageDistribution packageDistribution,
+        ExecutorService executorService) {
+      super(writer);
+      this.packageDistribution = packageDistribution;
+      this.executorService = executorService;
+    }
+
+    public Map<Integer, VirtualFile> run() throws ExecutionException, IOException {
+      // Strategy for distributing classes for write out:
+      // 1. Place all files in the package distribution file in the proposed files (if any).
+      // 2. Place the remaining files based on their packages in sorted order.
+
+      int maxReferencedIndex = packageDistribution.maxReferencedIndex();
+      for (int index = 0; index <= maxReferencedIndex; index++) {
+        VirtualFile file = new VirtualFile(index, writer.namingLens);
+        nameToFileMap.put(index, file);
+      }
+
+      // First fill required classes into the main dex file.
+      fillForMainDexList(classes);
+
+      // Sort the remaining classes based on the original names.
+      // This with make classes from the same package be adjacent.
+      classes = sortClassesByPackage(classes, originalNames);
+
+      Set<String> usedPrefixes = fillForDistribution(classes, originalNames);
+
+      // TODO(zerny): Add the package map to AndroidApp and refactor its generation.
+      Map<String, Integer> newAssignments;
+      if (classes.isEmpty()) {
+        newAssignments = Collections.emptyMap();
+      } else {
+        newAssignments =
+            new PackageSplitPopulator(
+                nameToFileMap, classes, originalNames, usedPrefixes, application.dexItemFactory,
+                FillStrategy.LEAVE_SPACE_FOR_GROWTH, writer.namingLens)
+                .call();
+        if (!newAssignments.isEmpty() && nameToFileMap.size() > 1) {
+          System.err.println(" * The used package map is missing entries. The following default "
+              + "mappings have been used:");
+          writeAssignments(newAssignments, new OutputStreamWriter(System.err));
+          System.err.println(" * Consider updating the map.");
+        }
+      }
+
+      Path newPackageMap = Paths.get("package.map");
+      System.out.println(" - " + newPackageMap.toString());
+      PackageDistribution.writePackageToFileMap(newPackageMap, newAssignments, packageDistribution);
+
+      return nameToFileMap;
+    }
+
+    private Set<String> fillForDistribution(Set<DexProgramClass> classes,
+        Map<DexProgramClass, String> originalNames) throws ExecutionException {
+      Set<String> usedPrefixes = null;
+      if (packageDistribution != null) {
+        ArrayList<Future<List<DexProgramClass>>> futures = new ArrayList<>(nameToFileMap.size());
+        usedPrefixes = packageDistribution.getFiles();
+        for (VirtualFile file : nameToFileMap.values()) {
+          PackageMapPopulator populator =
+              new PackageMapPopulator(file, classes, packageDistribution, originalNames);
+          futures.add(executorService.submit(populator));
+        }
+        ThreadUtils.awaitFutures(futures).forEach(classes::removeAll);
+      }
+      return usedPrefixes;
+    }
+
+    private void writeAssignments(Map<String, Integer> assignments, Writer output)
+        throws IOException{
+      for (Entry<String, Integer> entry : assignments.entrySet()) {
+        output.write("    ");
+        PackageDistribution.formatEntry(entry, output);
+        output.write("\n");
+      }
+      output.flush();
+    }
+  }
+
   private static class VirtualFileIndexedItemCollection implements IndexedItemCollection {
 
     final int id;
@@ -575,6 +680,7 @@
       this.originalNames = originalNames;
     }
 
+    @Override
     public List<DexProgramClass> call() {
       String currentPrefix = null;
       int currentFileId = -1;
@@ -598,9 +704,9 @@
           inserted.add(clazz);
         }
         if (file.isFull()) {
-          throw new RuntimeException(
+          throw new CompilationError(
               "Cannot fit package " + currentPrefix
-                  + " in requested dex file, consider to remove mapping.");
+                  + " in requested dex file, consider removing mapping.");
         }
       }
       file.commitTransaction();
@@ -643,6 +749,74 @@
   }
 
   /**
+   * Helper class to cycle through the set of virtual files.
+   *
+   * Iteration starts at the first file and iterates through all files.
+   *
+   * When {@link VirtualFileCycler#restart()} is called iteration of all files is restarted at the
+   * current file.
+   *
+   * If the fill strategy indicate that the main dex file should be minimal, then the main dex file
+   * will not be part of the iteration.
+   */
+  private static class VirtualFileCycler {
+    private Map<Integer, VirtualFile> files;
+    private final NamingLens namingLens;
+    private final FillStrategy fillStrategy;
+
+    private int nextFileId;
+    private Iterator<VirtualFile> allFilesCyclic;
+    private Iterator<VirtualFile> activeFiles;
+
+    VirtualFileCycler(Map<Integer, VirtualFile> files, NamingLens namingLens,
+        FillStrategy fillStrategy) {
+      this.files = files;
+      this.namingLens = namingLens;
+      this.fillStrategy = fillStrategy;
+
+      nextFileId = files.size();
+      if (fillStrategy == FillStrategy.MINIMAL_MAIN_DEX) {
+        // The main dex file is filtered out, so ensure at least one file for the remaining
+        // classes
+        files.put(nextFileId, new VirtualFile(nextFileId, namingLens));
+        this.files = Maps.filterKeys(files, key -> key != 0);
+        nextFileId++;
+      }
+
+      reset();
+    }
+
+    private void reset() {
+      allFilesCyclic = Iterators.cycle(files.values());
+      restart();
+    }
+
+    boolean hasNext() {
+      return activeFiles.hasNext();
+    }
+
+    VirtualFile next() {
+      VirtualFile next = activeFiles.next();
+      assert fillStrategy != FillStrategy.MINIMAL_MAIN_DEX || next.getId() != 0;
+      return next;
+    }
+
+    // Start a new iteration over all files, starting at the current one.
+    void restart() {
+      activeFiles = Iterators.limit(allFilesCyclic, files.size());
+    }
+
+    VirtualFile addFile() {
+      VirtualFile newFile = new VirtualFile(nextFileId, namingLens);
+      files.put(nextFileId, newFile);
+      nextFileId++;
+
+      reset();
+      return newFile;
+    }
+  }
+
+  /**
    * Distributes the given classes over the files in package order.
    *
    * <p>The populator avoids package splits. Big packages are split into subpackages if their size
@@ -666,13 +840,12 @@
      */
     private static final int MIN_FILL_FACTOR = 5;
 
-    private final Map<Integer, VirtualFile> files;
     private final List<DexProgramClass> classes;
     private final Map<DexProgramClass, String> originalNames;
     private final Set<String> previousPrefixes;
     private final DexItemFactory dexItemFactory;
-    private final InternalOptions options;
-    private final NamingLens namingLens;
+    private final FillStrategy fillStrategy;
+    private final VirtualFileCycler cycler;
 
     PackageSplitPopulator(
         Map<Integer, VirtualFile> files,
@@ -680,30 +853,28 @@
         Map<DexProgramClass, String> originalNames,
         Set<String> previousPrefixes,
         DexItemFactory dexItemFactory,
-        InternalOptions options,
+        FillStrategy fillStrategy,
         NamingLens namingLens) {
-      this.files = files;
       this.classes = new ArrayList<>(classes);
       this.originalNames = originalNames;
       this.previousPrefixes = previousPrefixes;
       this.dexItemFactory = dexItemFactory;
-      this.options = options;
-      this.namingLens = namingLens;
+      this.fillStrategy = fillStrategy;
+      this.cycler = new VirtualFileCycler(files, namingLens, fillStrategy);
     }
 
     private String getOriginalName(DexProgramClass clazz) {
       return originalNames != null ? originalNames.get(clazz) : clazz.toString();
     }
 
+    @Override
     public Map<String, Integer> call() throws IOException {
-      Iterator<VirtualFile> allFilesCyclic = Iterators.cycle(files.values());
-      Iterator<VirtualFile> activeFiles = Iterators.limit(allFilesCyclic, files.size());
       int prefixLength = MINIMUM_PREFIX_LENGTH;
       int transactionStartIndex = 0;
       int fileStartIndex = 0;
       String currentPrefix = null;
       Map<String, Integer> newPackageAssignments = new LinkedHashMap<>();
-      VirtualFile current = activeFiles.next();
+      VirtualFile current = cycler.next();
       List<DexProgramClass> nonPackageClasses = new ArrayList<>();
       for (int classIndex = 0; classIndex < classes.size(); classIndex++) {
         DexProgramClass clazz = classes.get(classIndex);
@@ -711,8 +882,8 @@
         if (!PackageMapPopulator.coveredByPrefix(originalName, currentPrefix)) {
           if (currentPrefix != null) {
             current.commitTransaction();
-            // Reset the iterator to again iterate over all files, starting with the current one.
-            activeFiles = Iterators.limit(allFilesCyclic, files.size());
+            // Reset the cycler to again iterate over all files, starting with the current one.
+            cycler.restart();
             assert !newPackageAssignments.containsKey(currentPrefix);
             newPackageAssignments.put(currentPrefix, current.id);
             // Try to reduce the prefix length if possible. Only do this on a successful commit.
@@ -750,7 +921,7 @@
           nonPackageClasses.add(clazz);
           continue;
         }
-        if (current.isFilledEnough(options) || current.isFull()) {
+        if (current.isFilledEnough(fillStrategy) || current.isFull()) {
           current.abortTransaction();
           // We allow for a final rollback that has at most 20% of classes in it.
           // This is a somewhat random number that was empirically chosen.
@@ -762,7 +933,7 @@
             // The idea is that we do not increase the number of files, so it has to fit
             // somewhere.
             fileStartIndex = transactionStartIndex;
-            if (!activeFiles.hasNext()) {
+            if (!cycler.hasNext()) {
               // Special case where we simply will never be able to fit the current package into
               // one dex file. This is currently the case for Strings in jumbo tests, see:
               // b/33227518
@@ -773,11 +944,9 @@
                 transactionStartIndex = classIndex + 1;
               }
               // All files are filled up to the 20% mark.
-              files.put(files.size(), new VirtualFile(files.size(), namingLens));
-              allFilesCyclic = Iterators.cycle(files.values());
-              activeFiles = Iterators.limit(allFilesCyclic, files.size());
+              cycler.addFile();
             }
-            current = activeFiles.next();
+            current = cycler.next();
           }
           currentPrefix = null;
           // Go back to previous start index.
@@ -791,24 +960,25 @@
         newPackageAssignments.put(currentPrefix, current.id);
       }
       if (nonPackageClasses.size() > 0) {
-        addNonPackageClasses(Iterators.limit(allFilesCyclic, files.size()), nonPackageClasses);
+        addNonPackageClasses(cycler, nonPackageClasses);
       }
       return newPackageAssignments;
     }
 
-    private void addNonPackageClasses(Iterator<VirtualFile> activeFiles,
-        List<DexProgramClass> nonPackageClasses) throws IOException {
+    private void addNonPackageClasses(
+        VirtualFileCycler cycler, List<DexProgramClass> nonPackageClasses) {
+      cycler.restart();
       VirtualFile current;
-      current = activeFiles.next();
+      current = cycler.next();
       for (DexProgramClass clazz : nonPackageClasses) {
-        if (current.isFilledEnough(options)) {
-          current = getVirtualFile(activeFiles);
+        if (current.isFilledEnough(fillStrategy)) {
+          current = getVirtualFile(cycler);
         }
         current.addClass(clazz);
         while (current.isFull()) {
           // This only happens if we have a huge class, that takes up more than 20% of a dex file.
           current.abortTransaction();
-          current = getVirtualFile(activeFiles);
+          current = getVirtualFile(cycler);
           boolean wasEmpty = current.isEmpty();
           current.addClass(clazz);
           if (wasEmpty && current.isFull()) {
@@ -820,12 +990,12 @@
       }
     }
 
-    private VirtualFile getVirtualFile(Iterator<VirtualFile> activeFiles) throws IOException {
+    private VirtualFile getVirtualFile(VirtualFileCycler cycler) {
       VirtualFile current = null;
-      while (activeFiles.hasNext() && (current = activeFiles.next()).isFilledEnough(options)) {}
-      if (current == null || current.isFilledEnough(options)) {
-        current = new VirtualFile(files.size(), namingLens);
-        files.put(files.size(), current);
+      while (cycler.hasNext()
+          && (current = cycler.next()).isFilledEnough(fillStrategy)) {}
+      if (current == null || current.isFilledEnough(fillStrategy)) {
+        current = cycler.addFile();
       }
       return current;
     }
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index a558b3e..a5c8ff8 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -40,9 +40,8 @@
 
   private Map<Descriptor, KeyedDexItem> computeDefinitions(DexType type) {
     Builder<Descriptor, KeyedDexItem> builder = ImmutableMap.builder();
-    DexClassPromise promise = app.definitionFor(type);
-    if (promise != null) {
-      DexClass clazz = promise.get();
+    DexClass clazz = app.definitionFor(type);
+    if (clazz != null) {
       registerDefinitions(builder, clazz.directMethods());
       registerDefinitions(builder, clazz.virtualMethods());
       registerDefinitions(builder, clazz.instanceFields());
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
index 9330fdd..9e3e118 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
@@ -21,7 +21,7 @@
 
   public AppInfoWithSubtyping(DexApplication application) {
     super(application);
-    populateSubtypeMap(application.getClassMap(), application.dexItemFactory);
+    populateSubtypeMap(application.getFullClassMap(), application.dexItemFactory);
   }
 
   protected AppInfoWithSubtyping(AppInfoWithSubtyping previous) {
@@ -33,7 +33,7 @@
   protected AppInfoWithSubtyping(AppInfoWithSubtyping previous, GraphLense lense) {
     super(previous, lense);
     // Recompute subtype map if we have modified the graph.
-    populateSubtypeMap(previous.app.getClassMap(), dexItemFactory);
+    populateSubtypeMap(previous.app.getFullClassMap(), dexItemFactory);
   }
 
   public Set<DexType> getMissingClasses() {
@@ -84,22 +84,17 @@
     }
   }
 
-  private void populateSubtypeMap(
-      Map<DexType, DexClassPromise> classes, DexItemFactory dexItemFactory) {
+  private void populateSubtypeMap(Map<DexType, DexClass> classes, DexItemFactory dexItemFactory) {
     dexItemFactory.clearSubtypeInformation();
     dexItemFactory.objectType.tagAsSubtypeRoot();
     Hashtable<DexType, Set<DexType>> map = new Hashtable<>();
-    Function<DexType, DexClass> typeToClass = type -> {
-      DexClassPromise promise = classes.get(type);
-      return promise == null ? null : promise.get();
-    };
-    for (Map.Entry<DexType, DexClassPromise> entry : classes.entrySet()) {
-      populateAllSuperTypes(map, entry.getKey(), entry.getValue().get(), typeToClass);
+    for (Map.Entry<DexType, DexClass> entry : classes.entrySet()) {
+      populateAllSuperTypes(map, entry.getKey(), entry.getValue(), classes::get);
     }
     for (Map.Entry<DexType, Set<DexType>> entry : map.entrySet()) {
       subtypeMap.put(entry.getKey(), ImmutableSet.copyOf(entry.getValue()));
     }
-    assert DexType.validateLevelsAreCorrect(typeToClass, dexItemFactory);
+    assert DexType.validateLevelsAreCorrect(classes::get, dexItemFactory);
   }
 
   // For mapping invoke virtual instruction to target methods.
diff --git a/src/main/java/com/android/tools/r8/graph/ClassKind.java b/src/main/java/com/android/tools/r8/graph/ClassKind.java
index 6f53a40..9298ba5 100644
--- a/src/main/java/com/android/tools/r8/graph/ClassKind.java
+++ b/src/main/java/com/android/tools/r8/graph/ClassKind.java
@@ -1,12 +1,14 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.Resource;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 /** Kind of the application class. Can be program, classpath or library. */
 public enum ClassKind {
-  PROGRAM(DexProgramClass::new),
-  CLASSPATH(DexClasspathClass::new),
-  LIBRARY(DexLibraryClass::new);
+  PROGRAM(DexProgramClass::new, DexClass::isProgramClass),
+  CLASSPATH(DexClasspathClass::new, DexClass::isClasspathClass),
+  LIBRARY(DexLibraryClass::new, DexClass::isLibraryClass);
 
   private interface Factory {
     DexClass create(DexType type, Resource.Kind origin, DexAccessFlags accessFlags,
@@ -17,9 +19,11 @@
   }
 
   private final Factory factory;
+  private final Predicate<DexClass> check;
 
-  ClassKind(Factory factory) {
+  ClassKind(Factory factory, Predicate<DexClass> check) {
     this.factory = factory;
+    this.check = check;
   }
 
   public DexClass create(
@@ -30,4 +34,16 @@
     return factory.create(type, origin, accessFlags, superType, interfaces, sourceFile,
         annotations, staticFields, instanceFields, directMethods, virtualMethods);
   }
+
+  public boolean isOfKind(DexClass clazz) {
+    return check.test(clazz);
+  }
+
+  public <T extends DexClass> Consumer<DexClass> bridgeConsumer(Consumer<T> consumer) {
+    return clazz -> {
+      assert isOfKind(clazz);
+      @SuppressWarnings("unchecked") T specialized = (T) clazz;
+      consumer.accept(specialized);
+    };
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/Code.java b/src/main/java/com/android/tools/r8/graph/Code.java
index 04c01be..dca5e02 100644
--- a/src/main/java/com/android/tools/r8/graph/Code.java
+++ b/src/main/java/com/android/tools/r8/graph/Code.java
@@ -19,7 +19,7 @@
 
   public abstract String toString();
 
-  public abstract String toString(ClassNameMapper naming);
+  public abstract String toString(DexEncodedMethod method, ClassNameMapper naming);
 
   public boolean isDexCode() {
     return false;
diff --git a/src/main/java/com/android/tools/r8/graph/DexApplication.java b/src/main/java/com/android/tools/r8/graph/DexApplication.java
index acbc205..eea0169 100644
--- a/src/main/java/com/android/tools/r8/graph/DexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DexApplication.java
@@ -6,16 +6,13 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
-import com.android.tools.r8.Resource;
-import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.ir.desugar.LambdaRewriter;
-import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.utils.ClasspathClassCollection;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.LazyClassCollection;
+import com.android.tools.r8.utils.LibraryClassCollection;
+import com.android.tools.r8.utils.ProgramClassCollection;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.Timing;
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import java.io.ByteArrayOutputStream;
@@ -26,25 +23,20 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Hashtable;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public class DexApplication {
 
-  // Maps type into class promise, may be used concurrently.
-  private final ImmutableMap<DexType, DexClassPromise> classMap;
-
-  // Lazily loaded classes.
-  //
-  // Note that this collection is autonomous and may be used in several
-  // different applications. Particularly, it is the case when one
-  // application is being build based on another one. Among others,
-  // it will have an important side-effect: class conflict resolution,
-  // generated errors in particular, may be different in lazy scenario.
-  private final LazyClassCollection lazyClassCollection;
+  // Maps type into class, may be used concurrently.
+  private ProgramClassCollection programClasses;
+  private ClasspathClassCollection classpathClasses;
+  private LibraryClassCollection libraryClasses;
 
   public final ImmutableSet<DexType> mainDexList;
 
@@ -60,67 +52,97 @@
   /** Constructor should only be invoked by the DexApplication.Builder. */
   private DexApplication(
       ClassNameMapper proguardMap,
-      ImmutableMap<DexType, DexClassPromise> classMap,
-      LazyClassCollection lazyClassCollection,
+      ProgramClassCollection programClasses,
+      ClasspathClassCollection classpathClasses,
+      LibraryClassCollection libraryClasses,
       ImmutableSet<DexType> mainDexList,
       DexItemFactory dexItemFactory,
       DexString highestSortingString,
       Timing timing) {
+    assert programClasses != null;
     this.proguardMap = proguardMap;
-    this.lazyClassCollection = lazyClassCollection;
+    this.programClasses = programClasses;
+    this.classpathClasses = classpathClasses;
+    this.libraryClasses = libraryClasses;
     this.mainDexList = mainDexList;
-    this.classMap = classMap;
     this.dexItemFactory = dexItemFactory;
     this.highestSortingString = highestSortingString;
     this.timing = timing;
   }
 
-  ImmutableMap<DexType, DexClassPromise> getClassMap() {
-    assert lazyClassCollection == null : "Only allowed in non-lazy scenarios.";
-    return classMap;
+  /** Force load all classes and return type -> class map containing all the classes */
+  public Map<DexType, DexClass> getFullClassMap() {
+    return forceLoadAllClasses();
   }
 
-  public Iterable<DexProgramClass> classes() {
-    List<DexProgramClass> result = new ArrayList<>();
-    // Note: we ignore lazy class collection because it
-    // is never supposed to be used for program classes.
-    for (DexClassPromise promise : classMap.values()) {
-      if (promise.isProgramClass()) {
-        result.add(promise.get().asProgramClass());
-      }
-    }
-    return result;
+  // Reorder classes randomly. Note that the order of classes in program or library
+  // class collections should not matter for compilation of valid code and when running
+  // with assertions enabled we reorder the classes randomly to catch possible issues.
+  // Also note that the order may add to non-determinism in reporting errors for invalid
+  // code, but this non-determinism exists even with the same order of classes since we
+  // may process classes concurrently and fail-fast on the first error.
+  private <T> boolean reorderClasses(List<T> classes) {
+    Collections.shuffle(classes);
+    return true;
   }
 
-  public Iterable<DexLibraryClass> libraryClasses() {
-    assert lazyClassCollection == null : "Only allowed in non-lazy scenarios.";
-    List<DexLibraryClass> result = new ArrayList<>();
-    for (DexClassPromise promise : classMap.values()) {
-      if (promise.isLibraryClass()) {
-        result.add(promise.get().asLibraryClass());
+  public List<DexProgramClass> classes() {
+    List<DexProgramClass> classes = programClasses.collectLoadedClasses();
+    assert reorderClasses(classes);
+    return classes;
+  }
+
+  public List<DexLibraryClass> libraryClasses() {
+    assert classpathClasses == null : "Operation is not supported.";
+    Map<DexType, DexClass> classMap = forceLoadAllClasses();
+    List<DexLibraryClass> classes = new ArrayList<>();
+    for (DexClass clazz : classMap.values()) {
+      if (clazz.isLibraryClass()) {
+        classes.add(clazz.asLibraryClass());
       }
     }
-    return result;
+    assert reorderClasses(classes);
+    return classes;
+  }
+
+  private Map<DexType, DexClass> forceLoadAllClasses() {
+    Map<DexType, DexClass> loaded = new IdentityHashMap<>();
+
+    // program classes are supposed to be loaded, but force-loading them is no-op.
+    programClasses.forceLoad(type -> true);
+    programClasses.collectLoadedClasses().forEach(clazz -> loaded.put(clazz.type, clazz));
+
+    if (classpathClasses != null) {
+      classpathClasses.forceLoad(type -> !loaded.containsKey(type));
+      classpathClasses.collectLoadedClasses().forEach(clazz -> loaded.put(clazz.type, clazz));
+    }
+
+    if (libraryClasses != null) {
+      libraryClasses.forceLoad(type -> !loaded.containsKey(type));
+      libraryClasses.collectLoadedClasses().forEach(clazz -> loaded.put(clazz.type, clazz));
+    }
+
+    return loaded;
   }
 
   public DexClass definitionFor(DexType type) {
-    DexClassPromise promise = classMap.get(type);
-    // In presence of lazy class collection we also reach out to it
-    // as well unless the class found is already a program class.
-    if (lazyClassCollection != null && (promise == null || !promise.isProgramClass())) {
-      promise = lazyClassCollection.get(type, promise);
+    DexClass clazz = programClasses.get(type);
+    if (clazz == null && classpathClasses != null) {
+      clazz = classpathClasses.get(type);
     }
-    return promise == null ? null : promise.get();
+    if (clazz == null && libraryClasses != null) {
+      clazz = libraryClasses.get(type);
+    }
+    return clazz;
   }
 
   public DexProgramClass programDefinitionFor(DexType type) {
-    DexClassPromise promise = classMap.get(type);
-    // Don't bother about lazy class collection, it should never load program classes.
-    return (promise == null || !promise.isProgramClass()) ? null : promise.get().asProgramClass();
+    DexClass clazz = programClasses.get(type);
+    return clazz == null ? null : clazz.asProgramClass();
   }
 
   public String toString() {
-    return "Application (classes #" + classMap.size() + ")";
+    return "Application (" + programClasses + "; " + classpathClasses + "; " + libraryClasses + ")";
   }
 
   public ClassNameMapper getProguardMap() {
@@ -152,7 +174,7 @@
         ps.println("Bytecode for");
         ps.println("Class: '" + clazzName + "'");
         ps.println("Method: '" + methodName + "':");
-        ps.println(method.getCode().toString(naming));
+        ps.println(method.getCode().toString(method, naming));
       } catch (IOException e) {
         e.printStackTrace();
       } finally {
@@ -170,7 +192,7 @@
    * <p>If no directory is provided everything is written to System.out.
    */
   public void disassemble(Path outputDir, InternalOptions options) {
-    for (DexClass clazz : classes()) {
+    for (DexProgramClass clazz : programClasses.collectLoadedClasses()) {
       for (DexEncodedMethod method : clazz.virtualMethods()) {
         if (options.methodMatchesFilter(method)) {
           disassemble(method, getProguardMap(), outputDir);
@@ -202,21 +224,48 @@
     if (clazz.type != dexItemFactory.objectType) {
       builder.append(".super ");
       builder.append(clazz.superType.toSmaliString());
-      // TODO(sgjesse): Add implemented interfaces
       builder.append("\n");
+      for (DexType iface : clazz.interfaces.values) {
+        builder.append(".implements ");
+        builder.append(iface.toSmaliString());
+        builder.append("\n");
+      }
     }
     ps.append(builder.toString());
   }
 
-  /** Write smali source for the application code on the provided PrintStream. */
+  private void writeClassFooter(DexClass clazz, PrintStream ps) {
+    StringBuilder builder = new StringBuilder();
+    builder.append("# End of class ");
+    builder.append(clazz.type.toSmaliString());
+    builder.append("\n");
+    ps.append(builder.toString());
+  }
+
+  /**
+   * Write smali source for the application code on the provided PrintStream.
+   */
   public void smali(InternalOptions options, PrintStream ps) {
-    List<DexProgramClass> classes = (List<DexProgramClass>) classes();
+    List<DexProgramClass> classes = programClasses.collectLoadedClasses();
     classes.sort(Comparator.comparing(DexProgramClass::toSourceString));
+    boolean firstClass = true;
     for (DexClass clazz : classes) {
       boolean classHeaderWritten = false;
+      if (!options.hasMethodsFilter()) {
+        if (!firstClass) {
+          ps.append("\n");
+          firstClass = false;
+        }
+        writeClassHeader(clazz, ps);
+        classHeaderWritten = true;
+      }
       for (DexEncodedMethod method : clazz.virtualMethods()) {
         if (options.methodMatchesFilter(method)) {
           if (!classHeaderWritten) {
+            if (!firstClass) {
+              ps.append("\n");
+              firstClass = false;
+            }
             writeClassHeader(clazz, ps);
             classHeaderWritten = true;
           }
@@ -227,6 +276,10 @@
       for (DexEncodedMethod method : clazz.directMethods()) {
         if (options.methodMatchesFilter(method)) {
           if (!classHeaderWritten) {
+            if (!firstClass) {
+              ps.append("\n");
+              firstClass = false;
+            }
             writeClassHeader(clazz, ps);
             classHeaderWritten = true;
           }
@@ -234,13 +287,24 @@
           ps.append(method.toSmaliString(getProguardMap()));
         }
       }
+      if (classHeaderWritten) {
+        ps.append("\n");
+        writeClassFooter(clazz, ps);
+      }
     }
   }
 
   public static class Builder {
+    // We handle program class collection separately from classpath
+    // and library class collections. Since while we assume program
+    // class collection should always be fully loaded and thus fully
+    // represented by the map (making it easy, for example, adding
+    // new or removing existing classes), classpath and library
+    // collections will be considered monolithic collections.
 
-    private final Hashtable<DexType, DexClassPromise> classMap = new Hashtable<>();
-    private LazyClassCollection lazyClassCollection;
+    private final List<DexProgramClass> programClasses;
+    private ClasspathClassCollection classpathClasses;
+    private LibraryClassCollection libraryClasses;
 
     public final Hashtable<DexCode, DexCode> codeItems = new Hashtable<>();
 
@@ -252,18 +316,17 @@
     private final Set<DexType> mainDexList = Sets.newIdentityHashSet();
 
     public Builder(DexItemFactory dexItemFactory, Timing timing) {
+      this.programClasses = new ArrayList<>();
       this.dexItemFactory = dexItemFactory;
       this.timing = timing;
-      this.lazyClassCollection = null;
+      this.classpathClasses = null;
+      this.libraryClasses = null;
     }
 
     public Builder(DexApplication application) {
-      this(application, application.classMap);
-    }
-
-    public Builder(DexApplication application, Map<DexType, DexClassPromise> classMap) {
-      this.classMap.putAll(classMap);
-      this.lazyClassCollection = application.lazyClassCollection;
+      programClasses = application.programClasses.collectLoadedClasses();
+      classpathClasses = application.classpathClasses;
+      libraryClasses = application.libraryClasses;
       proguardMap = application.proguardMap;
       timing = application.timing;
       highestSortingString = application.highestSortingString;
@@ -277,62 +340,45 @@
       return this;
     }
 
+    public synchronized Builder replaceProgramClasses(List<DexProgramClass> newProgramClasses) {
+      assert newProgramClasses != null;
+      this.programClasses.clear();
+      this.programClasses.addAll(newProgramClasses);
+      return this;
+    }
+
     public synchronized Builder setHighestSortingString(DexString value) {
       highestSortingString = value;
       return this;
     }
 
-    public Builder addClassPromise(DexClassPromise promise) {
-      addClassPromise(promise, false);
+    public synchronized Builder addProgramClass(DexProgramClass clazz) {
+      programClasses.add(clazz);
       return this;
     }
 
-    public Builder setLazyClassCollection(LazyClassCollection lazyClassMap) {
-      this.lazyClassCollection = lazyClassMap;
+    public Builder setClasspathClassCollection(ClasspathClassCollection classes) {
+      this.classpathClasses = classes;
       return this;
     }
 
-    public Builder addClassIgnoringLibraryDuplicates(DexClass clazz) {
-      addClass(clazz, true);
+    public Builder setLibraryClassCollection(LibraryClassCollection classes) {
+      this.libraryClasses = classes;
       return this;
     }
 
-    public Builder addSynthesizedClass(DexProgramClass synthesizedClass, boolean addToMainDexList) {
+    public synchronized Builder addSynthesizedClass(
+        DexProgramClass synthesizedClass, boolean addToMainDexList) {
       assert synthesizedClass.isProgramClass() : "All synthesized classes must be program classes";
-      addClassPromise(synthesizedClass);
+      addProgramClass(synthesizedClass);
       if (addToMainDexList && !mainDexList.isEmpty()) {
         mainDexList.add(synthesizedClass.type);
       }
       return this;
     }
 
-    public List<DexProgramClass> getProgramClasses() {
-      List<DexProgramClass> result = new ArrayList<>();
-      // Note: we ignore lazy class collection because it
-      // is never supposed to be used for program classes.
-      for (DexClassPromise promise : classMap.values()) {
-        if (promise.isProgramClass()) {
-          result.add(promise.get().asProgramClass());
-        }
-      }
-      return result;
-    }
-
-    // Callback from FileReader when parsing a DexProgramClass (multi-threaded).
-    private void addClass(DexClass clazz, boolean skipLibDups) {
-      addClassPromise(clazz, skipLibDups);
-    }
-
-    public synchronized void addClassPromise(DexClassPromise promise, boolean skipLibDups) {
-      assert promise != null;
-      DexType type = promise.getType();
-      DexClassPromise oldPromise = classMap.get(type);
-      if (oldPromise != null) {
-        promise = chooseClass(promise, oldPromise, skipLibDups);
-      }
-      if (oldPromise != promise) {
-        classMap.put(type, promise);
-      }
+    public Collection<DexProgramClass> getProgramClasses() {
+      return programClasses;
     }
 
     public Builder addToMainDexList(Collection<DexType> mainDexList) {
@@ -343,90 +389,13 @@
     public DexApplication build() {
       return new DexApplication(
           proguardMap,
-          ImmutableMap.copyOf(classMap),
-          lazyClassCollection,
+          ProgramClassCollection.create(programClasses),
+          classpathClasses,
+          libraryClasses,
           ImmutableSet.copyOf(mainDexList),
           dexItemFactory,
           highestSortingString,
           timing);
     }
   }
-
-  public static DexClassPromise chooseClass(
-      DexClassPromise a, DexClassPromise b, boolean skipLibDups) {
-    // NOTE: We assume that there should not be any conflicting names in user defined
-    // classes and/or linked jars. If we ever want to allow 'keep first'-like policy
-    // to resolve this kind of conflict between program and/or classpath classes, we'll
-    // need to make sure we choose the class we keep deterministically.
-    if (a.isProgramClass() && b.isProgramClass()) {
-      if (allowProgramClassConflict(a, b)) {
-        return a;
-      }
-      throw new CompilationError(
-          "Program type already present: " + a.getType().toSourceString());
-    }
-    if (a.isProgramClass()) {
-      return chooseBetweenProgramAndOtherClass(a, b);
-    }
-    if (b.isProgramClass()) {
-      return chooseBetweenProgramAndOtherClass(b, a);
-    }
-
-    if (a.isClasspathClass() && b.isClasspathClass()) {
-      throw new CompilationError(
-          "Classpath type already present: " + a.getType().toSourceString());
-    }
-    if (a.isClasspathClass()) {
-      return chooseBetweenClasspathAndLibraryClass(a, b);
-    }
-    if (b.isClasspathClass()) {
-      return chooseBetweenClasspathAndLibraryClass(b, a);
-    }
-
-    return chooseBetweenLibraryClasses(b, a, skipLibDups);
-  }
-
-  private static boolean allowProgramClassConflict(DexClassPromise a, DexClassPromise b) {
-    // Currently only allow collapsing synthetic lambda classes.
-    return a.getOrigin() == Resource.Kind.DEX
-        && b.getOrigin() == Resource.Kind.DEX
-        && a.get().accessFlags.isSynthetic()
-        && b.get().accessFlags.isSynthetic()
-        && LambdaRewriter.hasLambdaClassPrefix(a.getType())
-        && LambdaRewriter.hasLambdaClassPrefix(b.getType());
-  }
-
-  private static DexClassPromise chooseBetweenProgramAndOtherClass(
-      DexClassPromise selected, DexClassPromise ignored) {
-    assert selected.isProgramClass() && !ignored.isProgramClass();
-    if (ignored.isLibraryClass()) {
-      logIgnoredClass(ignored, "Class `%s` was specified as library and program type.");
-    }
-    // We don't log program/classpath class conflict since it is expected case.
-    return selected;
-  }
-
-  private static DexClassPromise chooseBetweenClasspathAndLibraryClass(
-      DexClassPromise selected, DexClassPromise ignored) {
-    assert selected.isClasspathClass() && ignored.isLibraryClass();
-    logIgnoredClass(ignored, "Class `%s` was specified as library and classpath type.");
-    return selected;
-  }
-
-  private static DexClassPromise chooseBetweenLibraryClasses(
-      DexClassPromise selected, DexClassPromise ignored, boolean skipDups) {
-    assert selected.isLibraryClass() && ignored.isLibraryClass();
-    if (!skipDups) {
-      throw new CompilationError(
-          "Library type already present: " + selected.getType().toSourceString());
-    }
-    logIgnoredClass(ignored, "Class `%s` was specified twice as a library type.");
-    return selected;
-  }
-
-  private static void logIgnoredClass(DexClassPromise ignored, String message) {
-    if (Log.ENABLED) {
-      Log.warn(DexApplication.class, message, ignored.getType().toSourceString());
-    }
-  }
 }
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 f684309..8560de3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -9,7 +9,7 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.google.common.base.MoreObjects;
 
-public abstract class DexClass extends DexItem implements DexClassPromise {
+public abstract class DexClass extends DexItem {
 
   private static final DexEncodedMethod[] NO_METHODS = {};
   private static final DexEncodedField[] NO_FIELDS = {};
@@ -50,6 +50,12 @@
         throw new CompilationError("Interface " + type.toString() + " cannot implement itself");
       }
     }
+    if (!type.descriptor.isValidClassDescriptor()) {
+      throw new CompilationError(
+          "Class descriptor '"
+              + type.descriptor.toString()
+              + "' cannot be represented in dex format.");
+    }
   }
 
   @Override
@@ -118,7 +124,6 @@
 
   public abstract void addDependencies(MixedSectionCollection collector);
 
-  @Override
   public boolean isProgramClass() {
     return false;
   }
@@ -127,7 +132,6 @@
     return null;
   }
 
-  @Override
   public boolean isClasspathClass() {
     return false;
   }
@@ -136,7 +140,6 @@
     return null;
   }
 
-  @Override
   public boolean isLibraryClass() {
     return false;
   }
@@ -154,21 +157,10 @@
     return null;
   }
 
-  @Override
   public Resource.Kind getOrigin() {
     return this.origin;
   }
 
-  @Override
-  public DexClass get() {
-    return this;
-  }
-
-  @Override
-  public DexType getType() {
-    return type;
-  }
-
   public boolean hasClassInitializer() {
     return getClassInitializer() != null;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassPromise.java b/src/main/java/com/android/tools/r8/graph/DexClassPromise.java
deleted file mode 100644
index c0bdf20..0000000
--- a/src/main/java/com/android/tools/r8/graph/DexClassPromise.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2017, 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.graph;
-
-import com.android.tools.r8.Resource;
-
-/**
- * Provides a way for delayed DexClass discovery.
- *
- * Provides minimal class details of the promised class and
- * provides the class when asked by calling method get().
- *
- * Note that DexClass also implements this interface, since it
- * represents a 'materialized' promise for a class.
- */
-public interface DexClassPromise {
-  DexType getType();
-
-  Resource.Kind getOrigin();
-
-  boolean isProgramClass();
-
-  boolean isClasspathClass();
-
-  boolean isLibraryClass();
-
-  DexClass get();
-}
diff --git a/src/main/java/com/android/tools/r8/graph/DexCode.java b/src/main/java/com/android/tools/r8/graph/DexCode.java
index ebfd388..f48e7db 100644
--- a/src/main/java/com/android/tools/r8/graph/DexCode.java
+++ b/src/main/java/com/android/tools/r8/graph/DexCode.java
@@ -15,9 +15,11 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Hashtable;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
@@ -157,10 +159,10 @@
   }
 
   public String toString() {
-    return toString(null);
+    return toString(null, null);
   }
 
-  public String toString(ClassNameMapper naming) {
+  public String toString(DexEncodedMethod method, ClassNameMapper naming) {
     StringBuilder builder = new StringBuilder();
     builder.append("registers: ").append(registerSize);
     builder.append(", inputs: ").append(incomingRegisterSize);
@@ -168,12 +170,22 @@
     builder.append("------------------------------------------------------------\n");
     builder.append("inst#  offset  instruction         arguments\n");
     builder.append("------------------------------------------------------------\n");
+    DexDebugEntry debugInfo = null;
+    Iterator<DexDebugEntry> debugInfoIterator = Collections.emptyIterator();
+    if (getDebugInfo() != null && method != null) {
+      debugInfoIterator = new DexDebugEntryBuilder(method, new DexItemFactory()).build().iterator();
+      debugInfo = debugInfoIterator.hasNext() ? debugInfoIterator.next() : null;
+    }
     int instructionNumber = 0;
     for (Instruction insn : instructions) {
       StringUtils.appendLeftPadded(builder, Integer.toString(instructionNumber++), 5);
       builder.append(": ")
           .append(insn.toString(naming))
           .append('\n');
+      if (debugInfo != null && debugInfo.address == insn.getOffset()) {
+        builder.append("      ").append(debugInfo).append("\n");
+        debugInfo = debugInfoIterator.hasNext() ? debugInfoIterator.next() : null;
+      }
     }
     if (tries.length > 0) {
       builder.append("Tries (numbers are offsets)\n");
diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugEntryBuilder.java b/src/main/java/com/android/tools/r8/graph/DexDebugEntryBuilder.java
index f6d8fb4..4410f2a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDebugEntryBuilder.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugEntryBuilder.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
+import com.android.tools.r8.ir.code.MoveType;
 import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -60,19 +61,19 @@
     DexCode code = method.getCode().asDexCode();
     DexDebugInfo info = code.getDebugInfo();
     int argumentRegister = code.registerSize - code.incomingRegisterSize;
-    int argumentCount = code.incomingRegisterSize;
     if (!method.accessFlags.isStatic()) {
-      --argumentCount;
       DexString name = factory.thisName;
       DexType type = method.method.getHolder();
-      startLocal(argumentRegister++, name, type, null);
+      startLocal(argumentRegister, name, type, null);
+      argumentRegister += MoveType.fromDexType(type).requiredRegisters();
     }
     DexType[] types = method.method.proto.parameters.values;
     DexString[] names = info.parameters;
-    for (int i = 0; i < argumentCount; i++) {
+    for (int i = 0; i < types.length; i++) {
       // If null, the parameter has a parameterized type and the local is introduced in the stream.
       if (names[i] != null) {
-        startLocal(argumentRegister++, names[i], types[i], null);
+        startLocal(argumentRegister, names[i], types[i], null);
+        argumentRegister += MoveType.fromDexType(types[i]).requiredRegisters();
       }
     }
     currentLine = info.startLine;
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 188440d..3df2fab 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -22,7 +22,7 @@
 import com.android.tools.r8.ir.code.MoveType;
 import com.android.tools.r8.ir.code.ValueNumberGenerator;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.regalloc.RegisterAllocator;
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
@@ -73,6 +73,11 @@
     return compilationState != CompilationState.NOT_PROCESSED;
   }
 
+  public boolean cannotInline() {
+    return compilationState == CompilationState.NOT_PROCESSED
+        || compilationState == CompilationState.PROCESSED_NOT_INLINING_CANDIDATE;
+  }
+
   public boolean isInliningCandidate(DexEncodedMethod container, boolean alwaysInline) {
     if (container.accessFlags.isStatic() && container.accessFlags.isConstructor()) {
       // This will probably never happen but never inline a class initializer.
@@ -102,7 +107,8 @@
     return compilationState == PROCESSED_INLINING_CANDIDATE_PUBLIC;
   }
 
-  public void markProcessed(InliningConstraint state) {
+  public boolean markProcessed(Constraint state) {
+    CompilationState prevCompilationState = compilationState;
     switch (state) {
       case ALWAYS:
         compilationState = PROCESSED_INLINING_CANDIDATE_PUBLIC;
@@ -117,6 +123,7 @@
         compilationState = PROCESSED_NOT_INLINING_CANDIDATE;
         break;
     }
+    return prevCompilationState != compilationState;
   }
 
   public void markNotProcessed() {
@@ -341,7 +348,7 @@
   }
 
   public String codeToString() {
-    return code == null ? "<no code>" : code.toString();
+    return code == null ? "<no code>" : code.toString(this, null);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexField.java b/src/main/java/com/android/tools/r8/graph/DexField.java
index f97c147..5616967 100644
--- a/src/main/java/com/android/tools/r8/graph/DexField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexField.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.dex.IndexedItemCollection;
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.naming.NamingLens;
 
 public class DexField extends Descriptor<DexEncodedField, DexField> implements
@@ -17,6 +18,10 @@
     this.clazz = clazz;
     this.type = type;
     this.name = name;
+    if (!name.isValidFieldName()) {
+      throw new CompilationError(
+          "Field name '" + name.toString() + "' cannot be represented in dex format.");
+    }
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index de536f6..a066d24 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.dex.IndexedItemCollection;
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.naming.NamingLens;
 
 public class DexMethod extends Descriptor<DexEncodedMethod, DexMethod>
@@ -20,6 +21,10 @@
     this.holder = holder;
     this.proto = proto;
     this.name = name;
+    if (!name.isValidMethodName()) {
+      throw new CompilationError(
+          "Method name '" + name.toString() + "' cannot be represented in dex format.");
+    }
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexString.java b/src/main/java/com/android/tools/r8/graph/DexString.java
index e9b687e..e70e8f0 100644
--- a/src/main/java/com/android/tools/r8/graph/DexString.java
+++ b/src/main/java/com/android/tools/r8/graph/DexString.java
@@ -185,6 +185,127 @@
     return slowCompareTo(other);
   }
 
+  private boolean isSimpleNameChar(char ch) {
+    if (ch >= 'A' && ch <= 'Z') {
+      return true;
+    }
+    if (ch >= 'a' && ch <= 'z') {
+      return true;
+    }
+    if (ch >= '0' && ch <= '9') {
+      return true;
+    }
+    if (ch == '$' || ch == '-' || ch == '_') {
+      return true;
+    }
+    if (ch >= 0x00a1 && ch <= 0x1fff) {
+      return true;
+    }
+    if (ch >= 0x2010 && ch <= 0x2027) {
+      return true;
+    }
+    if (ch >= 0x2030 && ch <= 0xd7ff) {
+      return true;
+    }
+    if (ch >= 0xe000 && ch <= 0xffef) {
+      return true;
+    }
+    if (ch >= 0x10000 && ch <= 0x10ffff) {
+      return true;
+    }
+    return false;
+  }
+
+  private boolean isValidClassDescriptor(String string) {
+    if (string.length() < 3
+        || string.charAt(0) != 'L'
+        || string.charAt(string.length() - 1) != ';') {
+      return false;
+    }
+    if (string.charAt(1) == '/' || string.charAt(string.length() - 2) == '/') {
+      return false;
+    }
+    for (int i = 1; i < string.length() - 1; i++) {
+      char ch = string.charAt(i);
+      if (ch == '/') {
+        continue;
+      }
+      if (isSimpleNameChar(ch)) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+
+  private boolean isValidMethodName(String string) {
+    if (string.isEmpty()) {
+      return false;
+    }
+    // According to https://source.android.com/devices/tech/dalvik/dex-format#membername
+    // '<' SimpleName '>' should be valid. However, the art verifier only allows <init>
+    // and <clinit> which is reasonable.
+    if ((string.charAt(0) == '<') &&
+        (string.equals("<init>") || string.equals("<clinit>"))) {
+      return true;
+    }
+    for (int i = 0; i < string.length(); i++) {
+      char ch = string.charAt(i);
+      if (isSimpleNameChar(ch)) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+
+  private boolean isValidFieldName(String string) {
+    if (string.isEmpty()) {
+      return false;
+    }
+    int start = 0;
+    int end = string.length();
+    if (string.charAt(0) == '<') {
+      if (string.charAt(string.length() - 1) == '>') {
+        start = 1;
+        end = string.length() - 1;
+      } else {
+        return false;
+      }
+    }
+    for (int i = start; i < end; i++) {
+      if (isSimpleNameChar(string.charAt(i))) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+
+  public boolean isValidMethodName() {
+    try {
+      return isValidMethodName(decode());
+    } catch (UTFDataFormatException e) {
+      return false;
+    }
+  }
+
+  public boolean isValidFieldName() {
+    try {
+      return isValidFieldName(decode());
+    } catch (UTFDataFormatException e) {
+      return false;
+    }
+  }
+
+  public boolean isValidClassDescriptor() {
+    try {
+      return isValidClassDescriptor(decode());
+    } catch (UTFDataFormatException e) {
+      return false;
+    }
+  }
+
   public String dump() {
     StringBuilder builder = new StringBuilder();
     builder.append(toString());
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLense.java b/src/main/java/com/android/tools/r8/graph/GraphLense.java
index e6c2d00..b9173dd 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLense.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLense.java
@@ -6,6 +6,19 @@
 import java.util.IdentityHashMap;
 import java.util.Map;
 
+/**
+ * A GraphLense implements a virtual view on top of the graph, used to delay global rewrites until
+ * later IR processing stages.
+ * <p>
+ * Valid remappings are limited to the following operations:
+ * <ul>
+ * <li>Mapping a classes type to one of the super/subtypes.</li>
+ * <li>Renaming private methods/fields.</li>
+ * <li>Moving methods/fields to a super/subclass.</li>
+ * <li>Replacing method/field references by the same method/field on a super/subtype</li>
+ * </ul>
+ * Note that the latter two have to take visibility into account.
+ */
 public abstract class GraphLense {
 
   public static class Builder {
diff --git a/src/main/java/com/android/tools/r8/graph/JarCode.java b/src/main/java/com/android/tools/r8/graph/JarCode.java
index 2766684..9a367ff 100644
--- a/src/main/java/com/android/tools/r8/graph/JarCode.java
+++ b/src/main/java/com/android/tools/r8/graph/JarCode.java
@@ -112,7 +112,7 @@
   }
 
   @Override
-  public String toString(ClassNameMapper naming) {
+  public String toString(DexEncodedMethod method, ClassNameMapper naming) {
     return toString();
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/LazyClassFileLoader.java b/src/main/java/com/android/tools/r8/graph/LazyClassFileLoader.java
deleted file mode 100644
index e5792cd..0000000
--- a/src/main/java/com/android/tools/r8/graph/LazyClassFileLoader.java
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2017, 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.graph;
-
-import static com.android.tools.r8.utils.FileUtils.DEFAULT_DEX_FILENAME;
-
-import com.android.tools.r8.Resource;
-import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.errors.Unreachable;
-import com.google.common.io.Closer;
-import java.io.IOException;
-
-// Lazily loads a class file represented by resource.
-public final class LazyClassFileLoader implements DexClassPromise {
-  // Resource representing file definition.
-  private final Resource resource;
-  // Class kind to be created.
-  private final ClassKind classKind;
-
-  // Application reader to be used. Note that the reader may be reused in
-  // many loaders and may be used concurrently, it is considered to be
-  // thread-safe since its only state is internal options which we
-  // consider immutable after they are initialized (barring dex factory
-  // which is thread-safe).
-  private final JarApplicationReader reader;
-
-  // Dex type of the class to be created.
-  private final DexType type;
-
-  // Cached loaded class if get(...) method has already been called, this
-  // field is only accessed in context synchronized on `this`.
-  private DexClass loadedClass = null;
-
-  public LazyClassFileLoader(DexType type,
-      Resource resource, ClassKind classKind, JarApplicationReader reader) {
-    this.resource = resource;
-    this.reader = reader;
-    this.type = type;
-    this.classKind = classKind;
-    assert classKind != ClassKind.PROGRAM;
-  }
-
-  // Callback method for JarClassFileReader, is always called in synchronized context.
-  private void addClass(DexClass clazz) {
-    assert clazz != null;
-    assert loadedClass == null;
-    loadedClass = clazz;
-  }
-
-  @Override
-  public DexType getType() {
-    return type;
-  }
-
-  @Override
-  public Resource.Kind getOrigin() {
-    return Resource.Kind.CLASSFILE;
-  }
-
-  @Override
-  public boolean isProgramClass() {
-    return false;
-  }
-
-  @Override
-  public boolean isClasspathClass() {
-    return classKind == ClassKind.CLASSPATH;
-  }
-
-  @Override
-  public boolean isLibraryClass() {
-    return classKind == ClassKind.LIBRARY;
-  }
-
-  // Loads the class from the resource. Synchronized on `this` to avoid
-  // unnecessary complications, thus all threads trying to load a class with
-  // this loader will wait for the first load to finish.
-  @Override
-  public synchronized DexClass get() {
-    if (loadedClass != null) {
-      return loadedClass;
-    }
-
-    try (Closer closer = Closer.create()) {
-      JarClassFileReader reader = new JarClassFileReader(this.reader, this::addClass);
-      reader.read(DEFAULT_DEX_FILENAME, classKind, resource.getStream(closer));
-    } catch (IOException e) {
-      throw new CompilationError("Failed to load class: " + type.toSourceString(), e);
-    }
-
-    if (loadedClass == null) {
-      throw new Unreachable("Class is supposed to be loaded: " + type.toSourceString());
-    }
-
-    if (loadedClass.type != type) {
-      throw new CompilationError("Class content provided for type descriptor "
-          + type.toSourceString() + " actually defines class " + loadedClass.type.toSourceString());
-    }
-
-    return loadedClass;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
index 1d5f38c..7dab70a 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
@@ -79,6 +79,7 @@
 
   private static DexProgramClass[] sortClasses(
       DexApplication application, DexProgramClass[] classes) {
+    Arrays.sort(classes, (o1, o2) -> o1.type.descriptor.slowCompareTo(o2.type.descriptor));
     SortingProgramClassVisitor classVisitor = new SortingProgramClassVisitor(application, classes);
     classVisitor.run(classes);
     return classVisitor.getSortedClasses();
diff --git a/src/main/java/com/android/tools/r8/ir/code/Argument.java b/src/main/java/com/android/tools/r8/ir/code/Argument.java
index 94c415e..94f6507 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Argument.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Argument.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.utils.InternalOptions;
 
 /**
@@ -67,7 +67,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
index 8bb31d2..ab2056d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.code;
 
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.conversion.IRBuilder;
@@ -119,7 +120,7 @@
   public List<BasicBlock> getNormalPredecessors() {
     ImmutableList.Builder<BasicBlock> normals = ImmutableList.builder();
     for (BasicBlock predecessor : predecessors) {
-      if (!predecessor.isCatchSuccessor(this)) {
+      if (!predecessor.hasCatchSuccessor(this)) {
         normals.add(predecessor);
       }
     }
@@ -647,10 +648,10 @@
 
   public EdgeType getEdgeType(BasicBlock successor) {
     assert successors.indexOf(successor) >= 0;
-    return isCatchSuccessor(successor) ? EdgeType.EXCEPTIONAL : EdgeType.NORMAL;
+    return hasCatchSuccessor(successor) ? EdgeType.EXCEPTIONAL : EdgeType.NORMAL;
   }
 
-  public boolean isCatchSuccessor(BasicBlock block) {
+  public boolean hasCatchSuccessor(BasicBlock block) {
     if (!hasCatchHandlers()) {
       return false;
     }
@@ -658,7 +659,7 @@
   }
 
   public int guardsForCatchSuccessor(BasicBlock block) {
-    assert isCatchSuccessor(block);
+    assert hasCatchSuccessor(block);
     int index = successors.indexOf(block);
     int count = 0;
     for (int handler : catchHandlers.getAllTargets()) {
@@ -694,7 +695,7 @@
       StringBuilder builder, List<BasicBlock> list, Function<BasicBlock, String> postfix) {
     if (list.size() > 0) {
       for (BasicBlock block : list) {
-        builder.append(block.getNumber());
+        builder.append(block.number >= 0 ? block.number : "<unknown>");
         builder.append(postfix.apply(block));
         builder.append(" ");
       }
@@ -713,7 +714,7 @@
   }
 
   private String predecessorPostfix(BasicBlock block) {
-    if (isCatchSuccessor(block)) {
+    if (hasCatchSuccessor(block)) {
       return new String(new char[guardsForCatchSuccessor(block)]).replace("\0", "*");
     }
     return "";
@@ -1053,7 +1054,7 @@
     // one new phi to merge the two exception values, and all other phis don't need
     // to be changed.
     for (BasicBlock catchSuccessor : catchSuccessors) {
-      catchSuccessor.splitCriticalExceptioEdges(
+      catchSuccessor.splitCriticalExceptionEdges(
           code.valueNumberGenerator,
           newBlock -> {
             newBlock.setNumber(code.blocks.size());
@@ -1062,15 +1063,6 @@
     }
   }
 
-  private boolean allPredecessorsHaveCatchEdges() {
-    for (BasicBlock predecessor : getPredecessors()) {
-      if (!predecessor.isCatchSuccessor(this)) {
-        assert false;
-      }
-    }
-    return true;
-  }
-
   /**
    * Assumes that `this` block is a catch handler target (note that it does not have to
    * start with MoveException instruction, since the instruction can be removed by
@@ -1086,10 +1078,8 @@
    *
    * NOTE: onNewBlock must assign block number to the newly created block.
    */
-  public void splitCriticalExceptioEdges(
+  public void splitCriticalExceptionEdges(
       ValueNumberGenerator valueNumberGenerator, Consumer<BasicBlock> onNewBlock) {
-    assert allPredecessorsHaveCatchEdges();
-
     List<BasicBlock> predecessors = this.getPredecessors();
     boolean hasMoveException = entry().isMoveException();
     MoveException move = null;
@@ -1103,6 +1093,10 @@
     List<BasicBlock> newPredecessors = new ArrayList<>();
     List<Value> values = new ArrayList<>(predecessors.size());
     for (BasicBlock predecessor : predecessors) {
+      if (!predecessor.hasCatchSuccessor(this)) {
+        throw new CompilationError(
+            "Invalid block structure: catch block reachable via non-exceptional flow.");
+      }
       BasicBlock newBlock = new BasicBlock();
       newPredecessors.add(newBlock);
       if (hasMoveException) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/Binop.java b/src/main/java/com/android/tools/r8/ir/code/Binop.java
index 83240bb..899516a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Binop.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Binop.java
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 public abstract class Binop extends Instruction {
 
@@ -112,7 +112,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
index 451832f..4cca9dd 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
@@ -15,7 +15,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.utils.NumberUtils;
 
 public class ConstNumber extends ConstInstruction {
@@ -188,7 +188,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Div.java b/src/main/java/com/android/tools/r8/ir/code/Div.java
index c8c1c32..8fd9bf0 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Div.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Div.java
@@ -14,9 +14,6 @@
 import com.android.tools.r8.code.DivIntLit8;
 import com.android.tools.r8.code.DivLong;
 import com.android.tools.r8.code.DivLong2Addr;
-import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
 
 public class Div extends ArithmeticBinop {
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
index ba1e0e9..0b8d876 100644
--- a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
@@ -9,8 +9,7 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.Inliner;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import java.util.List;
 
 abstract class FieldInstruction extends Instruction {
@@ -43,7 +42,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
     // Resolve the field if possible and decide whether the instruction can inlined.
     DexType fieldHolder = field.getHolder();
     DexEncodedField target = info.lookupInstanceTarget(fieldHolder, field);
@@ -51,15 +50,15 @@
     if ((target != null) && (fieldClass != null) && !fieldClass.isLibraryClass()) {
       DexAccessFlags flags = target.accessFlags;
       if (flags.isPublic()) {
-        return Inliner.InliningConstraint.ALWAYS;
+        return Constraint.ALWAYS;
       }
       if (flags.isPrivate() && (fieldHolder == holder)) {
-        return Inliner.InliningConstraint.PRIVATE;
+        return Constraint.PRIVATE;
       }
       if (flags.isProtected() && (fieldHolder.isSamePackage(holder))) {
-        return Inliner.InliningConstraint.PACKAGE;
+        return Constraint.PACKAGE;
       }
     }
-    return Inliner.InliningConstraint.NEVER;
+    return Constraint.NEVER;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstanceOf.java b/src/main/java/com/android/tools/r8/ir/code/InstanceOf.java
index 3fe498d..1126299 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstanceOf.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstanceOf.java
@@ -9,7 +9,7 @@
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 public class InstanceOf extends Instruction {
 
@@ -75,14 +75,14 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
     DexClass targetClass = info.definitionFor(type());
     if (targetClass == null) {
-      return InliningConstraint.NEVER;
+      return Constraint.NEVER;
     }
     if (targetClass.accessFlags.isPublic()) {
-      return InliningConstraint.ALWAYS;
+      return Constraint.ALWAYS;
     }
-    return InliningConstraint.NEVER;
+    return Constraint.NEVER;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index 1b18ccc..2e821cf 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -9,7 +9,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.code.Value.DebugInfo;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.regalloc.RegisterAllocator;
 import com.android.tools.r8.utils.CfgPrinter;
 import com.android.tools.r8.utils.InternalOptions;
@@ -797,7 +797,7 @@
   }
 
   // Returns the inlining constraint for this instruction.
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.NEVER;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.NEVER;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Invoke.java b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
index 5b516b7..14104d7 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Invoke.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
@@ -91,8 +91,14 @@
   }
 
   protected int argumentRegisterValue(int i, DexBuilder builder) {
+    assert needsRangedInvoke(builder);
     if (i < arguments().size()) {
-      return builder.allocatedRegister(arguments().get(i), getNumber());
+      // If argument values flow into ranged invokes, all the ranged invoke arguments
+      // are arguments to this method in order. Therefore, we use the incoming registers
+      // for the ranged invoke arguments. We know that arguments are always available there.
+      // If argument reuse is allowed there is no splitting and if argument reuse is disallowed
+      // the argument registers are never overwritten.
+      return builder.argumentOrAllocateRegister(arguments().get(i), getNumber());
     }
     return 0;
   }
@@ -120,10 +126,10 @@
 
   protected boolean argumentsConsecutive(DexBuilder builder) {
     Value value = arguments().get(0);
-    int next = builder.allocatedRegister(value, getNumber()) + value.requiredRegisters();
+    int next = builder.argumentOrAllocateRegister(value, getNumber()) + value.requiredRegisters();
     for (int i = 1; i < arguments().size(); i++) {
       value = arguments().get(i);
-      assert next == builder.allocatedRegister(value, getNumber());
+      assert next == builder.argumentOrAllocateRegister(value, getNumber());
       next += value.requiredRegisters();
     }
     return true;
@@ -162,9 +168,45 @@
     if (requiredArgumentRegisters() > 5) {
       return Constants.U16BIT_MAX;
     }
+    if (argumentsAreConsecutiveInputArguments()) {
+      return Constants.U16BIT_MAX;
+    }
     return Constants.U4BIT_MAX;
   }
 
+  private boolean argumentsAreConsecutiveInputArguments() {
+    if (arguments().size() == 0) {
+      return false;
+    }
+    Value current = arguments().get(0);
+    if (!current.isArgument()) {
+      return false;
+    }
+    for (int i = 1; i < arguments().size(); i++) {
+      Value next = arguments().get(i);
+      if (current.getNextConsecutive() != next) {
+        return false;
+      }
+      current = next;
+    }
+    return true;
+  }
+
+  private boolean argumentsAreConsecutiveInputArgumentsWithHighRegisters(
+      DexBuilder builder) {
+    if (!argumentsAreConsecutiveInputArguments()) {
+      return false;
+    }
+    Value lastArgument = arguments().get(arguments().size() - 1);
+    return builder.argumentOrAllocateRegister(lastArgument, getNumber()) > Constants.U4BIT_MAX;
+  }
+
+  protected boolean needsRangedInvoke(DexBuilder builder) {
+    return requiredArgumentRegisters() > 5
+        || hasHighArgumentRegister(builder)
+        || argumentsAreConsecutiveInputArgumentsWithHighRegisters(builder);
+  }
+
   @Override
   public int maxOutValueRegister() {
     return Constants.U8BIT_MAX;
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java b/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
index 2c7ea4b..d0d0739 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeCustom.java
@@ -50,7 +50,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeCustomRange(firstRegister, argumentRegisters, getCallSite());
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
index 95776f4..f11d62f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
@@ -39,7 +39,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeDirectRange(firstRegister, argumentRegisters, getInvokedMethod());
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
index f1c1d65..9d0c01f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
@@ -38,7 +38,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeInterfaceRange(firstRegister, argumentRegisters, getInvokedMethod());
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
index 0725fed..2912c1a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeNewArray.java
@@ -49,7 +49,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new FilledNewArrayRange(firstRegister, argumentRegisters, type);
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
index 9c87144..efc12db 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
@@ -47,7 +47,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokePolymorphicRange(
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
index 0c4fe14..dc22e2e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
@@ -38,7 +38,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeStaticRange(firstRegister, argumentRegisters, getInvokedMethod());
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
index 2e1e3e7..fc79c11 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
@@ -38,7 +38,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeSuperRange(firstRegister, argumentRegisters, getInvokedMethod());
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
index 339ae71..3988980 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
@@ -38,7 +38,7 @@
     com.android.tools.r8.code.Instruction instruction;
     int argumentRegisters = requiredArgumentRegisters();
     builder.requestOutgoingRegisters(argumentRegisters);
-    if (argumentRegisters > 5 || hasHighArgumentRegister(builder)) {
+    if (needsRangedInvoke(builder)) {
       assert argumentsConsecutive(builder);
       int firstRegister = argumentRegisterValue(0, builder);
       instruction = new InvokeVirtualRange(firstRegister, argumentRegisters, getInvokedMethod());
diff --git a/src/main/java/com/android/tools/r8/ir/code/JumpInstruction.java b/src/main/java/com/android/tools/r8/ir/code/JumpInstruction.java
index 2a02218..7b1c007 100644
--- a/src/main/java/com/android/tools/r8/ir/code/JumpInstruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/JumpInstruction.java
@@ -5,7 +5,7 @@
 
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.utils.InternalOptions;
 import java.util.List;
 
@@ -47,7 +47,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Monitor.java b/src/main/java/com/android/tools/r8/ir/code/Monitor.java
index 869d1d0..b3e155b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Monitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Monitor.java
@@ -29,7 +29,15 @@
 
   @Override
   public void buildDex(DexBuilder builder) {
-    int object = builder.allocatedRegister(object(), getNumber());
+    // If the monitor object is an argument, we use the argument register for all the monitor
+    // enters and exits in order to not confuse the Art verifier lock verification code.
+    // This is best effort. If the argument happens to be in a very high register we cannot
+    // do it and the lock verification can hit a case where it gets confused. Not much we
+    // can do about that, but this should avoid it in the most common cases.
+    int object = builder.argumentOrAllocateRegister(object(), getNumber());
+    if (object > maxInValueRegister()) {
+      object = builder.allocatedRegister(object(), getNumber());
+    }
     if (type == Type.ENTER) {
       builder.add(this, new MonitorEnter(object));
     } else {
diff --git a/src/main/java/com/android/tools/r8/ir/code/Move.java b/src/main/java/com/android/tools/r8/ir/code/Move.java
index 6f70c57..91e19f0 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Move.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Move.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 public class Move extends Instruction {
 
@@ -81,7 +81,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Phi.java b/src/main/java/com/android/tools/r8/ir/code/Phi.java
index 5912f0f..de44e83 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Phi.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Phi.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.code;
 
+import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.ir.code.BasicBlock.EdgeType;
 import com.android.tools.r8.ir.conversion.IRBuilder;
@@ -60,6 +61,9 @@
     // exactly once by adding the operands.
     assert operands.isEmpty();
     boolean canBeNull = false;
+    if (block.getPredecessors().size() == 0) {
+      throwUndefinedValueError();
+    }
     for (BasicBlock pred : block.getPredecessors()) {
       EdgeType edgeType = pred.getEdgeType(block);
       // Since this read has been delayed we must provide the local info for the value.
@@ -79,6 +83,9 @@
     // exactly once by adding the operands.
     assert this.operands.isEmpty();
     boolean canBeNull = false;
+    if (operands.size() == 0) {
+      throwUndefinedValueError();
+    }
     for (Value operand : operands) {
       canBeNull |= operand.canBeNull();
       appendOperand(operand);
@@ -89,6 +96,13 @@
     removeTrivialPhi();
   }
 
+  private void throwUndefinedValueError() {
+    throw new CompilationError(
+        "Undefined value encountered during compilation. "
+            + "This is typically caused by invalid dex input that uses a register "
+            + "that is not define on all control-flow paths leading to the use.");
+  }
+
   private void appendOperand(Value operand) {
     operands.add(operand);
     operand.addPhiUser(this);
@@ -174,9 +188,6 @@
       same = op;
     }
     assert isTrivialPhi();
-    if (same == null) {
-      same = Value.UNDEFINED;
-    }
     // Removing this phi, so get rid of it as a phi user from all of the operands to avoid
     // recursively getting back here with the same phi. If the phi has itself as an operand
     // that also removes the self-reference.
diff --git a/src/main/java/com/android/tools/r8/ir/code/Return.java b/src/main/java/com/android/tools/r8/ir/code/Return.java
index 2819c58..142206c 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Return.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Return.java
@@ -11,7 +11,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 public class Return extends JumpInstruction {
 
@@ -110,7 +110,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Throw.java b/src/main/java/com/android/tools/r8/ir/code/Throw.java
index e0ba866..9bd6a81 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Throw.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Throw.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.conversion.DexBuilder;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 public class Throw extends JumpInstruction {
 
@@ -63,7 +63,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/Unop.java b/src/main/java/com/android/tools/r8/ir/code/Unop.java
index ff1744a..174b7b6 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Unop.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Unop.java
@@ -6,7 +6,7 @@
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 
 abstract public class Unop extends Instruction {
 
@@ -43,7 +43,7 @@
   }
 
   @Override
-  public InliningConstraint inliningConstraint(AppInfo info, DexType holder) {
-    return InliningConstraint.ALWAYS;
+  public Constraint inliningConstraint(AppInfo info, DexType holder) {
+    return Constraint.ALWAYS;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
index bd48134..c506867 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
@@ -19,6 +19,8 @@
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -134,10 +136,14 @@
 
     private final List<DexEncodedMethod> leaves;
     private final boolean brokeCycles;
+    private final Map<DexEncodedMethod, Set<DexEncodedMethod>> cycleBreakingCalls;
 
-    private Leaves(List<DexEncodedMethod> leaves, boolean brokeCycles) {
+    private Leaves(List<DexEncodedMethod> leaves, boolean brokeCycles,
+        Map<DexEncodedMethod, Set<DexEncodedMethod>> cycleBreakingCalls) {
       this.leaves = leaves;
       this.brokeCycles = brokeCycles;
+      this.cycleBreakingCalls = cycleBreakingCalls;
+      assert brokeCycles == (cycleBreakingCalls.size() != 0);
     }
 
     public int size() {
@@ -152,31 +158,38 @@
       return brokeCycles;
     }
 
+    /**
+     * Calls that were broken to produce the leaves.
+     *
+     * If {@link Leaves#breakCycles()} return <code>true</code> this provides the calls for each
+     * leaf that were broken.
+     *
+     * NOTE: The broken calls are not confined to the set of leaves.
+     */
+    public Map<DexEncodedMethod, Set<DexEncodedMethod>> getCycleBreakingCalls() {
+      return cycleBreakingCalls;
+    }
+
     @Override
     public String toString() {
       StringBuilder builder = new StringBuilder();
       builder.append("Leaves: ");
       builder.append(leaves.size());
       builder.append("\n");
-      builder.append(brokeCycles ? "Cycles broken" : "No cycles broken");
+      builder.append(brokeCycles ? "Call cycles broken" : "No call cycles broken");
       return builder.toString();
     }
   }
 
-  private final GraphLense graphLense;
   private final Map<DexEncodedMethod, Node> nodes = new LinkedHashMap<>();
   private List<Node> leaves = null;
   private Set<DexEncodedMethod> singleCallSite = Sets.newIdentityHashSet();
   private Set<DexEncodedMethod> doubleCallSite = Sets.newIdentityHashSet();
 
-  private CallGraph(GraphLense graphLense) {
-    this.graphLense = graphLense;
-  }
-
   public static CallGraph build(DexApplication application, AppInfoWithSubtyping appInfo,
       GraphLense graphLense) {
 
-    CallGraph graph = new CallGraph(graphLense);
+    CallGraph graph = new CallGraph();
 
     for (DexClass clazz : application.classes()) {
       for (DexEncodedMethod method : clazz.directMethods()) {
@@ -279,18 +292,19 @@
    * <p>
    *
    * @return object with the leaves as a List of {@link DexEncodedMethod} and <code>boolean</code>
-   * indication of whether cycels where broken to produce leaves. <code>null</code> if the graph is
+   * indication of whether cycles were broken to produce leaves. <code>null</code> if the graph is
    * empty.
    */
   public Leaves pickLeaves() {
     boolean cyclesBroken = false;
+    Map<DexEncodedMethod, Set<DexEncodedMethod>> brokenCalls = Collections.emptyMap();
     if (isEmpty()) {
       return null;
     }
     List<DexEncodedMethod> leaves = removeLeaves();
     if (leaves.size() == 0) {
       // The graph had no more leaves, so break cycles to construct leaves.
-      breakCycles();
+      brokenCalls = breakCycles();
       cyclesBroken = true;
       leaves = removeLeaves();
     }
@@ -298,7 +312,7 @@
     for (DexEncodedMethod leaf : leaves) {
       assert !leaf.isProcessed();
     }
-    return new Leaves(leaves, cyclesBroken);
+    return new Leaves(leaves, cyclesBroken, brokenCalls);
   }
 
   /**
@@ -309,35 +323,41 @@
    * (outgoing) degree.
    * <p>
    * It will avoid removing edges from bridge-methods if possible.
+   * <p>
+   * Returns the calls that were broken.
    */
-  private void breakCycles() {
+  private Map<DexEncodedMethod, Set<DexEncodedMethod>> breakCycles() {
+    Map<DexEncodedMethod, Set<DexEncodedMethod>> brokenCalls = new IdentityHashMap<>();
     // Break non bridges with degree 1.
     int minDegree = nodes.size();
     for (Node node : nodes.values()) {
       // Break cycles and add all leaves created in the process.
       if (!node.isBridge() && node.callDegree() <= 1) {
         assert node.callDegree() == 1;
-        removeAllCalls(node);
+        Set<DexEncodedMethod> calls = removeAllCalls(node);
         leaves.add(node);
+        brokenCalls.put(node.method, calls);
       } else {
         minDegree = Integer.min(minDegree, node.callDegree());
       }
     }
 
-    // Return if new leaves where created.
+    // Return if new leaves were created.
     if (leaves.size() > 0) {
-      return;
+      return brokenCalls;
     }
 
     // Break methods with the found minimum degree and add all leaves created in the process.
     for (Node node : nodes.values()) {
       if (node.callDegree() <= minDegree) {
         assert node.callDegree() == minDegree;
-        removeAllCalls(node);
+        Set<DexEncodedMethod> calls = removeAllCalls(node);
         leaves.add(node);
+        brokenCalls.put(node.method, calls);
       }
     }
     assert leaves.size() > 0;
+    return brokenCalls;
   }
 
   synchronized private Node ensureMethodNode(DexEncodedMethod method) {
@@ -356,11 +376,14 @@
     callee.invokeCount++;
   }
 
-  private void removeAllCalls(Node node) {
+  private Set<DexEncodedMethod> removeAllCalls(Node node) {
+    Set<DexEncodedMethod> calls = Sets.newIdentityHashSet();
     for (Node call : node.calls) {
+      calls.add(call.method);
       call.callees.remove(node);
     }
     node.calls.clear();
+    return calls;
   }
 
   private void remove(Node node, List<Node> leaves) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/DexBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/DexBuilder.java
index 4484aec..50afe5f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/DexBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/DexBuilder.java
@@ -318,6 +318,12 @@
     return registerAllocator.getRegisterForValue(value, instructionNumber);
   }
 
+  // Get the argument register for a value if it is an argument, otherwise returns the
+  // allocated register at the instruction number.
+  public int argumentOrAllocateRegister(Value value, int instructionNumber) {
+    return registerAllocator.getArgumentOrAllocateRegisterForValue(value, instructionNumber);
+  }
+
   public boolean argumentValueUsesHighRegister(Value value, int instructionNumber) {
     return registerAllocator.argumentValueUsesHighRegister(value, instructionNumber);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
index 7e47ed2..118d0eb 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
@@ -268,7 +268,7 @@
   }
 
   @Override
-  public boolean traceInstruction(int index, IRBuilder builder) {
+  public int traceInstruction(int index, IRBuilder builder) {
     Instruction dex = code.instructions[index];
     int offset = dex.getOffset();
     assert !dex.isPayload();
@@ -277,9 +277,9 @@
       // Check that we don't ever have instructions that can throw and have targets.
       assert !dex.canThrow();
       for (int relativeOffset : targets) {
-        builder.ensureSuccessorBlock(offset + relativeOffset);
+        builder.ensureNormalSuccessorBlock(offset, offset + relativeOffset);
       }
-      return true;
+      return index;
     }
     if (dex.canThrow()) {
       // If the instruction can throw and is in a try block, add edges to its catch successors.
@@ -297,7 +297,7 @@
         builder.ensureBlockWithoutEnqueuing(tryRangeStartAddress);
         // Edge to exceptional successors.
         for (Integer handlerOffset : getUniqueTryHandlerOffsets(tryRange)) {
-          builder.ensureSuccessorBlock(handlerOffset);
+          builder.ensureExceptionalSuccessorBlock(offset, handlerOffset);
         }
         // If the following instruction is a move-result include it in this (the invokes) block.
         if (index + 1 < code.instructions.length && isMoveResult(code.instructions[index + 1])) {
@@ -307,29 +307,29 @@
         }
         // Edge to normal successor if any (fallthrough).
         if (!(dex instanceof Throw)) {
-          builder.ensureSuccessorBlock(dex.getOffset() + dex.getSize());
+          builder.ensureNormalSuccessorBlock(offset, dex.getOffset() + dex.getSize());
         }
-        return true;
+        return index;
       }
       // Close the block if the instruction is a throw, otherwise the block remains open.
-      return dex instanceof Throw;
+      return dex instanceof Throw ? index : -1;
     }
     if (dex.isSwitch()) {
       // TODO(zerny): Remove this from block computation.
       switchPayloadResolver.addPayloadUser(dex);
 
       for (int target : switchPayloadResolver.absoluteTargets(dex)) {
-        builder.ensureSuccessorBlock(target);
+        builder.ensureNormalSuccessorBlock(offset, target);
       }
-      builder.ensureSuccessorBlock(offset + dex.getSize());
-      return true;
+      builder.ensureNormalSuccessorBlock(offset, offset + dex.getSize());
+      return index;
     }
     // TODO(zerny): Remove this from block computation.
     if (dex.hasPayload()) {
       arrayFilledDataPayloadResolver.addPayloadUser((FillArrayData) dex);
     }
     // This instruction does not close the block.
-    return false;
+    return -1;
   }
 
   private boolean inTryRange(Try tryItem, int offset) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index bd8a469..8cd9a2a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -81,9 +81,14 @@
 import com.android.tools.r8.ir.code.ValueNumberGenerator;
 import com.android.tools.r8.ir.code.Xor;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.StringUtils.BraceType;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceAVLTreeMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
+import it.unimi.dsi.fastutil.ints.IntArraySet;
+import it.unimi.dsi.fastutil.ints.IntIterator;
+import it.unimi.dsi.fastutil.ints.IntSet;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -101,6 +106,8 @@
  */
 public class IRBuilder {
 
+  public static final int INITIAL_BLOCK_OFFSET = -1;
+
   // SSA construction uses a worklist of basic blocks reachable from the entry and their
   // instruction offsets.
   private static class WorklistItem {
@@ -158,8 +165,64 @@
     }
   }
 
+  public static class BlockInfo {
+    BasicBlock block = new BasicBlock();
+    IntSet normalPredecessors = new IntArraySet();
+    IntSet normalSuccessors = new IntArraySet();
+    IntSet exceptionalPredecessors = new IntArraySet();
+    IntSet exceptionalSuccessors = new IntArraySet();
+
+    void addNormalPredecessor(int offset) {
+      normalPredecessors.add(offset);
+    }
+
+    void addNormalSuccessor(int offset) {
+      normalSuccessors.add(offset);
+    }
+
+    void replaceNormalPredecessor(int existing, int replacement) {
+      normalPredecessors.remove(existing);
+      normalPredecessors.add(replacement);
+    }
+
+    void addExceptionalPredecessor(int offset) {
+      exceptionalPredecessors.add(offset);
+    }
+
+    void addExceptionalSuccessor(int offset) {
+      exceptionalSuccessors.add(offset);
+    }
+
+    int predecessorCount() {
+      return normalPredecessors.size() + exceptionalPredecessors.size();
+    }
+
+    BlockInfo split(
+        int blockStartOffset, int fallthroughOffset, Int2ReferenceMap<BlockInfo> targets) {
+      BlockInfo fallthroughInfo = new BlockInfo();
+      fallthroughInfo.normalPredecessors = new IntArraySet(Collections.singleton(blockStartOffset));
+      fallthroughInfo.block.incrementUnfilledPredecessorCount();
+      // Move all normal successors to the fallthrough block.
+      IntIterator normalSuccessorIterator = normalSuccessors.iterator();
+      while (normalSuccessorIterator.hasNext()) {
+        BlockInfo normalSuccessor = targets.get(normalSuccessorIterator.nextInt());
+        normalSuccessor.replaceNormalPredecessor(blockStartOffset, fallthroughOffset);
+      }
+      fallthroughInfo.normalSuccessors = normalSuccessors;
+      normalSuccessors = new IntArraySet(Collections.singleton(fallthroughOffset));
+      // Copy all exceptional successors to the fallthrough block.
+      IntIterator exceptionalSuccessorIterator = fallthroughInfo.exceptionalSuccessors.iterator();
+      while (exceptionalSuccessorIterator.hasNext()) {
+        BlockInfo exceptionalSuccessor = targets.get(exceptionalSuccessorIterator.nextInt());
+        exceptionalSuccessor.addExceptionalPredecessor(fallthroughOffset);
+      }
+      fallthroughInfo.exceptionalSuccessors = new IntArraySet(this.exceptionalSuccessors);
+      return fallthroughInfo;
+    }
+  }
+
   // Mapping from instruction offsets to basic-block targets.
-  private final Map<Integer, BasicBlock> targets = new HashMap<>();
+  private final Int2ReferenceSortedMap<BlockInfo> targets = new Int2ReferenceAVLTreeMap<>();
 
   // Worklist of reachable blocks.
   private final Queue<Integer> traceBlocksWorklist = new LinkedList<>();
@@ -219,6 +282,10 @@
     this.options = options;
   }
 
+  public Int2ReferenceSortedMap<BlockInfo> getCFG() {
+    return targets;
+  }
+
   private void addToWorklist(BasicBlock block, int firstInstructionIndex) {
     // TODO(ager): Filter out the ones that are already in the worklist, mark bit in block?
     if (!block.isFilled()) {
@@ -239,13 +306,8 @@
     assert source != null;
     source.setUp();
 
-    // Create entry block.
-    setCurrentBlock(new BasicBlock());
-
-    // If the method needs a prelude, the entry block must never be the target of other blocks.
-    if (!source.needsPrelude()) {
-      targets.put(0, currentBlock);
-    }
+    // Create entry block (at a non-targetable address).
+    targets.put(INITIAL_BLOCK_OFFSET, new BlockInfo());
 
     // Process reachable code paths starting from instruction 0.
     processedInstructions = new boolean[source.instructionCount()];
@@ -260,15 +322,18 @@
       // Process each instruction until the block is closed.
       for (int index = startOfBlockIndex; index < source.instructionCount(); ++index) {
         markIndexProcessed(index);
-        boolean closed = source.traceInstruction(index, this);
-        if (closed) {
+        int closedAt = source.traceInstruction(index, this);
+        if (closedAt != -1) {
+          if (closedAt + 1 < source.instructionCount()) {
+            ensureBlockWithoutEnqueuing(source.instructionOffset(closedAt + 1));
+          }
           break;
         }
         // If the next instruction starts a block, fall through to it.
         if (index + 1 < source.instructionCount()) {
           int nextOffset = source.instructionOffset(index + 1);
-          if (getTarget(nextOffset) != null) {
-            ensureSuccessorBlock(nextOffset);
+          if (targets.get(nextOffset) != null) {
+            ensureNormalSuccessorBlock(startOfBlockOffset, nextOffset);
             break;
           }
         }
@@ -276,6 +341,7 @@
     }
     processedInstructions = null;
 
+    setCurrentBlock(targets.get(INITIAL_BLOCK_OFFSET).block);
     source.buildPrelude(this);
 
     // Process normal blocks reachable from the entry block using a worklist of reachable
@@ -311,9 +377,6 @@
     // necessary.
     splitCriticalEdges();
 
-    // Consistency check.
-    assert phiOperandsAreConsistent();
-
     // Package up the IR code.
     IRCode ir = new IRCode(method, blocks, normalExitBlock, valueNumberGenerator);
 
@@ -340,11 +403,36 @@
 
   private boolean verifyFilledPredecessors() {
     for (BasicBlock block : blocks) {
-      assert block.verifyFilledPredecessors();
+      assert verifyFilledPredecessors(block);
     }
     return true;
   }
 
+  private boolean verifyFilledPredecessors(BasicBlock block) {
+    assert block.verifyFilledPredecessors();
+    // TODO(zerny): Consider moving the validation of the initial control-flow graph to after its
+    // construction and prior to building the IR.
+    for (BlockInfo info : targets.values()) {
+      if (info != null && info.block == block) {
+        assert info.predecessorCount() == block.getPredecessors().size();
+        assert info.normalSuccessors.size() == block.getNormalSucessors().size();
+        if (block.hasCatchHandlers()) {
+          assert info.exceptionalSuccessors.size()
+              == block.getCatchHandlers().getUniqueTargets().size();
+        } else {
+          assert !block.canThrow()
+              || info.exceptionalSuccessors.isEmpty()
+              || (info.exceptionalSuccessors.size() == 1
+                  && info.exceptionalSuccessors.iterator().nextInt() < 0);
+        }
+        return true;
+      }
+    }
+    // There are places where we add in new blocks that we do not represent in the initial CFG.
+    // TODO(zerny): Should we maintain the initial CFG after instruction building?
+    return true;
+  }
+
   private int processWorklist(int blockNumber) {
     for (WorklistItem item = ssaWorklist.poll(); item != null; item = ssaWorklist.poll()) {
       if (item.block.isFilled()) {
@@ -359,11 +447,11 @@
           source.closedCurrentBlock();
           break;
         }
-        BasicBlock block = getTarget(source.instructionOffset(i));
-        if (block != null && block != currentBlock) {
-          closeCurrentBlockWithFallThrough(block);
+        BlockInfo info = targets.get(source.instructionOffset(i));
+        if (info != null && info.block != currentBlock) {
+          closeCurrentBlockWithFallThrough(info.block);
           source.closedCurrentBlockWithFallthrough(i);
-          addToWorklist(block, i);
+          addToWorklist(info.block, i);
           break;
         }
         source.buildInstruction(this, i);
@@ -722,7 +810,7 @@
   public void addGoto(int targetOffset) {
     addInstruction(new Goto());
     BasicBlock targetBlock = getTarget(targetOffset);
-    if (currentBlock.isCatchSuccessor(targetBlock)) {
+    if (currentBlock.hasCatchSuccessor(targetBlock)) {
       needGotoToCatchBlocks.add(new BasicBlock.Pair(currentBlock, targetBlock));
     } else {
       currentBlock.link(targetBlock);
@@ -998,9 +1086,15 @@
 
   public void addMoveException(int dest) {
     Value out = writeRegister(dest, MoveType.OBJECT, ThrowingInfo.NO_THROW);
+    assert out.getDebugInfo() == null;
     MoveException instruction = new MoveException(out);
     assert !instruction.instructionTypeCanThrow();
-    assert currentBlock.getInstructions().isEmpty();
+    if (!currentBlock.getInstructions().isEmpty()) {
+      throw new CompilationError("Invalid MoveException instruction encountered. "
+          + "The MoveException instruction is not the first instruction in the block in "
+          + method.qualifiedName()
+          + ".");
+    }
     addInstruction(instruction);
   }
 
@@ -1151,7 +1245,8 @@
       // If this was a packed switch with only fallthrough cases we can make it a goto.
       // Oddly, this does happen.
       if (numberOfFallthroughs == numberOfTargets) {
-        targets.get(fallthroughOffset).decrementUnfilledPredecessorCount(numberOfFallthroughs);
+        BlockInfo info = targets.get(fallthroughOffset);
+        info.block.decrementUnfilledPredecessorCount(numberOfFallthroughs);
         addGoto(fallthroughOffset);
         return;
       }
@@ -1161,7 +1256,8 @@
       int bytesSaved = packedSwitchPayloadSize - sparseSwitchPayloadSize;
       // Perform the rewrite if we can reduce the payload size by more than 20%.
       if (bytesSaved > (packedSwitchPayloadSize / 5)) {
-        targets.get(fallthroughOffset).decrementUnfilledPredecessorCount(numberOfFallthroughs);
+        BlockInfo info = targets.get(fallthroughOffset);
+        info.block.decrementUnfilledPredecessorCount(numberOfFallthroughs);
         int nextCaseIndex = 0;
         int currentKey = keys[0];
         keys = new int[numberOfSparseTargets];
@@ -1458,10 +1554,16 @@
     BasicBlock block = new BasicBlock();
     blocks.add(block);
     block.incrementUnfilledPredecessorCount();
-    for (Integer offset : source.getCurrentCatchHandlers().getUniqueTargets()) {
-      BasicBlock target = getTarget(offset);
-      assert !target.isSealed();
-      target.incrementUnfilledPredecessorCount();
+    int freshOffset = INITIAL_BLOCK_OFFSET - 1;
+    while (targets.containsKey(freshOffset)) {
+      freshOffset--;
+    }
+    targets.put(freshOffset, null);
+    for (int offset : source.getCurrentCatchHandlers().getUniqueTargets()) {
+      BlockInfo target = targets.get(offset);
+      assert !target.block.isSealed();
+      target.block.incrementUnfilledPredecessorCount();
+      target.addExceptionalPredecessor(freshOffset);
     }
     addInstruction(new Goto());
     currentBlock.link(block);
@@ -1499,21 +1601,32 @@
   // Package (ie, SourceCode accessed) helpers.
 
   // Ensure there is a block starting at offset.
-  BasicBlock ensureBlockWithoutEnqueuing(int offset) {
-    BasicBlock block = targets.get(offset);
-    if (block == null) {
-      block = new BasicBlock();
-      targets.put(offset, block);
+  BlockInfo ensureBlockWithoutEnqueuing(int offset) {
+    assert offset != INITIAL_BLOCK_OFFSET;
+    BlockInfo info = targets.get(offset);
+    if (info == null) {
       // If this is a processed instruction, the block split and it has a fall-through predecessor.
       if (offset >= 0 && isOffsetProcessed(offset)) {
-        block.incrementUnfilledPredecessorCount();
+        int blockStartOffset = getBlockStartOffset(offset);
+        BlockInfo existing = targets.get(blockStartOffset);
+        info = existing.split(blockStartOffset, offset, targets);
+      } else {
+        info = new BlockInfo();
       }
+      targets.put(offset, info);
     }
-    return block;
+    return info;
+  }
+
+  private int getBlockStartOffset(int offset) {
+    if (targets.containsKey(offset)) {
+      return offset;
+    }
+    return targets.headMap(offset).lastIntKey();
   }
 
   // Ensure there is a block starting at offset and add it to the work-list if it needs processing.
-  private BasicBlock ensureBlock(int offset) {
+  private BlockInfo ensureBlock(int offset) {
     // We don't enqueue negative targets (these are special blocks, eg, an argument prelude).
     if (offset >= 0 && !isOffsetProcessed(offset)) {
       traceBlocksWorklist.add(offset);
@@ -1550,16 +1663,32 @@
   }
 
   // Ensure there is a block at offset and add a predecessor to it.
-  BasicBlock ensureSuccessorBlock(int offset) {
-    BasicBlock block = ensureBlock(offset);
-    block.incrementUnfilledPredecessorCount();
-    return block;
+  private void ensureSuccessorBlock(int sourceOffset, int targetOffset, boolean normal) {
+    BlockInfo targetInfo = ensureBlock(targetOffset);
+    int sourceStartOffset = getBlockStartOffset(sourceOffset);
+    BlockInfo sourceInfo = targets.get(sourceStartOffset);
+    if (normal) {
+      sourceInfo.addNormalSuccessor(targetOffset);
+      targetInfo.addNormalPredecessor(sourceStartOffset);
+    } else {
+      sourceInfo.addExceptionalSuccessor(targetOffset);
+      targetInfo.addExceptionalPredecessor(sourceStartOffset);
+    }
+    targetInfo.block.incrementUnfilledPredecessorCount();
+  }
+
+  void ensureNormalSuccessorBlock(int sourceOffset, int targetOffset) {
+    ensureSuccessorBlock(sourceOffset, targetOffset, true);
+  }
+
+  void ensureExceptionalSuccessorBlock(int sourceOffset, int targetOffset) {
+    ensureSuccessorBlock(sourceOffset, targetOffset, false);
   }
 
   // Private block helpers.
 
   private BasicBlock getTarget(int offset) {
-    return targets.get(offset);
+    return targets.get(offset).block;
   }
 
   private void closeCurrentBlock() {
@@ -1577,7 +1706,7 @@
     assert currentBlock != null;
     flushCurrentDebugPosition();
     currentBlock.add(new Goto());
-    if (currentBlock.isCatchSuccessor(nextBlock)) {
+    if (currentBlock.hasCatchSuccessor(nextBlock)) {
       needGotoToCatchBlocks.add(new BasicBlock.Pair(currentBlock, nextBlock));
     } else {
       currentBlock.link(nextBlock);
@@ -1657,8 +1786,8 @@
       target.getPredecessors().add(newBlock);
 
       // Check that the successor indexes are correct.
-      assert source.isCatchSuccessor(newBlock);
-      assert !source.isCatchSuccessor(target);
+      assert source.hasCatchSuccessor(newBlock);
+      assert !source.hasCatchSuccessor(target);
 
       // Mark the filled predecessors to the blocks.
       if (source.isFilled()) {
@@ -1669,22 +1798,6 @@
     return blockNumber;
   }
 
-  private boolean phiOperandsAreConsistent() {
-    for (BasicBlock block : blocks) {
-      if (block.hasIncompletePhis()) {
-        StringBuilder builder = new StringBuilder("Incomplete phis in ");
-        builder.append(method);
-        builder.append(". The following registers appear to be uninitialized: ");
-        StringUtils.append(builder, block.getIncompletePhiRegisters(), ", ", BraceType.NONE);
-        throw new CompilationError(builder.toString());
-      }
-      for (Phi phi : block.getPhis()) {
-        assert phi.getOperands().size() == block.getPredecessors().size();
-      }
-    }
-    return true;
-  }
-
   /**
    * Change to control-flow graph to avoid repeated phi operands when all the same values
    * flow in from multiple predecessors.
@@ -1716,6 +1829,15 @@
   public void joinPredecessorsWithIdenticalPhis() {
     List<BasicBlock> blocksToAdd = new ArrayList<>();
     for (BasicBlock block : blocks) {
+      // Consistency check. At this point there should be no incomplete phis.
+      // If there are, the input is typically dex code that uses a register
+      // that is not defined on all control-flow paths.
+      if (block.hasIncompletePhis()) {
+        throw new CompilationError(
+            "Undefined value encountered during compilation. "
+                + "This is typically caused by invalid dex input that uses a register "
+                + "that is not define on all control-flow paths leading to the use.");
+      }
       if (block.entry() instanceof MoveException) {
         // TODO: Should we support joining in the presence of move-exception instructions?
         continue;
@@ -1768,7 +1890,7 @@
       // If any of the edges to the block are critical, we need to insert new blocks on each
       // containing the move-exception instruction which must remain the first instruction.
       if (block.entry() instanceof MoveException) {
-        block.splitCriticalExceptioEdges(valueNumberGenerator,
+        block.splitCriticalExceptionEdges(valueNumberGenerator,
             newBlock -> {
               newBlock.setNumber(blocks.size() + newBlocks.size());
               newBlocks.add(newBlock);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 8370eb8..a787025 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -25,7 +25,7 @@
 import com.android.tools.r8.ir.optimize.CodeRewriter;
 import com.android.tools.r8.ir.optimize.DeadCodeRemover;
 import com.android.tools.r8.ir.optimize.Inliner;
-import com.android.tools.r8.ir.optimize.Inliner.InliningConstraint;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.optimize.MemberValuePropagation;
 import com.android.tools.r8.ir.optimize.Outliner;
 import com.android.tools.r8.ir.optimize.PeepholeOptimizer;
@@ -37,11 +37,10 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
-import java.util.Random;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -66,6 +65,7 @@
   private final LensCodeRewriter lensCodeRewriter;
   private final Inliner inliner;
   private CallGraph callGraph;
+  private OptimizationFeedback ignoreOptimizationFeedback = new OptimizationFeedbackIgnore();
 
   private DexString highestSortingString;
 
@@ -204,7 +204,7 @@
         boolean matchesMethodFilter = options.methodMatchesFilter(method);
         if (matchesMethodFilter) {
           if (method.getCode().isJarCode()) {
-            rewriteCode(method, Outliner::noProcessing);
+            rewriteCode(method, ignoreOptimizationFeedback, Outliner::noProcessing);
           }
           updateHighestSortingStrings(method);
         }
@@ -236,34 +236,41 @@
 
     // Process the application identifying outlining candidates.
     timing.begin("IR conversion phase 1");
+    int count = 0;
+    OptimizationFeedback directFeedback = new OptimizationFeedbackDirect();
+    OptimizationFeedbackDelayed delayedFeedback = new OptimizationFeedbackDelayed();
     while (!callGraph.isEmpty()) {
+      count++;
       CallGraph.Leaves leaves = callGraph.pickLeaves();
-      List<DexEncodedMethod> leafMethods = leaves.getLeaves();
-      assert leafMethods.size() > 0;
-      // If cycles where broken to produce leaves, don't do parallel processing to keep
-      // deterministic output.
-      // TODO(37133161): Most likely the failing:
-      //  java.com.android.tools.r8.internal.R8GMSCoreDeterministicTest
-      // is caused by processing in multiple threads.
-      if (true || leaves.brokeCycles()) {
-        for (DexEncodedMethod method : leafMethods) {
-          processMethod(method,
-              outliner == null ? Outliner::noProcessing : outliner::identifyCandidates);
-        }
-      } else {
-        List<Future<?>> futures = new ArrayList<>();
-        // For testing we have the option to randomize the processing order for the
-        // deterministic tests.
-        if (options.testing.randomizeCallGraphLeaves) {
-          Collections.shuffle(leafMethods, new Random(System.nanoTime()));
-        }
-        for (DexEncodedMethod method : leafMethods) {
+      List<DexEncodedMethod> methods = leaves.getLeaves();
+      assert methods.size() > 0;
+      List<Future<?>> futures = new ArrayList<>();
+
+      // For testing we have the option to determine the processing order of the methods.
+      if (options.testing.irOrdering != null) {
+        methods = options.testing.irOrdering.apply(methods, leaves);
+      }
+
+      while (methods.size() > 0) {
+        // Process the methods on multiple threads. If cycles where broken collect the
+        // optimization feedback to reprocess methods affected by it. This is required to get
+        // deterministic behaviour, as the processing order within each set of leaves is
+        // non-deterministic.
+        for (DexEncodedMethod method : methods) {
           futures.add(executorService.submit(() -> {
             processMethod(method,
+                leaves.brokeCycles() ? delayedFeedback : directFeedback,
                 outliner == null ? Outliner::noProcessing : outliner::identifyCandidates);
           }));
         }
         ThreadUtils.awaitFutures(futures);
+        if (leaves.brokeCycles()) {
+          // If cycles in the call graph were broken, then re-process all methods which are
+          // affected by the optimization feedback of other methods in this group.
+          methods = delayedFeedback.applyAndClear(methods, leaves);
+        } else {
+          methods = ImmutableList.of();
+        }
       }
     }
     timing.end();
@@ -276,8 +283,7 @@
     if ((inliner != null) && (inliner.doubleInlineCallers.size() > 0)) {
       inliner.applyDoubleInlining = true;
       for (DexEncodedMethod method : inliner.doubleInlineCallers) {
-        method.markNotProcessed();
-        processMethod(method, Outliner::noProcessing);
+        processMethod(method, ignoreOptimizationFeedback, Outliner::noProcessing);
         assert method.isProcessed();
       }
     }
@@ -295,8 +301,7 @@
         for (DexEncodedMethod method : outliner.getMethodsSelectedForOutlining()) {
           // This is the second time we compile this method first mark it not processed.
           assert !method.getCode().isOutlineCode();
-          method.markNotProcessed();
-          processMethod(method, outliner::applyOutliningCandidate);
+          processMethod(method, ignoreOptimizationFeedback, outliner::applyOutliningCandidate);
           assert method.isProcessed();
         }
         builder.addSynthesizedClass(outlineClass, true);
@@ -377,28 +382,28 @@
 
   public void optimizeSynthesizedMethod(DexEncodedMethod method) {
     // Process the generated method, but don't apply any outlining.
-    processMethod(method, Outliner::noProcessing);
+    processMethod(method, ignoreOptimizationFeedback, Outliner::noProcessing);
   }
 
   private String logCode(InternalOptions options, DexEncodedMethod method) {
     return options.useSmaliSyntax ? method.toSmaliString(null) : method.codeToString();
   }
 
-  private void processMethod(
-      DexEncodedMethod method, BiConsumer<IRCode, DexEncodedMethod> outlineHandler) {
+  private void processMethod(DexEncodedMethod method,
+      OptimizationFeedback feedback,
+      BiConsumer<IRCode, DexEncodedMethod> outlineHandler) {
     Code code = method.getCode();
     boolean matchesMethodFilter = options.methodMatchesFilter(method);
     if (code != null && matchesMethodFilter) {
-      assert !method.isProcessed();
-      InliningConstraint state = rewriteCode(method, outlineHandler);
-      method.markProcessed(state);
+      rewriteCode(method, feedback, outlineHandler);
     } else {
       // Mark abstract methods as processed as well.
-      method.markProcessed(InliningConstraint.NEVER);
+      method.markProcessed(Constraint.NEVER);
     }
   }
 
-  private InliningConstraint rewriteCode(DexEncodedMethod method,
+  private void rewriteCode(DexEncodedMethod method,
+      OptimizationFeedback feedback,
       BiConsumer<IRCode, DexEncodedMethod> outlineHandler) {
     if (options.verbose) {
       System.out.println("Processing: " + method.toSourceString());
@@ -409,7 +414,8 @@
     }
     IRCode code = method.buildIR(options);
     if (code == null) {
-      return InliningConstraint.NEVER;
+      feedback.markProcessed(method, Constraint.NEVER);
+      return;
     }
     if (Log.ENABLED) {
       Log.debug(getClass(), "Initial (SSA) flow graph for %s:\n%s", method.toSourceString(), code);
@@ -470,7 +476,7 @@
     }
 
     codeRewriter.shortenLiveRanges(code);
-    codeRewriter.identifyReturnsArgument(method, code);
+    codeRewriter.identifyReturnsArgument(method, code, feedback);
 
     // Insert code to log arguments if requested.
     if (options.methodMatchesLogArgumentsFilter(method)) {
@@ -489,10 +495,13 @@
     printMethod(code, "Final IR (non-SSA)");
 
     // After all the optimizations have take place, we compute whether method should be inlined.
+    Constraint state;
     if (!options.inlineAccessors || inliner == null) {
-      return InliningConstraint.NEVER;
+      state = Constraint.NEVER;
+    } else {
+      state = inliner.identifySimpleMethods(code, method);
     }
-    return inliner.identifySimpleMethods(code, method);
+    feedback.markProcessed(method, state);
   }
 
   private void updateHighestSortingStrings(DexEncodedMethod method) {
@@ -547,7 +556,7 @@
     // Always perform dead code elimination before register allocation. The register allocator
     // does not allow dead code (to make sure that we do not waste registers for unneeded values).
     DeadCodeRemover.removeDeadCode(code, codeRewriter, options);
-    LinearScanRegisterAllocator registerAllocator = new LinearScanRegisterAllocator(code);
+    LinearScanRegisterAllocator registerAllocator = new LinearScanRegisterAllocator(code, options);
     registerAllocator.allocateRegisters(options.debug);
     printMethod(code, "After register allocation (non-SSA)");
     printLiveRanges(registerAllocator, "Final live ranges.");
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
index 5647878..12be2c2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
@@ -28,17 +28,21 @@
 import com.android.tools.r8.ir.code.MoveType;
 import com.android.tools.r8.ir.code.NumericType;
 import com.android.tools.r8.ir.code.Switch;
+import com.android.tools.r8.ir.conversion.IRBuilder.BlockInfo;
 import com.android.tools.r8.ir.conversion.JarState.Local;
 import com.android.tools.r8.ir.conversion.JarState.Slot;
 import com.android.tools.r8.logging.Log;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Queue;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import org.objectweb.asm.Handle;
@@ -66,7 +70,6 @@
 import org.objectweb.asm.util.Textifier;
 import org.objectweb.asm.util.TraceMethodVisitor;
 
-
 public class JarSourceCode implements SourceCode {
 
   // Try-catch block wrapper containing resolved offsets.
@@ -110,6 +113,16 @@
     }
   }
 
+  private static class JarStateWorklistItem {
+    BlockInfo blockInfo;
+    int instructionIndex;
+
+    public JarStateWorklistItem(BlockInfo blockInfo, int instructionIndex) {
+      this.blockInfo = blockInfo;
+      this.instructionIndex = instructionIndex;
+    }
+  }
+
   // Various descriptors.
   private static final String INT_ARRAY_DESC = "[I";
   private static final String REFLECT_ARRAY_DESC = "Ljava/lang/reflect/Array;";
@@ -144,7 +157,7 @@
   // thus that the monitor-entry prelude (part of the argument block which must not have a try-catch
   // successor) is not joined with the first instruction block (which likely will have a try-catch
   // successor).
-  private static final int EXCEPTIONAL_SYNC_EXIT_OFFSET = -1;
+  private static final int EXCEPTIONAL_SYNC_EXIT_OFFSET = -2;
   private static final TryCatchBlock EXCEPTIONAL_SYNC_EXIT =
       new TryCatchBlock(EXCEPTIONAL_SYNC_EXIT_OFFSET, 0, Integer.MAX_VALUE, null);
 
@@ -295,6 +308,70 @@
         builder.addDebugUninitialized(localRegister, constType(localType));
       }
     }
+    computeBlockEntryJarStates(builder);
+  }
+
+  private void computeBlockEntryJarStates(IRBuilder builder) {
+    Int2ReferenceSortedMap<BlockInfo> CFG = builder.getCFG();
+    Queue<JarStateWorklistItem> worklist = new LinkedList<>();
+    BlockInfo entry = CFG.get(IRBuilder.INITIAL_BLOCK_OFFSET);
+    if (CFG.get(0) != null) {
+      entry = CFG.get(0);
+    }
+    worklist.add(new JarStateWorklistItem(entry, 0));
+    state.recordStateForTarget(0, this);
+    for (JarStateWorklistItem item = worklist.poll(); item != null; item = worklist.poll()) {
+      state.restoreState(item.instructionIndex);
+      // If the block being restored is a try-catch handler push the exception on the stack.
+      for (int i = 0; i < node.tryCatchBlocks.size(); i++) {
+        TryCatchBlockNode tryCatchBlockNode = (TryCatchBlockNode) node.tryCatchBlocks.get(i);
+        if (tryCatchBlockNode.handler == getInstruction(item.instructionIndex)) {
+          state.push(THROWABLE_TYPE);
+          break;
+        }
+      }
+      // Iterate each of the instructions in the block to compute the outgoing JarState.
+      for (int i = item.instructionIndex; i <= instructionCount(); ++i) {
+        // If we are at the end of the instruction stream or if we have reached the start
+        // of a new block, propagate the state to all successors and add the ones
+        // that changed to the worklist.
+        if (i == instructionCount() || (i != item.instructionIndex && CFG.containsKey(i))) {
+          item.blockInfo.normalSuccessors.iterator().forEachRemaining(offset -> {
+            if (state.recordStateForTarget(offset, this)) {
+              if (offset >= 0) {
+                worklist.add(new JarStateWorklistItem(CFG.get(offset.intValue()), offset));
+              }
+            }
+          });
+          item.blockInfo.exceptionalSuccessors.iterator().forEachRemaining(offset -> {
+            if (state.recordStateForExceptionalTarget(offset, this)) {
+              if (offset >= 0) {
+                worklist.add(new JarStateWorklistItem(CFG.get(offset.intValue()), offset));
+              }
+            }
+          });
+          break;
+        }
+
+        AbstractInsnNode insn = getInstruction(i);
+        updateState(insn);
+
+        if (!isControlFlowInstruction(insn)) {
+          updateStateForLocalVariableEnd(insn);
+        }
+      }
+    }
+  }
+
+  private void updateStateForLocalVariableEnd(AbstractInsnNode insn) {
+    assert !isControlFlowInstruction(insn);
+    if (!(insn.getNext() instanceof LabelNode)) {
+      return;
+    }
+    // If the label is the end of any local-variable scopes end the locals.
+    LabelNode label = (LabelNode) insn.getNext();
+    List<Local> locals = state.getLocalsToClose(label);
+    state.closeLocals(locals);
   }
 
   @Override
@@ -308,7 +385,6 @@
 
   private void buildExceptionalPostlude(IRBuilder builder) {
     assert isSynchronized();
-    assert state.isInvalid();
     generatingMethodSynchronization = true;
     int exceptionRegister = 0; // We are exiting the method so we just overwrite register 0.
     builder.addMoveException(exceptionRegister);
@@ -324,14 +400,10 @@
 
   @Override
   public void closedCurrentBlockWithFallthrough(int fallthroughInstructionIndex) {
-    assert !state.isInvalid();
-    state.recordStateForTarget(fallthroughInstructionIndex, this);
-    state.invalidateState();
   }
 
   @Override
   public void closedCurrentBlock() {
-    assert state.isInvalid();
   }
 
   @Override
@@ -344,8 +416,8 @@
     currentInstruction = insn;
     assert verifyExceptionEdgesAreRecorded(insn);
 
-    // Restore the state if invalid.
-    if (state.isInvalid()) {
+    // If a new block is starting here, we restore the computed JarState.
+    if (builder.getCFG().containsKey(instructionIndex) || instructionIndex == 0) {
       state.restoreState(instructionIndex);
       // If the block being restored is a try-catch handler push the exception on the stack.
       for (int i = 0; i < node.tryCatchBlocks.size(); i++) {
@@ -406,7 +478,7 @@
 
   @Override
   public DebugLocalInfo getCurrentLocal(int register) {
-    return state.getLocalInfoForRegister(register);
+    return generatingMethodSynchronization ? null : state.getLocalInfoForRegister(register);
   }
 
   @Override
@@ -519,24 +591,24 @@
   }
 
   @Override
-  public boolean traceInstruction(int index, IRBuilder builder) {
+  public int traceInstruction(int index, IRBuilder builder) {
     AbstractInsnNode insn = getInstruction(index);
     // Exit early on no-op instructions.
     if (insn instanceof LabelNode || insn instanceof LineNumberNode) {
-      return false;
+      return -1;
     }
     // If this instruction exits, close this block.
     if (isReturn(insn)) {
-      return true;
+      return index;
     }
     // For each target ensure a basic block and close this block.
     int[] targets = getTargets(insn);
     if (targets != NO_TARGETS) {
       assert !canThrow(insn);
       for (int target : targets) {
-        builder.ensureSuccessorBlock(target);
+        builder.ensureNormalSuccessorBlock(index, target);
       }
-      return true;
+      return index;
     }
     if (canThrow(insn)) {
       List<TryCatchBlock> tryCatchBlocks = getTryHandlers(insn);
@@ -549,20 +621,20 @@
           int handler = tryCatchBlock.getHandler();
           if (!seenHandlerOffsets.contains(handler)) {
             seenHandlerOffsets.add(handler);
-            builder.ensureSuccessorBlock(handler);
+            builder.ensureExceptionalSuccessorBlock(index, handler);
           }
         }
         // Edge to normal successor if any (fallthrough).
         if (!isThrow(insn)) {
-          builder.ensureSuccessorBlock(getOffset(insn.getNext()));
+          builder.ensureNormalSuccessorBlock(index, getOffset(insn.getNext()));
         }
-        return true;
+        return index;
       }
       // If the throwable instruction is "throw" it closes the block.
-      return isThrow(insn);
+      return isThrow(insn) ? index : -1;
     }
     // This instruction does not close the block.
-    return false;
+    return -1;
   }
 
   private List<TryCatchBlock> getPotentialTryHandlers(AbstractInsnNode insn) {
@@ -988,6 +1060,674 @@
     }
   }
 
+  // State updating procedures.
+
+  private void updateState(AbstractInsnNode insn) {
+    switch (insn.getType()) {
+      case AbstractInsnNode.INSN:
+        updateState((InsnNode) insn);
+        break;
+      case AbstractInsnNode.INT_INSN:
+        updateState((IntInsnNode) insn);
+        break;
+      case AbstractInsnNode.VAR_INSN:
+        updateState((VarInsnNode) insn);
+        break;
+      case AbstractInsnNode.TYPE_INSN:
+        updateState((TypeInsnNode) insn);
+        break;
+      case AbstractInsnNode.FIELD_INSN:
+        updateState((FieldInsnNode) insn);
+        break;
+      case AbstractInsnNode.METHOD_INSN:
+        updateState((MethodInsnNode) insn);
+        break;
+      case AbstractInsnNode.INVOKE_DYNAMIC_INSN:
+        updateState((InvokeDynamicInsnNode) insn);
+        break;
+      case AbstractInsnNode.JUMP_INSN:
+        updateState((JumpInsnNode) insn);
+        break;
+      case AbstractInsnNode.LABEL:
+        updateState((LabelNode) insn);
+        break;
+      case AbstractInsnNode.LDC_INSN:
+        updateState((LdcInsnNode) insn);
+        break;
+      case AbstractInsnNode.IINC_INSN:
+        updateState((IincInsnNode) insn);
+        break;
+      case AbstractInsnNode.TABLESWITCH_INSN:
+        updateState((TableSwitchInsnNode) insn);
+        break;
+      case AbstractInsnNode.LOOKUPSWITCH_INSN:
+        updateState((LookupSwitchInsnNode) insn);
+        break;
+      case AbstractInsnNode.MULTIANEWARRAY_INSN:
+        updateState((MultiANewArrayInsnNode) insn);
+        break;
+      case AbstractInsnNode.LINE:
+        updateState((LineNumberNode) insn);
+        break;
+      default:
+        throw new Unreachable("Unexpected instruction " + insn);
+    }
+  }
+
+  private void updateState(InsnNode insn) {
+    int opcode = insn.getOpcode();
+    switch (opcode) {
+      case Opcodes.NOP:
+        // Intentionally left empty.
+        break;
+      case Opcodes.ACONST_NULL:
+        state.push(JarState.NULL_TYPE);
+        break;
+      case Opcodes.ICONST_M1:
+      case Opcodes.ICONST_0:
+      case Opcodes.ICONST_1:
+      case Opcodes.ICONST_2:
+      case Opcodes.ICONST_3:
+      case Opcodes.ICONST_4:
+      case Opcodes.ICONST_5:
+        state.push(Type.INT_TYPE);
+        break;
+      case Opcodes.LCONST_0:
+      case Opcodes.LCONST_1:
+        state.push(Type.LONG_TYPE);
+        break;
+      case Opcodes.FCONST_0:
+      case Opcodes.FCONST_1:
+      case Opcodes.FCONST_2:
+        state.push(Type.FLOAT_TYPE);
+        break;
+      case Opcodes.DCONST_0:
+      case Opcodes.DCONST_1:
+        state.push(Type.DOUBLE_TYPE);
+        break;
+      case Opcodes.IALOAD:
+      case Opcodes.LALOAD:
+      case Opcodes.FALOAD:
+      case Opcodes.DALOAD:
+      case Opcodes.AALOAD:
+      case Opcodes.BALOAD:
+      case Opcodes.CALOAD:
+      case Opcodes.SALOAD: {
+        state.pop();
+        Slot array = state.pop(JarState.ARRAY_TYPE);
+        Type elementType = getArrayElementType(array.type);
+        if (elementType == null) {
+          // We propagate the null type, which will then get resolved to an
+          // actual type if we have a non-null type on another flow edge.
+          elementType = JarState.NULL_TYPE;
+        }
+        state.push(elementType);
+        break;
+      }
+      case Opcodes.IASTORE:
+      case Opcodes.LASTORE:
+      case Opcodes.FASTORE:
+      case Opcodes.DASTORE:
+      case Opcodes.AASTORE:
+      case Opcodes.BASTORE:
+      case Opcodes.CASTORE:
+      case Opcodes.SASTORE: {
+        state.pop();
+        state.pop();
+        state.pop();
+        break;
+      }
+      case Opcodes.POP: {
+        Slot value = state.pop();
+        assert value.isCategory1();
+        break;
+      }
+      case Opcodes.POP2: {
+        Slot value = state.pop();
+        if (value.isCategory1()) {
+          Slot value2 = state.pop();
+          assert value2.isCategory1();
+        }
+        break;
+      }
+      case Opcodes.DUP: {
+        Slot value = state.peek();
+        assert value.isCategory1();
+        state.push(value.type);
+        break;
+      }
+      case Opcodes.DUP_X1: {
+        // Stack transformation: ..., v2, v1 -> ..., v1, v2, v1
+        Slot value1 = state.pop();
+        Slot value2 = state.pop();
+        assert value1.isCategory1() && value2.isCategory1();
+        int stack2 = state.push(value1.type);
+        int stack1 = state.push(value2.type);
+        state.push(value1.type);
+        assert value2.register == stack2;
+        assert value1.register == stack1;
+        break;
+      }
+      case Opcodes.DUP_X2: {
+        Slot value1 = state.pop();
+        Slot value2 = state.pop();
+        assert value1.isCategory1();
+        if (value2.isCategory1()) {
+          Slot value3 = state.pop();
+          assert value3.isCategory1();
+          // Stack transformation: ..., v3, v2, v1 -> ..., v1, v3, v2, v1
+          updateStateForDupOneBelowTwo(value3, value2, value1);
+        } else {
+          // Stack transformation: ..., w2, v1 -> ..., v1, w2, v1
+          updateStateForDupOneBelowOne(value2, value1);
+        }
+        break;
+      }
+      case Opcodes.DUP2: {
+        Slot value1 = state.pop();
+        if (value1.isCategory1()) {
+          Slot value2 = state.pop();
+          // Stack transformation: ..., v2, v1 -> ..., v2, v1, v2, v1
+          assert value2.isCategory1();
+          state.push(value2.type);
+          state.push(value1.type);
+          state.push(value2.type);
+          state.push(value1.type);
+        } else {
+          // Stack transformation: ..., w1 -> ..., w1, w1
+          state.push(value1.type);
+          state.push(value1.type);
+        }
+        break;
+      }
+      case Opcodes.DUP2_X1: {
+        Slot value1 = state.pop();
+        Slot value2 = state.pop();
+        assert value2.isCategory1();
+        if (value1.isCategory1()) {
+          // Stack transformation: ..., v3, v2, v1 -> v2, v1, v3, v2, v1
+          Slot value3 = state.pop();
+          assert value3.isCategory1();
+          updateStateForDupTwoBelowOne(value3, value2, value1);
+        } else {
+          // Stack transformation: ..., v2, w1 -> ..., w1, v2, w1
+          updateStateForDupOneBelowOne(value2, value1);
+        }
+        break;
+      }
+      case Opcodes.DUP2_X2: {
+        Slot value1 = state.pop();
+        Slot value2 = state.pop();
+        if (!value1.isCategory1() && !value2.isCategory1()) {
+          // State transformation: ..., w2, w1 -> w1, w2, w1
+          updateStateForDupOneBelowOne(value2, value1);
+        } else {
+          Slot value3 = state.pop();
+          if (!value1.isCategory1()) {
+            assert value2.isCategory1();
+            assert value3.isCategory1();
+            // State transformation: ..., v3, v2, w1 -> w1, v3, v2, w1
+            updateStateForDupOneBelowTwo(value3, value2, value1);
+          } else if (!value3.isCategory1()) {
+            assert value1.isCategory1();
+            assert value2.isCategory1();
+            // State transformation: ..., w3, v2, v1 -> v2, v1, w3, v2, v1
+            updateStateForDupTwoBelowOne(value3, value2, value1);
+          } else {
+            Slot value4 = state.pop();
+            assert value1.isCategory1();
+            assert value2.isCategory1();
+            assert value3.isCategory1();
+            assert value4.isCategory1();
+            // State transformation: ..., v4, v3, v2, v1 -> v2, v1, v4, v3, v2, v1
+            updateStateForDupTwoBelowTwo(value4, value3, value2, value1);
+          }
+        }
+        break;
+      }
+      case Opcodes.SWAP: {
+        Slot value1 = state.pop();
+        Slot value2 = state.pop();
+        assert value1.isCategory1() && value2.isCategory1();
+        state.push(value1.type);
+        state.push(value2.type);
+        break;
+      }
+      case Opcodes.IADD:
+      case Opcodes.LADD:
+      case Opcodes.FADD:
+      case Opcodes.DADD:
+      case Opcodes.ISUB:
+      case Opcodes.LSUB:
+      case Opcodes.FSUB:
+      case Opcodes.DSUB:
+      case Opcodes.IMUL:
+      case Opcodes.LMUL:
+      case Opcodes.FMUL:
+      case Opcodes.DMUL:
+      case Opcodes.IDIV:
+      case Opcodes.LDIV:
+      case Opcodes.FDIV:
+      case Opcodes.DDIV:
+      case Opcodes.IREM:
+      case Opcodes.LREM:
+      case Opcodes.FREM:
+      case Opcodes.DREM: {
+        Type type = opType(opcode);
+        state.pop();
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.INEG:
+      case Opcodes.LNEG:
+      case Opcodes.FNEG:
+      case Opcodes.DNEG: {
+        Type type = opType(opcode);
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.ISHL:
+      case Opcodes.LSHL:
+      case Opcodes.ISHR:
+      case Opcodes.LSHR:
+      case Opcodes.IUSHR:
+      case Opcodes.LUSHR: {
+        Type type = opType(opcode);
+        state.pop();
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.IAND:
+      case Opcodes.LAND: {
+        Type type = opcode == Opcodes.IAND ? Type.INT_TYPE : Type.LONG_TYPE;
+        state.pop();
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.IOR:
+      case Opcodes.LOR: {
+        Type type = opcode == Opcodes.IOR ? Type.INT_TYPE : Type.LONG_TYPE;
+        state.pop();
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.IXOR:
+      case Opcodes.LXOR: {
+        Type type = opcode == Opcodes.IXOR ? Type.INT_TYPE : Type.LONG_TYPE;
+        state.pop();
+        state.pop();
+        state.push(type);
+        break;
+      }
+      case Opcodes.I2L:
+        updateStateForConversion(Type.INT_TYPE, Type.LONG_TYPE);
+        break;
+      case Opcodes.I2F:
+        updateStateForConversion(Type.INT_TYPE, Type.FLOAT_TYPE);
+        break;
+      case Opcodes.I2D:
+        updateStateForConversion(Type.INT_TYPE, Type.DOUBLE_TYPE);
+        break;
+      case Opcodes.L2I:
+        updateStateForConversion(Type.LONG_TYPE, Type.INT_TYPE);
+        break;
+      case Opcodes.L2F:
+        updateStateForConversion(Type.LONG_TYPE, Type.FLOAT_TYPE);
+        break;
+      case Opcodes.L2D:
+        updateStateForConversion(Type.LONG_TYPE, Type.DOUBLE_TYPE);
+        break;
+      case Opcodes.F2I:
+        updateStateForConversion(Type.FLOAT_TYPE, Type.INT_TYPE);
+        break;
+      case Opcodes.F2L:
+        updateStateForConversion(Type.FLOAT_TYPE, Type.LONG_TYPE);
+        break;
+      case Opcodes.F2D:
+        updateStateForConversion(Type.FLOAT_TYPE, Type.DOUBLE_TYPE);
+        break;
+      case Opcodes.D2I:
+        updateStateForConversion(Type.DOUBLE_TYPE, Type.INT_TYPE);
+        break;
+      case Opcodes.D2L:
+        updateStateForConversion(Type.DOUBLE_TYPE, Type.LONG_TYPE);
+        break;
+      case Opcodes.D2F:
+        updateStateForConversion(Type.DOUBLE_TYPE, Type.FLOAT_TYPE);
+        break;
+      case Opcodes.I2B:
+        updateStateForConversion(Type.INT_TYPE, Type.BYTE_TYPE);
+        break;
+      case Opcodes.I2C:
+        updateStateForConversion(Type.INT_TYPE, Type.CHAR_TYPE);
+        break;
+      case Opcodes.I2S:
+        updateStateForConversion(Type.INT_TYPE, Type.SHORT_TYPE);
+        break;
+      case Opcodes.LCMP: {
+        state.pop();
+        state.pop();
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      case Opcodes.FCMPL:
+      case Opcodes.FCMPG: {
+        state.pop();
+        state.pop();
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      case Opcodes.DCMPL:
+      case Opcodes.DCMPG: {
+        state.pop();
+        state.pop();
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      case Opcodes.IRETURN: {
+        state.pop();
+        break;
+      }
+      case Opcodes.LRETURN: {
+        state.pop();
+        break;
+      }
+      case Opcodes.FRETURN: {
+        state.pop();
+        break;
+      }
+      case Opcodes.DRETURN: {
+        state.pop();
+        break;
+      }
+      case Opcodes.ARETURN: {
+        state.pop(JarState.REFERENCE_TYPE);
+        break;
+      }
+      case Opcodes.RETURN: {
+        break;
+      }
+      case Opcodes.ARRAYLENGTH: {
+        state.pop(JarState.ARRAY_TYPE);
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      case Opcodes.ATHROW: {
+        state.pop(JarState.OBJECT_TYPE);
+        break;
+      }
+      case Opcodes.MONITORENTER: {
+        state.pop(JarState.REFERENCE_TYPE);
+        break;
+      }
+      case Opcodes.MONITOREXIT: {
+        state.pop(JarState.REFERENCE_TYPE);
+        break;
+      }
+      default:
+        throw new Unreachable("Unexpected Insn opcode: " + insn.getOpcode());
+    }
+  }
+
+  private void updateStateForDupOneBelowTwo(Slot value3, Slot value2, Slot value1) {
+    state.push(value1.type);
+    state.push(value3.type);
+    state.push(value2.type);
+    state.push(value1.type);
+  }
+
+  private void updateStateForDupOneBelowOne(Slot value2, Slot value1) {
+    state.push(value1.type);
+    state.push(value2.type);
+    state.push(value1.type);
+  }
+
+  private void updateStateForDupTwoBelowOne(Slot value3, Slot value2, Slot value1) {
+    state.push(value2.type);
+    state.push(value1.type);
+    state.push(value3.type);
+    state.push(value2.type);
+    state.push(value1.type);
+  }
+
+  private void updateStateForDupTwoBelowTwo(Slot value4, Slot value3, Slot value2, Slot value1) {
+    state.push(value2.type);
+    state.push(value1.type);
+    state.push(value4.type);
+    state.push(value3.type);
+    state.push(value2.type);
+    state.push(value1.type);
+  }
+
+  private void updateState(IntInsnNode insn) {
+    switch (insn.getOpcode()) {
+      case Opcodes.BIPUSH:
+      case Opcodes.SIPUSH: {
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      case Opcodes.NEWARRAY: {
+        String desc = arrayTypeDesc(insn.operand);
+        Type type = Type.getType(desc);
+        state.pop();
+        state.push(type);
+        break;
+      }
+      default:
+        throw new Unreachable("Unexpected IntInsn opcode: " + insn.getOpcode());
+    }
+  }
+
+  private void updateState(VarInsnNode insn) {
+    int opcode = insn.getOpcode();
+    Type expectedType;
+    switch (opcode) {
+      case Opcodes.ILOAD:
+      case Opcodes.ISTORE:
+        expectedType = Type.INT_TYPE;
+        break;
+      case Opcodes.FLOAD:
+      case Opcodes.FSTORE:
+        expectedType = Type.FLOAT_TYPE;
+        break;
+      case Opcodes.LLOAD:
+      case Opcodes.LSTORE:
+        expectedType = Type.LONG_TYPE;
+        break;
+      case Opcodes.DLOAD:
+      case Opcodes.DSTORE:
+        expectedType = Type.DOUBLE_TYPE;
+        break;
+      case Opcodes.ALOAD:
+      case Opcodes.ASTORE:
+        expectedType = JarState.REFERENCE_TYPE;
+        break;
+      case Opcodes.RET: {
+        throw new Unreachable("RET should be handled by the ASM jsr inliner");
+      }
+      default:
+        throw new Unreachable("Unexpected VarInsn opcode: " + insn.getOpcode());
+    }
+    if (Opcodes.ILOAD <= opcode && opcode <= Opcodes.ALOAD) {
+      Slot src = state.readLocal(insn.var, expectedType);
+      state.push(src.type);
+    } else {
+      assert Opcodes.ISTORE <= opcode && opcode <= Opcodes.ASTORE;
+      Slot slot = state.pop();
+      if (slot.type == JarState.NULL_TYPE && expectedType != JarState.REFERENCE_TYPE) {
+        state.writeLocal(insn.var, expectedType);
+      } else {
+        state.writeLocal(insn.var, slot.type);
+      }
+    }
+  }
+
+  private void updateState(TypeInsnNode insn) {
+    Type type = Type.getObjectType(insn.desc);
+    switch (insn.getOpcode()) {
+      case Opcodes.NEW: {
+        state.push(type);
+        break;
+      }
+      case Opcodes.ANEWARRAY: {
+        Type arrayType = makeArrayType(type);
+        state.pop();
+        state.push(arrayType);
+        break;
+      }
+      case Opcodes.CHECKCAST: {
+        // Pop the top value and push it back on with the checked type.
+        state.pop(type);
+        state.push(type);
+        break;
+      }
+      case Opcodes.INSTANCEOF: {
+        state.pop(JarState.REFERENCE_TYPE);
+        state.push(Type.INT_TYPE);
+        break;
+      }
+      default:
+        throw new Unreachable("Unexpected TypeInsn opcode: " + insn.getOpcode());
+    }
+
+  }
+
+  private void updateState(FieldInsnNode insn) {
+    Type type = Type.getType(insn.desc);
+    switch (insn.getOpcode()) {
+      case Opcodes.GETSTATIC:
+        state.push(type);
+        break;
+      case Opcodes.PUTSTATIC:
+        state.pop();
+        break;
+      case Opcodes.GETFIELD: {
+        state.pop(JarState.OBJECT_TYPE);
+        state.push(type);
+        break;
+      }
+      case Opcodes.PUTFIELD: {
+        state.pop();
+        state.pop(JarState.OBJECT_TYPE);
+        break;
+      }
+      default:
+        throw new Unreachable("Unexpected FieldInsn opcode: " + insn.getOpcode());
+    }
+  }
+
+  private void updateState(MethodInsnNode insn) {
+    updateStateForInvoke(insn.desc, insn.getOpcode() != Opcodes.INVOKESTATIC);
+  }
+
+  private void updateState(InvokeDynamicInsnNode insn) {
+    updateStateForInvoke(insn.desc, false /* receiver passed explicitly */);
+  }
+
+  private void updateStateForInvoke(String desc, boolean implicitReceiver) {
+    // Pop arguments.
+    Type[] parameterTypes = Type.getArgumentTypes(desc);
+    state.popReverse(parameterTypes.length);
+    // Pop implicit receiver if needed.
+    if (implicitReceiver) {
+      state.pop();
+    }
+    // Push return value if needed.
+    Type returnType = Type.getReturnType(desc);
+    if (returnType != Type.VOID_TYPE) {
+      state.push(returnType);
+    }
+  }
+
+  private void updateState(JumpInsnNode insn) {
+    int[] targets = getTargets(insn);
+    int opcode = insn.getOpcode();
+    if (Opcodes.IFEQ <= opcode && opcode <= Opcodes.IF_ACMPNE) {
+      assert targets.length == 2;
+      if (opcode <= Opcodes.IFLE) {
+        state.pop();
+      } else {
+        state.pop();
+        state.pop();
+      }
+    } else {
+      switch (opcode) {
+        case Opcodes.GOTO: {
+          assert targets.length == 1;
+          break;
+        }
+        case Opcodes.IFNULL:
+        case Opcodes.IFNONNULL: {
+          state.pop();
+          break;
+        }
+        case Opcodes.JSR: {
+          throw new Unreachable("JSR should be handled by the ASM jsr inliner");
+        }
+        default:
+          throw new Unreachable("Unexpected JumpInsn opcode: " + insn.getOpcode());
+      }
+    }
+  }
+
+  private void updateState(LabelNode insn) {
+    // Open the scope of locals starting at this point.
+    if (insn != initialLabel) {
+      state.openLocals(insn);
+    }
+  }
+
+  private void updateState(LdcInsnNode insn) {
+    if (insn.cst instanceof Type) {
+      Type type = (Type) insn.cst;
+      state.push(type);
+    } else if (insn.cst instanceof String) {
+      state.push(STRING_TYPE);
+    } else if (insn.cst instanceof Long) {
+      state.push(Type.LONG_TYPE);
+    } else if (insn.cst instanceof Double) {
+      state.push(Type.DOUBLE_TYPE);
+    } else if (insn.cst instanceof Integer) {
+      state.push(Type.INT_TYPE);
+    } else {
+      assert insn.cst instanceof Float;
+      state.push(Type.FLOAT_TYPE);
+    }
+  }
+
+  private void updateState(IincInsnNode insn) {
+    state.readLocal(insn.var, Type.INT_TYPE);
+  }
+
+  private void updateState(TableSwitchInsnNode insn) {
+    state.pop();
+  }
+
+  private void updateState(LookupSwitchInsnNode insn) {
+    state.pop();
+  }
+
+  private void updateState(MultiANewArrayInsnNode insn) {
+    // Type of the full array.
+    Type arrayType = Type.getObjectType(insn.desc);
+    state.popReverse(insn.dims, Type.INT_TYPE);
+    state.push(arrayType);
+  }
+
+  private void updateState(LineNumberNode insn) {
+    // Intentionally empty.
+  }
+
+  private void updateStateForConversion(Type from, Type to) {
+    state.pop();
+    state.push(to);
+  }
+
   // IR instruction building procedures.
 
   private void build(AbstractInsnNode insn, IRBuilder builder) {
@@ -1510,7 +2250,6 @@
       processLocalVariablesAtControlEdge(insn, builder);
     }
     builder.addThrow(register);
-    state.invalidateState();
   }
 
   private void addReturn(InsnNode insn, MoveType type, int register, IRBuilder builder) {
@@ -1521,7 +2260,6 @@
     } else {
       builder.addReturn(type, register);
     }
-    state.invalidateState();
   }
 
   private void dupOneBelowTwo(Slot value3, Slot value2, Slot value1, IRBuilder builder) {
@@ -1914,10 +2652,6 @@
           throw new Unreachable("Unexpected JumpInsn opcode: " + insn.getOpcode());
       }
     }
-    for (int target : targets) {
-      state.recordStateForTarget(target, this);
-    }
-    state.invalidateState();
   }
 
   private void build(LabelNode insn, IRBuilder builder) {
@@ -1927,11 +2661,6 @@
         builder.addDebugLocalStart(local.slot.register, local.info);
       }
     }
-    // Processing local-variable ends is done before closing potential control-flow edges.
-    // Record the state for all the try-catch handlers that are active at this label.
-    for (TryCatchBlock tryCatchBlock : getTryHandlers(insn)) {
-      state.recordStateForExceptionalTarget(tryCatchBlock.getHandler(), this);
-    }
   }
 
   private void build(LdcInsnNode insn, IRBuilder builder) {
@@ -1969,6 +2698,7 @@
   }
 
   private void build(LookupSwitchInsnNode insn, IRBuilder builder) {
+    processLocalVariablesAtControlEdge(insn, builder);
     int[] keys = new int[insn.keys.size()];
     for (int i = 0; i < insn.keys.size(); i++) {
       keys[i] = (int) insn.keys.get(i);
@@ -1980,15 +2710,12 @@
       IRBuilder builder) {
     int index = state.pop(Type.INT_TYPE).register;
     int fallthroughOffset = getOffset(dflt);
-    state.recordStateForTarget(fallthroughOffset, this);
     int[] labelOffsets = new int[labels.size()];
     for (int i = 0; i < labels.size(); i++) {
       int offset = getOffset((LabelNode) labels.get(i));
       labelOffsets[i] = offset;
-      state.recordStateForTarget(offset, this);
     }
     builder.addSwitch(type, index, keys, fallthroughOffset, labelOffsets);
-    state.invalidateState();
   }
 
   private void build(MultiANewArrayInsnNode insn, IRBuilder builder) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/JarState.java b/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
index e45fcb2..51a8117 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
@@ -40,13 +40,6 @@
   // Type representative for an address type (used by JSR/RET).
   public static final Type ADDR_TYPE = Type.getObjectType("<address>");
 
-  private static final Slot INVALID_SLOT = new Slot(-1, null);
-  private static final Local INVALID_LOCAL = new Local(INVALID_SLOT, null);
-
-  public boolean isInvalid() {
-    return stack.peek() == INVALID_SLOT;
-  }
-
   // Typed mapping from a local slot or stack slot to a virtual register.
   public static class Slot {
     public final int register;
@@ -54,7 +47,7 @@
 
     @Override
     public String toString() {
-      return this == INVALID_SLOT ? "<invalid slot>" : "r" + register + ":" + type;
+      return "r" + register + ":" + type;
     }
 
     public Slot(int register, Type type) {
@@ -356,15 +349,6 @@
 
   // State procedures.
 
-  public void invalidateState() {
-    for (int i = 0; i < locals.length; i++) {
-      locals[i] = INVALID_LOCAL;
-    }
-    stack.clear();
-    stack.push(INVALID_SLOT);
-    topOfStack = -1;
-  }
-
   public boolean hasState(int offset) {
     return targetStates.get(offset) != null;
   }
@@ -374,49 +358,100 @@
     assert snapshot != null;
     assert locals.length == snapshot.locals.length;
     for (int i = 0; i < locals.length; i++) {
-      assert locals[i] == INVALID_LOCAL;
       locals[i] = snapshot.locals[i];
     }
-    assert stack.peek() == INVALID_SLOT;
-    assert topOfStack == -1;
     stack.clear();
     stack.addAll(snapshot.stack);
     topOfStack = startOfStack + 2 * stack.size();
   }
 
-  public void recordStateForTarget(int target, JarSourceCode source) {
-    recordStateForTarget(target, locals.clone(), ImmutableList.copyOf(stack), source);
+  public boolean recordStateForTarget(int target, JarSourceCode source) {
+    return recordStateForTarget(target, locals.clone(), ImmutableList.copyOf(stack), source);
   }
 
-  public void recordStateForExceptionalTarget(int target, JarSourceCode source) {
-    recordStateForTarget(target, locals.clone(), ImmutableList.of(), source);
+  public boolean recordStateForExceptionalTarget(int target, JarSourceCode source) {
+    return recordStateForTarget(target, locals.clone(), ImmutableList.of(), source);
   }
 
-  private void recordStateForTarget(int target, Local[] locals, ImmutableList<Slot> stack,
+  private boolean recordStateForTarget(int target, Local[] locals, ImmutableList<Slot> stack,
       JarSourceCode source) {
-    Snapshot snapshot = targetStates.get(target);
-    if (snapshot == null) {
-      if (!localVariables.isEmpty()) {
-        for (int i = 0; i < locals.length; i++) {
-          if (locals[i] != null) {
-            locals[i] = new Local(locals[i].slot, null);
-          }
-        }
-        // TODO(zerny): Precompute and sort the local ranges.
-        for (LocalVariableNode node : localVariables.keySet()) {
-          int startOffset = source.getOffset(node.start);
-          int endOffset = source.getOffset(node.end);
-          if (startOffset <= target && target < endOffset) {
-            int register = getLocalRegister(node.index, Type.getType(node.desc));
-            Local local = locals[register];
-            locals[register] = new Local(local.slot, localVariables.get(node));
-          }
+    if (!localVariables.isEmpty()) {
+      for (int i = 0; i < locals.length; i++) {
+        if (locals[i] != null) {
+          locals[i] = new Local(locals[i].slot, null);
         }
       }
-      targetStates.put(target, new Snapshot(locals, stack));
-      return;
+      // TODO(zerny): Precompute and sort the local ranges.
+      for (LocalVariableNode node : localVariables.keySet()) {
+        int startOffset = source.getOffset(node.start);
+        int endOffset = source.getOffset(node.end);
+        if (startOffset <= target && target < endOffset) {
+          int register = getLocalRegister(node.index, Type.getType(node.desc));
+          Local local = locals[register];
+          locals[register] = new Local(local.slot, localVariables.get(node));
+        }
+      }
     }
-    assert verifyStack(stack, snapshot.stack);
+    Snapshot snapshot = targetStates.get(target);
+    if (snapshot != null) {
+      Local[] newLocals = mergeLocals(snapshot.locals, locals);
+      ImmutableList<Slot> newStack = mergeStacks(snapshot.stack, stack);
+      if (newLocals != snapshot.locals || newStack != snapshot.stack) {
+        targetStates.put(target, new Snapshot(newLocals, newStack));
+        return true;
+      }
+      // The snapshot is up to date - no new type information recoded.
+      return false;
+    }
+    targetStates.put(target, new Snapshot(locals, stack));
+    return true;
+  }
+
+  private ImmutableList<Slot> mergeStacks(
+      ImmutableList<Slot> currentStack, ImmutableList<Slot> newStack) {
+    assert currentStack.size() == newStack.size();
+    List<Slot> mergedStack = null;
+    for (int i = 0; i < currentStack.size(); i++) {
+      if (currentStack.get(i).type == JarState.NULL_TYPE &&
+          newStack.get(i).type != JarState.NULL_TYPE) {
+        if (mergedStack == null) {
+          mergedStack = new ArrayList<>();
+          mergedStack.addAll(currentStack.subList(0, i));
+        }
+        mergedStack.add(newStack.get(i));
+      } else if (mergedStack != null) {
+        assert currentStack.get(i).isCompatibleWith(newStack.get(i).type);
+        mergedStack.add(currentStack.get(i));
+      }
+    }
+    return mergedStack != null ? ImmutableList.copyOf(mergedStack) : currentStack;
+  }
+
+  private Local[] mergeLocals(Local[] currentLocals, Local[] newLocals) {
+    assert currentLocals.length == newLocals.length;
+    Local[] mergedLocals = null;
+    for (int i = 0; i < currentLocals.length; i++) {
+      Local currentLocal = currentLocals[i];
+      Local newLocal = newLocals[i];
+      if (currentLocal == null || newLocal == null) {
+        continue;
+      }
+      // If this assert triggers we can get different debug information for the same local
+      // on different control-flow paths and we will have to merge them.
+      assert currentLocal.info == newLocal.info;
+      if (currentLocal.slot.type == JarState.NULL_TYPE &&
+          newLocal.slot.type != JarState.NULL_TYPE) {
+        if (mergedLocals == null) {
+          mergedLocals = new Local[currentLocals.length];
+          System.arraycopy(currentLocals, 0, mergedLocals, 0, i);
+        }
+        Slot newSlot = new Slot(newLocal.slot.register, newLocal.slot.type);
+        mergedLocals[i] = new Local(newSlot, newLocal.info);
+      } else if (mergedLocals != null) {
+        mergedLocals[i] = currentLocals[i];
+      }
+    }
+    return mergedLocals != null ? mergedLocals : currentLocals;
   }
 
   private static boolean verifyStack(List<Slot> stack, List<Slot> other) {
@@ -446,9 +481,6 @@
   public static String stackToString(Collection<Slot> stack) {
     List<String> strings = new ArrayList<>(stack.size());
     for (Slot slot : stack) {
-      if (slot == INVALID_SLOT) {
-        return "<stack invalidated>";
-      }
       strings.add(slot.type.toString());
     }
     StringBuilder builder = new StringBuilder("{ ");
@@ -466,9 +498,6 @@
     StringBuilder builder = new StringBuilder("{ ");
     boolean first = true;
     for (Local local : locals) {
-      if (local == INVALID_LOCAL) {
-        return "<locals invalidated>";
-      }
       if (!first) {
         builder.append(", ");
       } else {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
new file mode 100644
index 0000000..be5718e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
@@ -0,0 +1,15 @@
+// Copyright (c) 2017, 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.conversion;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+
+public interface OptimizationFeedback {
+  void methodReturnsArgument(DexEncodedMethod method, int argument);
+  void methodReturnsConstant(DexEncodedMethod method, long value);
+  void methodNeverReturnsNull(DexEncodedMethod method);
+  void markProcessed(DexEncodedMethod method, Constraint state);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDelayed.java
new file mode 100644
index 0000000..25d3fe5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDelayed.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2017, 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.conversion;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
+import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Reference2LongMap;
+import it.unimi.dsi.fastutil.objects.Reference2LongOpenHashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class OptimizationFeedbackDelayed implements OptimizationFeedback {
+
+  private Reference2IntMap<DexEncodedMethod> returnsArgument = new Reference2IntOpenHashMap<>();
+  private Reference2LongMap<DexEncodedMethod> returnsConstant = new Reference2LongOpenHashMap<>();
+  private Set<DexEncodedMethod> neverReturnsNull = Sets.newIdentityHashSet();
+  private Map<DexEncodedMethod, Constraint> inliningConstraints = Maps.newIdentityHashMap();
+
+  @Override
+  synchronized public void methodReturnsArgument(DexEncodedMethod method, int argument) {
+    if (method.getOptimizationInfo().returnsArgument()) {
+      assert method.getOptimizationInfo().getReturnedArgument() == argument;
+      return;
+    }
+    assert !returnsArgument.containsKey(method);
+    returnsArgument.put(method, argument);
+  }
+
+  @Override
+  synchronized public void methodReturnsConstant(DexEncodedMethod method, long value) {
+    if (method.getOptimizationInfo().returnsConstant()) {
+      assert method.getOptimizationInfo().getReturnedConstant() == value;
+      return;
+    }
+    assert !returnsConstant.containsKey(method);
+    returnsConstant.put(method, value);
+  }
+
+  @Override
+  synchronized public void methodNeverReturnsNull(DexEncodedMethod method) {
+    if (method.getOptimizationInfo().neverReturnsNull()) {
+      return;
+    }
+    assert !neverReturnsNull.contains(method);
+    neverReturnsNull.add(method);
+  }
+
+  @Override
+  public void markProcessed(DexEncodedMethod method, Constraint state) {
+    if (state == Constraint.NEVER) {
+      assert method.cannotInline();
+      method.markProcessed(state);
+    } else {
+      assert method.cannotInline();
+      inliningConstraints.put(method, state);
+    }
+  }
+
+  private <T> boolean setsOverlap(Set<T> set1, Set<T> set2) {
+    for (T element : set1) {
+      if (set2.contains(element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Apply the optimization feedback.
+   *
+   * Returns the methods from the passed in list that could be affected by applying the
+   * optimization feedback.
+   */
+  public List<DexEncodedMethod> applyAndClear(
+      List<DexEncodedMethod> processed, CallGraph.Leaves leaves) {
+    returnsArgument.forEach(DexEncodedMethod::markReturnsArgument);
+    returnsConstant.forEach(DexEncodedMethod::markReturnsConstant);
+    neverReturnsNull.forEach(DexEncodedMethod::markNeverReturnsNull);
+
+    // Collect all methods affected by the optimization feedback applied.
+    Set<DexEncodedMethod> all = Sets.newIdentityHashSet();
+    all.addAll(returnsArgument.keySet());
+    all.addAll(returnsConstant.keySet());
+    all.addAll(neverReturnsNull);
+    inliningConstraints.forEach((method, constraint) -> {
+      boolean changed = method.markProcessed(constraint);
+      if (changed) {
+        all.add(method);
+      }
+    });
+
+    // Collect the processed methods which could be affected by the applied optimization feedback.
+    List<DexEncodedMethod> result = new ArrayList<>();
+    for (DexEncodedMethod method : processed) {
+      Set<DexEncodedMethod> calls = leaves.getCycleBreakingCalls().get(method);
+      if (setsOverlap(calls, all)) {
+        result.add(method);
+      }
+    }
+
+    // Clear the collected optimization feedback.
+    returnsArgument.clear();
+    returnsConstant.clear();
+    neverReturnsNull.clear();
+    inliningConstraints.clear();
+
+    return result;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
new file mode 100644
index 0000000..dc0a809
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2017, 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.conversion;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+
+public class OptimizationFeedbackDirect implements OptimizationFeedback {
+
+  @Override
+  public void methodReturnsArgument(DexEncodedMethod method, int argument) {
+    method.markReturnsArgument(argument);
+  }
+
+  @Override
+  public void methodReturnsConstant(DexEncodedMethod method, long value) {
+    method.markReturnsConstant(value);
+  }
+
+  @Override
+  public void methodNeverReturnsNull(DexEncodedMethod method) {
+    method.markNeverReturnsNull();
+  }
+
+  @Override
+  public void markProcessed(DexEncodedMethod method, Constraint state) {
+    method.markProcessed(state);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
new file mode 100644
index 0000000..3c8057f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
@@ -0,0 +1,23 @@
+// Copyright (c) 2017, 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.conversion;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+
+public class OptimizationFeedbackIgnore implements OptimizationFeedback {
+
+  @Override
+  public void methodReturnsArgument(DexEncodedMethod method, int argument) {}
+
+  @Override
+  public void methodReturnsConstant(DexEncodedMethod method, long value) {}
+
+  @Override
+  public void methodNeverReturnsNull(DexEncodedMethod method) {}
+
+  @Override
+  public void markProcessed(DexEncodedMethod method, Constraint state) {}
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
index ba03f82..a36091d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
@@ -33,9 +33,10 @@
    * <p>The instruction at {@code index} is traced and its target blocks are marked by using
    * {@code IRBuilder.ensureSuccessorBlock} (and {@code ensureBlockWithoutEnqueuing}).
    *
-   * @return True if the instruction closes the current block, false otherwise.
+   * @return If the instruction closes the block, the last index of the block,
+   * otherwise -1.
    */
-  boolean traceInstruction(int instructionIndex, IRBuilder builder);
+  int traceInstruction(int instructionIndex, IRBuilder builder);
 
   void closedCurrentBlockWithFallthrough(int fallthroughInstructionIndex);
   void closedCurrentBlock();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 01be50d..c3f2d08 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -166,7 +166,7 @@
 
   private boolean isInMainDexList(DexType iface) {
     ImmutableSet<DexType> list = converter.application.mainDexList;
-    return list != null && list.contains(iface);
+    return list.contains(iface);
   }
 
   // Represent a static interface method as a method of companion class.
@@ -226,7 +226,7 @@
     InterfaceProcessor processor = new InterfaceProcessor(this);
     for (DexProgramClass clazz : builder.getProgramClasses()) {
       if (shouldProcess(clazz, flavour, true)) {
-        processor.process(clazz.get().asProgramClass());
+        processor.process(clazz.asProgramClass());
       }
     }
     return processor.companionClasses;
@@ -236,7 +236,7 @@
     ClassProcessor processor = new ClassProcessor(this);
     for (DexProgramClass clazz : builder.getProgramClasses()) {
       if (shouldProcess(clazz, flavour, false)) {
-        processor.process(clazz.get());
+        processor.process(clazz);
       }
     }
     return processor.getForwardMethods();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 37bfdaa..cb518a3 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -11,7 +11,6 @@
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexAnnotationSetRefList;
 import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClassPromise;
 import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -388,6 +387,10 @@
     DexClass definitionFor(DexType type) {
       return rewriter.converter.appInfo.app.definitionFor(type);
     }
+
+    DexProgramClass programDefinitionFor(DexType type) {
+      return rewriter.converter.appInfo.app.programDefinitionFor(type);
+    }
   }
 
   // Used for targeting methods referenced directly without creating accessors.
@@ -415,9 +418,7 @@
       // We already found the static method to be called, just relax its accessibility.
       assert descriptor.getAccessibility() != null;
       descriptor.getAccessibility().unsetPrivate();
-      DexClassPromise promise = definitionFor(descriptor.implHandle.asMethod().holder);
-      assert promise != null;
-      DexClass implMethodHolder = promise.get();
+      DexClass implMethodHolder = definitionFor(descriptor.implHandle.asMethod().holder);
       if (implMethodHolder.isInterface()) {
         descriptor.getAccessibility().setPublic();
       }
@@ -438,9 +439,7 @@
       // For all instantiation points for which compiler creates lambda$
       // methods, it creates these methods in the same class/interface.
       DexMethod implMethod = descriptor.implHandle.asMethod();
-      DexClassPromise promise = definitionFor(implMethod.holder);
-      assert promise != null;
-      DexClass implMethodHolder = promise.get();
+      DexClass implMethodHolder = definitionFor(implMethod.holder);
 
       DexEncodedMethod[] directMethods = implMethodHolder.directMethods;
       for (int i = 0; i < directMethods.length; i++) {
@@ -481,9 +480,8 @@
     @Override
     boolean ensureAccessibility() {
       // Create a static accessor with proper accessibility.
-      DexClassPromise promise = definitionFor(callTarget.holder);
-      assert promise != null && promise.isProgramClass();
-      DexClass accessorClass = promise.get();
+      DexProgramClass accessorClass = programDefinitionFor(callTarget.holder);
+      assert accessorClass != null;
 
       DexAccessFlags accessorFlags = new DexAccessFlags(
           Constants.ACC_SYNTHETIC | Constants.ACC_STATIC |
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index e5b8306..c280a23 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -48,6 +48,7 @@
 import com.android.tools.r8.ir.code.Switch;
 import com.android.tools.r8.ir.code.Switch.Type;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.conversion.OptimizationFeedback;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.LongInterval;
 import com.google.common.base.Equivalence;
@@ -78,7 +79,7 @@
   private static final int UNKNOWN_CAN_THROW = 0;
   private static final int CAN_THROW = 1;
   private static final int CANNOT_THROW = 2;
-  private static final int MAX_FILL_ARRAY_SIZE = 4 * Constants.KILOBYTE;
+  private static final int MAX_FILL_ARRAY_SIZE = 8 * Constants.KILOBYTE;
 
   private final AppInfo appInfo;
   private final DexItemFactory dexItemFactory;
@@ -607,7 +608,7 @@
   }
 
   public void identifyReturnsArgument(
-      DexEncodedMethod method, IRCode code) {
+      DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
     if (code.getNormalExitBlock() != null) {
       Return ret = code.getNormalExitBlock().exit().asReturn();
       if (!ret.isReturnVoid()) {
@@ -616,14 +617,14 @@
           // Find the argument number.
           int index = code.collectArguments().indexOf(returnValue);
           assert index != -1;
-          method.markReturnsArgument(index);
+          feedback.methodReturnsArgument(method, index);
         }
         if (returnValue.isConstant() && returnValue.definition.isConstNumber()) {
           long value = returnValue.definition.asConstNumber().getRawValue();
-          method.markReturnsConstant(value);
+          feedback.methodReturnsConstant(method, value);
         }
         if (returnValue.isNeverNull()) {
-          method.markNeverReturnsNull();
+          feedback.methodNeverReturnsNull(method);
         }
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index f677637..f57c022 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -50,23 +50,23 @@
     this.options = options;
   }
 
-  private InliningConstraint instructionAllowedForInlining(
+  private Constraint instructionAllowedForInlining(
       DexEncodedMethod method, Instruction instruction) {
-    InliningConstraint result = instruction.inliningConstraint(appInfo, method.method.holder);
-    if ((result == InliningConstraint.NEVER) && instruction.isDebugInstruction()) {
-      return InliningConstraint.ALWAYS;
+    Constraint result = instruction.inliningConstraint(appInfo, method.method.holder);
+    if ((result == Constraint.NEVER) && instruction.isDebugInstruction()) {
+      return Constraint.ALWAYS;
     }
     return result;
   }
 
-  public InliningConstraint identifySimpleMethods(IRCode code, DexEncodedMethod method) {
+  public Constraint identifySimpleMethods(IRCode code, DexEncodedMethod method) {
     DexCode dex = method.getCode().asDexCode();
     // We have generated code for a method and we want to figure out whether the method is a
     // candidate for inlining. The code is the final IR after optimizations.
     if (dex.instructions.length > INLINING_INSTRUCTION_LIMIT) {
-      return InliningConstraint.NEVER;
+      return Constraint.NEVER;
     }
-    InliningConstraint result = InliningConstraint.ALWAYS;
+    Constraint result = Constraint.ALWAYS;
     ListIterator<BasicBlock> iterator = code.listIterator();
     assert iterator.hasNext();
     BasicBlock block = iterator.next();
@@ -76,9 +76,9 @@
       InstructionListIterator it = block.listIterator();
       while (it.hasNext()) {
         Instruction instruction = it.next();
-        InliningConstraint state = instructionAllowedForInlining(method, instruction);
-        if (state == InliningConstraint.NEVER) {
-          return InliningConstraint.NEVER;
+        Constraint state = instructionAllowedForInlining(method, instruction);
+        if (state == Constraint.NEVER) {
+          return Constraint.NEVER;
         }
         if (state.ordinal() < result.ordinal()) {
           result = state;
@@ -105,7 +105,7 @@
     return methodHolder.isSamePackage(targetHolder);
   }
 
-  public enum InliningConstraint {
+  public enum Constraint {
     // The ordinal values are important so please do not reorder.
     NEVER,    // Never inline this.
     PRIVATE,  // Only inline this into methods with same holder.
@@ -113,23 +113,27 @@
     ALWAYS,   // No restrictions for inlining this.
   }
 
+  public enum Reason {
+    FORCE,         // Inlinee is marked for forced inlining (bridge method or renamed constructor).
+    SINGLE_CALLER, // Inlinee has precisely one caller.
+    DUAL_CALLER,   // Inlinee has precisely two callers.
+    SIMPLE,        // Inlinee has simple code suitable for inlining.
+  }
+
   static public class InlineAction {
 
     public final DexEncodedMethod target;
     public final Invoke invoke;
-    public final boolean forceInline;
+    public final Reason reason;
 
-    public InlineAction(
-        DexEncodedMethod target, Invoke invoke, boolean forceInline) {
+    public InlineAction(DexEncodedMethod target, Invoke invoke, Reason reason) {
       this.target = target;
       this.invoke = invoke;
-      this.forceInline = forceInline;
+      this.reason = reason;
     }
 
-    public InlineAction(DexEncodedMethod target, Invoke invoke) {
-      this.target = target;
-      this.invoke = invoke;
-      this.forceInline = target.getOptimizationInfo().forceInline();
+    public boolean forceInline() {
+      return reason != Reason.SIMPLE;
     }
 
     public IRCode buildIR(ValueNumberGenerator generator, AppInfoWithSubtyping appInfo,
@@ -275,7 +279,7 @@
               // Back up before the invoke instruction.
               iterator.previous();
               instruction_allowance -= numberOfInstructions(inlinee);
-              if (instruction_allowance >= 0 || result.forceInline) {
+              if (instruction_allowance >= 0 || result.forceInline()) {
                 iterator.inlineInvoke(code, inlinee, blockIterator, blocksToRemove, downcast);
               }
               // If we inlined the invoke from a bridge method, it is no longer a bridge method.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
index 954f11c..7d83150 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningOracle.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.CallGraph;
 import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.android.tools.r8.logging.Log;
 
 /**
@@ -103,6 +104,19 @@
     return candidate;
   }
 
+  private Reason computeInliningReason(DexEncodedMethod target) {
+    if (target.getOptimizationInfo().forceInline()) {
+      return Reason.FORCE;
+    }
+    if (callGraph.hasSingleCallSite(target)) {
+      return Reason.SINGLE_CALLER;
+    }
+    if (isDoubleInliningTarget(target)) {
+      return Reason.DUAL_CALLER;
+    }
+    return Reason.SIMPLE;
+  }
+
   public InlineAction computeForInvokeWithReceiver(InvokeMethodWithReceiver invoke) {
     boolean receiverIsNeverNull = invoke.receiverIsNeverNull();
     if (!receiverIsNeverNull) {
@@ -120,11 +134,9 @@
       return null;
     }
 
-    boolean fromBridgeMethod = target.getOptimizationInfo().forceInline();
-
     if (target == method) {
       // Bridge methods should never have recursive calls.
-      assert !fromBridgeMethod;
+      assert !target.getOptimizationInfo().forceInline();
       return null;
     }
 
@@ -154,11 +166,9 @@
       return null;
     }
 
-    boolean doubleInlineTarget = isDoubleInliningTarget(target);
+    Reason reason = computeInliningReason(target);
     // Determine if this should be inlined no matter how big it is.
-    boolean forceInline =
-        fromBridgeMethod | callGraph.hasSingleCallSite(target) | doubleInlineTarget;
-    if (!target.isInliningCandidate(method, forceInline)) {
+    if (!target.isInliningCandidate(method, reason != Reason.SIMPLE)) {
       // Abort inlining attempt if the single target is not an inlining candidate.
       if (info != null) {
         info.exclude(invoke, "target is not identified for inlining");
@@ -175,7 +185,7 @@
     }
 
     // Attempt to inline a candidate that is only called twice.
-    if (doubleInlineTarget && (doubleInlining(target) == null)) {
+    if ((reason == Reason.DUAL_CALLER) && (doubleInlining(target) == null)) {
       if (info != null) {
         info.exclude(invoke, "target is not ready for double inlining");
       }
@@ -185,7 +195,7 @@
     if (info != null) {
       info.include(invoke.getType(), target);
     }
-    return new InlineAction(target, invoke, forceInline);
+    return new InlineAction(target, invoke, reason);
   }
 
   public InlineAction computeForInvokeVirtual(InvokeVirtual invoke) {
@@ -224,12 +234,9 @@
     if (candidate == null) {
       return null;
     }
-    boolean fromBridgeMethod = candidate.getOptimizationInfo().forceInline();
-    boolean doubleInlineTarget = isDoubleInliningTarget(candidate);
+    Reason reason = computeInliningReason(candidate);
     // Determine if this should be inlined no matter how big it is.
-    boolean forceInline =
-        fromBridgeMethod | callGraph.hasSingleCallSite(candidate) | doubleInlineTarget;
-    if (!candidate.isInliningCandidate(method, forceInline)) {
+    if (!candidate.isInliningCandidate(method, reason != Reason.SIMPLE)) {
       // Abort inlining attempt if the single target is not an inlining candidate.
       if (info != null) {
         info.exclude(invoke, "target is not identified for inlining");
@@ -246,7 +253,7 @@
     }
 
     // Attempt to inline a candidate that is only called twice.
-    if (doubleInlineTarget && (doubleInlining(candidate) == null)) {
+    if ((reason == Reason.DUAL_CALLER) && (doubleInlining(candidate) == null)) {
       if (info != null) {
         info.exclude(invoke, "target is not ready for double inlining");
       }
@@ -256,7 +263,7 @@
     if (info != null) {
       info.include(invoke.getType(), candidate);
     }
-    return new InlineAction(candidate, invoke);
+    return new InlineAction(candidate, invoke, reason);
   }
 
   public InlineAction computeForInvokeSuper(InvokeSuper invoke) {
@@ -270,7 +277,7 @@
     if (info != null) {
       info.include(invoke.getType(), candidate);
     }
-    return new InlineAction(candidate, invoke);
+    return new InlineAction(candidate, invoke, Reason.SIMPLE);
   }
 
   public InlineAction computeForInvokePolymorpic(InvokePolymorphic invoke) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
index b122d23..df5cb27 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MemberValuePropagation.java
@@ -236,8 +236,7 @@
   private boolean isFieldRead(DexEncodedField field, boolean isStatic) {
     // Without live set information we cannot tell and assume true.
     if (liveSet == null
-        || isStatic && liveSet.staticFieldsRead.contains(field.field)
-        || !isStatic && liveSet.instanceFieldsRead.contains(field.field)
+        || liveSet.fieldsRead.contains(field.field)
         || liveSet.pinnedItems.contains(field)) {
       return true;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 42b5220..0ea5761 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -812,9 +812,9 @@
     }
 
     @Override
-    public boolean traceInstruction(int instructionIndex, IRBuilder builder) {
+    public int traceInstruction(int instructionIndex, IRBuilder builder) {
       // There is just one block, and after the last instruction it is closed.
-      return instructionIndex == outline.templateInstructions.size();
+      return instructionIndex == outline.templateInstructions.size() ? instructionIndex : -1;
     }
 
     @Override
@@ -991,7 +991,7 @@
     }
 
     @Override
-    public String toString(ClassNameMapper naming) {
+    public String toString(DexEncodedMethod method, ClassNameMapper naming) {
       return null;
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index 3a96ac2..9276f45 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -25,6 +25,7 @@
 import com.android.tools.r8.ir.code.Xor;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.utils.CfgPrinter;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.HashMultiset;
@@ -62,6 +63,8 @@
  */
 public class LinearScanRegisterAllocator implements RegisterAllocator {
   public static final int NO_REGISTER = Integer.MIN_VALUE;
+  public static final int REGISTER_CANDIDATE_NOT_FOUND = -1;
+  public static final int MIN_CONSTANT_FREE_FOR_POSITIONS = 5;
 
   private enum ArgumentReuseMode {
     ALLOW_ARGUMENT_REUSE,
@@ -107,6 +110,8 @@
   private final IRCode code;
   // Number of registers used for arguments.
   private final int numberOfArgumentRegisters;
+  // Compiler options.
+  private final InternalOptions options;
 
   // Mapping from basic blocks to the set of values live at entry to that basic block.
   private Map<BasicBlock, Set<Value>> liveAtEntrySets = new IdentityHashMap<>();
@@ -142,8 +147,9 @@
   // register.
   private boolean hasDedicatedMoveExceptionRegister = false;
 
-  public LinearScanRegisterAllocator(IRCode code) {
+  public LinearScanRegisterAllocator(IRCode code, InternalOptions options) {
     this.code = code;
+    this.options = options;
     int argumentRegisters = 0;
     for (Instruction instruction : code.blocks.getFirst().getInstructions()) {
       if (instruction.isArgument()) {
@@ -420,6 +426,14 @@
     return getRegisterForIntervals(intervals);
   }
 
+  @Override
+  public int getArgumentOrAllocateRegisterForValue(Value value, int instructionNumber) {
+    if (value.isArgument()) {
+      return getRegisterForIntervals(value.getLiveIntervals());
+    }
+    return getRegisterForValue(value, instructionNumber);
+  }
+
   private BasicBlock[] computeLivenessInformation() {
     BasicBlock[] blocks = code.numberInstructions();
     computeLiveAtEntrySets();
@@ -557,18 +571,18 @@
         active.add(argumentInterval);
       } else {
         // Treat the argument interval as spilled which will require a load to a different
-        // register for all usages.
+        // register for all register-constrained usages.
         if (argumentInterval.getUses().size() > 1) {
           LiveIntervalsUse use = argumentInterval.firstUseWithConstraint();
           if (use != null) {
             LiveIntervals split;
-            if (argumentInterval.getUses().size() == 2) {
-              // If there is only one real use (definition plus one real use), split before
+            if (argumentInterval.numberOfUsesWithConstraint() == 1) {
+              // If there is only one register-constrained use, split before
               // that one use.
               split = argumentInterval.splitBefore(use.getPosition());
             } else {
-              // If there are multiple real users, split right after the definition to make it
-              // more likely that arguments get in usable registers from the start.
+              // If there are multiple register-constrained users, split right after the definition
+              // to make it more likely that arguments get in usable registers from the start.
               split = argumentInterval
                   .splitBefore(argumentInterval.getValue().definition.getNumber() + 1);
             }
@@ -908,17 +922,24 @@
 
     if (mode == ArgumentReuseMode.ALLOW_ARGUMENT_REUSE) {
       // The sentinel registers cannot be used and we block them.
-      freePositions.set(0, 0);
+      freePositions.set(0, 0, false);
+      if (options.debug && !code.method.accessFlags.isStatic()) {
+        // If we are generating debug information, we pin the this value register since the
+        // debugger expects to always be able to find it in the input register.
+        assert numberOfArgumentRegisters > 0;
+        assert preArgumentSentinelValue.getNextConsecutive().requiredRegisters() == 1;
+        freePositions.set(1, 0, false);
+      }
       int lastSentinelRegister = numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS - 1;
       if (lastSentinelRegister <= registerConstraint) {
-        freePositions.set(lastSentinelRegister, 0);
+        freePositions.set(lastSentinelRegister, 0, false);
       }
     } else {
       // Argument reuse is not allowed and we block all the argument registers so that
       // arguments are never free.
       for (int i = 0; i < numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS; i++) {
         if (i <= registerConstraint) {
-          freePositions.set(i, 0);
+          freePositions.set(i, 0, false);
         }
       }
     }
@@ -930,7 +951,7 @@
     if (hasDedicatedMoveExceptionRegister) {
       int moveExceptionRegister = numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS;
       if (moveExceptionRegister <= registerConstraint) {
-        freePositions.set(moveExceptionRegister, 0);
+        freePositions.set(moveExceptionRegister, 0, false);
       }
     }
 
@@ -940,7 +961,7 @@
       if (activeRegister <= registerConstraint) {
         for (int i = 0; i < intervals.requiredRegisters(); i++) {
           if (activeRegister + i <= registerConstraint) {
-            freePositions.set(activeRegister + i, 0);
+            freePositions.set(activeRegister + i, 0, intervals.isConstantNumberInterval());
           }
         }
       }
@@ -953,17 +974,18 @@
       if (inactiveRegister <= registerConstraint && unhandledInterval.overlaps(intervals)) {
         int nextOverlap = unhandledInterval.nextOverlap(intervals);
         for (int i = 0; i < intervals.requiredRegisters(); i++) {
-          if (inactiveRegister + i <= registerConstraint) {
+          int register = inactiveRegister + i;
+          if (register <= registerConstraint) {
             int unhandledStart = toInstructionPosition(unhandledInterval.getStart());
             if (nextOverlap == unhandledStart) {
               // Don't use the register for an inactive interval that is only free until the next
               // instruction. We can get into this situation when unhandledInterval starts at a
               // gap position.
-              freePositions.set(inactiveRegister + i, 0);
+              freePositions.set(register, 0, freePositions.holdsConstant(register));
             } else {
-              freePositions.set(
-                  inactiveRegister + i,
-                  Math.min(freePositions.get(inactiveRegister + i), nextOverlap));
+              if (nextOverlap < freePositions.get(register)) {
+                freePositions.set(register, nextOverlap, intervals.isConstantNumberInterval());
+              }
             }
           }
         }
@@ -978,7 +1000,8 @@
     // Get the register (pair) that is free the longest. That is the register with the largest
     // free position.
     int candidate = getLargestValidCandidate(
-        unhandledInterval, registerConstraint, needsRegisterPair, freePositions);
+        unhandledInterval, registerConstraint, needsRegisterPair, freePositions, false);
+    assert candidate != REGISTER_CANDIDATE_NOT_FOUND;
     int largestFreePosition = freePositions.get(candidate);
     if (needsRegisterPair) {
       largestFreePosition = Math.min(largestFreePosition, freePositions.get(candidate + 1));
@@ -992,7 +1015,24 @@
         // argument reuse disallowed.
         return false;
       }
-      allocateBlockedRegister(unhandledInterval);
+      // If the first use for these intervals is unconstrained, just spill this interval instead
+      // of finding another candidate to spill via allocateBlockedRegister.
+      if (!unhandledInterval.getUses().first().hasConstraint()) {
+        int nextConstrainedPosition = unhandledInterval.firstUseWithConstraint().getPosition();
+        int register;
+        // Arguments are always in the argument registers, so for arguments just use that register
+        // for the unconstrained prefix. For everything else, get a spill register.
+        if (unhandledInterval.isArgumentInterval()) {
+          register = unhandledInterval.getSplitParent().getRegister();
+        } else {
+          register = getSpillRegister(unhandledInterval);
+        }
+        LiveIntervals split = unhandledInterval.splitBefore(nextConstrainedPosition);
+        assignRegisterToUnhandledInterval(unhandledInterval, needsRegisterPair, register);
+        unhandled.add(split);
+      } else {
+        allocateBlockedRegister(unhandledInterval);
+      }
     } else if (largestFreePosition >= unhandledInterval.getEnd()) {
       // Free for the entire interval. Allocate the register.
       assignRegisterToUnhandledInterval(unhandledInterval, needsRegisterPair, candidate);
@@ -1004,8 +1044,7 @@
       }
       // The candidate is free for the beginning of an interval. We split the interval
       // and use the register for as long as we can.
-      int splitPosition = largestFreePosition;
-      LiveIntervals split = unhandledInterval.splitBefore(splitPosition);
+      LiveIntervals split = unhandledInterval.splitBefore(largestFreePosition);
       assert split != unhandledInterval;
       assignRegisterToUnhandledInterval(unhandledInterval, needsRegisterPair, candidate);
       unhandled.add(split);
@@ -1130,14 +1169,15 @@
     active.add(unhandledInterval);
   }
 
-  private int getLargestCandidate(
-      int registerConstraint, RegisterPositions freePositions, boolean needsRegisterPair) {
-    int candidate = 0;
-    int largest = freePositions.get(0);
-    if (needsRegisterPair) {
-      largest = Math.min(largest, freePositions.get(1));
-    }
-    for (int i = 1; i <= registerConstraint; i++) {
+  private int getLargestCandidate(int registerConstraint, RegisterPositions freePositions,
+      boolean needsRegisterPair, boolean restrictToConstant) {
+    int candidate = REGISTER_CANDIDATE_NOT_FOUND;
+    int largest = -1;
+
+    for (int i = 0; i <= registerConstraint; i++) {
+      if (restrictToConstant && !freePositions.holdsConstant(i)) {
+        continue;
+      }
       int freePosition = freePositions.get(i);
       if (needsRegisterPair) {
         if (i >= registerConstraint) {
@@ -1153,17 +1193,23 @@
         }
       }
     }
+
     return candidate;
   }
 
   private int getLargestValidCandidate(LiveIntervals unhandledInterval, int registerConstraint,
-      boolean needsRegisterPair, RegisterPositions freePositions) {
-    int candidate = getLargestCandidate(registerConstraint, freePositions, needsRegisterPair);
+      boolean needsRegisterPair, RegisterPositions freePositions, boolean restrictToConstant) {
+    int candidate = getLargestCandidate(registerConstraint, freePositions, needsRegisterPair,
+        restrictToConstant);
+    if (candidate == REGISTER_CANDIDATE_NOT_FOUND) {
+      return candidate;
+    }
     if (needsOverlappingLongRegisterWorkaround(unhandledInterval)) {
       while (hasOverlappingLongRegisters(unhandledInterval, candidate)) {
         // Make the overlapping register unavailable for allocation and try again.
-        freePositions.set(candidate, 0);
-        candidate = getLargestCandidate(registerConstraint, freePositions, needsRegisterPair);
+        freePositions.set(candidate, 0, freePositions.holdsConstant(candidate));
+        candidate = getLargestCandidate(registerConstraint, freePositions, needsRegisterPair,
+            restrictToConstant);
       }
     }
     return candidate;
@@ -1190,7 +1236,8 @@
         for (int i = 0; i < intervals.requiredRegisters(); i++) {
           if (activeRegister + i <= registerConstraint) {
             int unhandledStart = unhandledInterval.getStart();
-            usePositions.set(activeRegister + i, intervals.firstUseAfter(unhandledStart));
+            usePositions.set(activeRegister + i, intervals.firstUseAfter(unhandledStart),
+                intervals.isConstantNumberInterval());
           }
         }
       }
@@ -1202,9 +1249,11 @@
       if (inactiveRegister <= registerConstraint && intervals.overlaps(unhandledInterval)) {
         for (int i = 0; i < intervals.requiredRegisters(); i++) {
           if (inactiveRegister + i <= registerConstraint) {
-            int unhandledStart = unhandledInterval.getStart();
-            usePositions.set(inactiveRegister + i, Math.min(
-                usePositions.get(inactiveRegister + i), intervals.firstUseAfter(unhandledStart)));
+            int firstUse = intervals.firstUseAfter(unhandledInterval.getStart());
+            if (firstUse < usePositions.get(inactiveRegister + i)) {
+              usePositions.set(inactiveRegister + i, firstUse,
+                  intervals.isConstantNumberInterval());
+            }
           }
         }
       }
@@ -1213,38 +1262,46 @@
     // Disallow the reuse of argument registers by always treating them as being used
     // at instruction number 0.
     for (int i = 0; i < numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS; i++) {
-      usePositions.set(i, 0);
+      usePositions.set(i, 0, false);
     }
 
     // Disallow reuse of the move exception register if we have reserved one.
     if (hasDedicatedMoveExceptionRegister) {
-      usePositions.set(numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS, 0);
+      usePositions.set(numberOfArgumentRegisters + NUMBER_OF_SENTINEL_REGISTERS, 0, false);
     }
 
     // Treat active linked argument intervals as pinned. They cannot be given another register
     // at their uses.
-    blockLinkedRegisters(
-        active, unhandledInterval, registerConstraint, usePositions, blockedPositions);
+    blockLinkedRegisters(active, unhandledInterval, registerConstraint, usePositions,
+        blockedPositions);
 
     // Treat inactive linked argument intervals as pinned. They cannot be given another register
     // at their uses.
-    blockLinkedRegisters(
-        inactive, unhandledInterval, registerConstraint, usePositions, blockedPositions);
+    blockLinkedRegisters(inactive, unhandledInterval, registerConstraint, usePositions,
+        blockedPositions);
 
     // Get the register (pair) that has the highest use position.
     boolean needsRegisterPair = unhandledInterval.requiredRegisters() == 2;
-    int candidate = getLargestValidCandidate(
-        unhandledInterval, registerConstraint, needsRegisterPair, usePositions);
-    int largestUsePosition = usePositions.get(candidate);
-    int blockedPosition = blockedPositions.get(candidate);
-    if (needsRegisterPair) {
-      blockedPosition = Math.min(blockedPosition, blockedPositions.get(candidate + 1));
-      largestUsePosition = Math.min(largestUsePosition, usePositions.get(candidate + 1));
+
+    int candidate = getLargestValidCandidate(unhandledInterval, registerConstraint,
+        needsRegisterPair, usePositions, true);
+    if (candidate != Integer.MAX_VALUE) {
+      int nonConstCandidate = getLargestValidCandidate(unhandledInterval, registerConstraint,
+          needsRegisterPair, usePositions, false);
+      if (nonConstCandidate == Integer.MAX_VALUE || candidate == REGISTER_CANDIDATE_NOT_FOUND) {
+        candidate = nonConstCandidate;
+      } else {
+        int largestConstUsePosition = getLargestPosition(usePositions, candidate, needsRegisterPair);
+        if (largestConstUsePosition - MIN_CONSTANT_FREE_FOR_POSITIONS < unhandledInterval
+            .getStart()) {
+          // The candidate that can be rematerialized has a live range too short to use it.
+          candidate = nonConstCandidate;
+        }
+      }
     }
 
-    // TODO(ager): When selecting a spill candidate also take rematerialization into account.
-    // Prefer spilling a constant that can be rematerialized instead of spilling something that
-    // cannot be rematerialized.
+    int largestUsePosition = getLargestPosition(usePositions, candidate, needsRegisterPair);
+    int blockedPosition = getBlockedPosition(blockedPositions, candidate, needsRegisterPair);
 
     if (largestUsePosition < unhandledInterval.getFirstUse()) {
       // All active and inactive intervals are used before current. Therefore, it is best to spill
@@ -1271,6 +1328,28 @@
     }
   }
 
+  private int getLargestPosition(RegisterPositions usePositions, int register,
+      boolean needsRegisterPair) {
+    int largestUsePosition = usePositions.get(register);
+
+    if (needsRegisterPair) {
+      largestUsePosition = Math.min(largestUsePosition, usePositions.get(register + 1));
+    }
+
+    return largestUsePosition;
+  }
+
+  private int getBlockedPosition(RegisterPositions blockedPositions, int register,
+      boolean needsRegisterPair) {
+    int blockedPosition = blockedPositions.get(register);
+
+    if (needsRegisterPair) {
+      blockedPosition = Math.min(blockedPosition, blockedPositions.get(register + 1));
+    }
+
+    return blockedPosition;
+  }
+
   private void assignRegisterAndSpill(
       LiveIntervals unhandledInterval, boolean needsRegisterPair, int candidate) {
     assignRegister(unhandledInterval, candidate);
@@ -1401,7 +1480,8 @@
     assert spilled.isSpilled();
     assert spilled.getValue().isConstant();
     assert !spilled.isLinked() || spilled.isArgumentInterval();
-    int maxGapSize = 50 * INSTRUCTION_NUMBER_DELTA;
+    // Do not split range if constant is reused by one of the eleven following instruction.
+    int maxGapSize = 11 * INSTRUCTION_NUMBER_DELTA;
     if (!spilled.getUses().isEmpty()) {
       // Split at first use after the spill position and add to unhandled to get a register
       // assigned for rematerialization.
@@ -1447,15 +1527,12 @@
         if (register <= registerConstraint && other.overlaps(interval)) {
           for (int i = 0; i < other.requiredRegisters(); i++) {
             if (register + i <= registerConstraint) {
-              for (LiveIntervalsUse use : other.getUses()) {
-                if (use.getPosition() > interval.getStart()) {
-                  blockedPositions.set(
-                      register + i,
-                      Math.min(blockedPositions.get(register + i), use.getPosition()));
-                  usePositions.set(
-                      register + i,
-                      Math.min(usePositions.get(register + i), use.getPosition()));
-                }
+              int firstUse = other.firstUseAfter(interval.getStart());
+              if (firstUse < blockedPositions.get(register + i)) {
+                blockedPositions.set(register + i, firstUse, other.isConstantNumberInterval());
+                // If we start blocking registers other than linked arguments, we might need to
+                // explicitly update the use positions as well as blocked positions.
+                assert usePositions.get(register + i) <= blockedPositions.get(register + i);
               }
             }
           }
@@ -1507,7 +1584,7 @@
         // If we are processing an exception edge, we need to use the throwing instruction
         // as the instruction we are coming from.
         int fromInstruction = block.exit().getNumber();
-        boolean isCatch = block.isCatchSuccessor(successor);
+        boolean isCatch = block.hasCatchSuccessor(successor);
         if (isCatch) {
           for (Instruction instruction : block.getInstructions()) {
             if (instruction.instructionTypeCanThrow()) {
@@ -1748,7 +1825,7 @@
   private void generateArgumentMoves(Invoke invoke, InstructionListIterator insertAt) {
     // If the invoke instruction require more than 5 registers we link the inputs because they
     // need to be in consecutive registers.
-    if (invoke.requiredArgumentRegisters() > 5) {
+    if (invoke.requiredArgumentRegisters() > 5 && !argumentsAreAlreadyLinked(invoke)) {
       List<Value> arguments = invoke.arguments();
       Value previous = null;
       for (int i = 0; i < arguments.size(); i++) {
@@ -1766,6 +1843,19 @@
     }
   }
 
+  private boolean argumentsAreAlreadyLinked(Invoke invoke) {
+    Iterator<Value> it = invoke.arguments().iterator();
+    Value current = it.next();
+    while (it.hasNext()) {
+      Value next = it.next();
+      if (!current.isLinked() || current.getNextConsecutive() != next) {
+        return false;
+      }
+      current = next;
+    }
+    return true;
+  }
+
   private Value createSentinelRegisterValue() {
     return createValue(MoveType.OBJECT, null);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervals.java b/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervals.java
index c966813..f01ed3a 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervals.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervals.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.regalloc;
 
+import static com.android.tools.r8.dex.Constants.U16BIT_MAX;
 import static com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator.NO_REGISTER;
 
 import com.android.tools.r8.dex.Constants;
@@ -29,7 +30,7 @@
   private boolean spilled = false;
 
   // Only registers up to and including the registerLimit are allowed for this interval.
-  private int registerLimit = Constants.U16BIT_MAX;
+  private int registerLimit = U16BIT_MAX;
 
   // Max register used for any of the non-spilled splits for these live intervals or for any of the
   // live intervals that this live interval is connected to by phi moves. This is used to
@@ -331,7 +332,7 @@
 
   public LiveIntervalsUse firstUseWithConstraint() {
     for (LiveIntervalsUse use : uses) {
-      if (use.getLimit() < Constants.U16BIT_MAX) {
+      if (use.hasConstraint()) {
         return use;
       }
     }
@@ -386,13 +387,14 @@
   }
 
   private void recomputeLimit() {
-    registerLimit = Constants.U16BIT_MAX;
+    registerLimit = U16BIT_MAX;
     for (LiveIntervalsUse use : uses) {
       updateRegisterConstraint(use.getLimit());
     }
   }
 
   public LiveIntervals getSplitCovering(int instructionNumber) {
+    assert getSplitParent() == this;
     // Check if this interval itself is covering the instruction.
     if (getStart() <= instructionNumber && getEnd() > instructionNumber) {
       return this;
@@ -417,6 +419,20 @@
     return null;
   }
 
+  public boolean isConstantNumberInterval() {
+    return value.definition != null && value.definition.isConstNumber();
+  }
+
+  public int numberOfUsesWithConstraint() {
+    int count = 0;
+    for (LiveIntervalsUse use : getUses()) {
+      if (use.hasConstraint()) {
+        count++;
+      }
+    }
+    return count;
+  }
+
   @Override
   public String toString() {
     StringBuilder builder = new StringBuilder();
@@ -468,4 +484,4 @@
       splitChild.print(printer, number + delta, number);
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervalsUse.java b/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervalsUse.java
index fd37af8..a602134 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervalsUse.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LiveIntervalsUse.java
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.regalloc;
 
+import static com.android.tools.r8.dex.Constants.U16BIT_MAX;
+
 public class LiveIntervalsUse implements Comparable<LiveIntervalsUse> {
   private int position;
   private int limit;
@@ -41,4 +43,8 @@
     }
     return limit - o.limit;
   }
+
+  public boolean hasConstraint() {
+    return limit < U16BIT_MAX;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/RegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/RegisterAllocator.java
index 9dba6d0..79ba8db 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/RegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/RegisterAllocator.java
@@ -10,4 +10,5 @@
   int registersUsed();
   int getRegisterForValue(Value value, int instructionNumber);
   boolean argumentValueUsesHighRegister(Value value, int instructionNumber);
+  int getArgumentOrAllocateRegisterForValue(Value value, int instructionNumber);
 }
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/RegisterPositions.java b/src/main/java/com/android/tools/r8/ir/regalloc/RegisterPositions.java
index 87eedca..35b87fc 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/RegisterPositions.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/RegisterPositions.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.ir.regalloc;
 
 import java.util.Arrays;
+import java.util.BitSet;
 
 /**
  * Simple mapping from a register to an int value.
@@ -16,6 +17,7 @@
   private static final int INITIAL_SIZE = 16;
   private int limit;
   private int[] backing;
+  private BitSet registerHoldsConstant;
 
   public RegisterPositions(int limit) {
     this.limit = limit;
@@ -23,13 +25,19 @@
     for (int i = 0; i < INITIAL_SIZE; i++) {
       backing[i] = Integer.MAX_VALUE;
     }
+    registerHoldsConstant = new BitSet(limit);
   }
 
-  public void set(int index, int value) {
+  public boolean holdsConstant(int index) {
+    return registerHoldsConstant.get(index);
+  }
+
+  public void set(int index, int value, boolean holdsConstant) {
     if (index >= backing.length) {
       grow(index + 1);
     }
     backing[index] = value;
+    registerHoldsConstant.set(index, holdsConstant);
   }
 
   public int get(int index) {
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/SingleBlockSourceCode.java b/src/main/java/com/android/tools/r8/ir/synthetic/SingleBlockSourceCode.java
index 8c97f8f..22cf6d5 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/SingleBlockSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/SingleBlockSourceCode.java
@@ -124,8 +124,8 @@
   }
 
   @Override
-  public final boolean traceInstruction(int instructionIndex, IRBuilder builder) {
-    return instructionIndex == constructors.size() - 1;
+  public final int traceInstruction(int instructionIndex, IRBuilder builder) {
+    return (instructionIndex == constructors.size() - 1) ? instructionIndex : -1;
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/SynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/synthetic/SynthesizedCode.java
index 7716663..3d3f9f1 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/SynthesizedCode.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/SynthesizedCode.java
@@ -37,7 +37,7 @@
 
   @Override
   public final String toString() {
-    return toString(null);
+    return toString(null, null);
   }
 
   private static void registerReachableDefinitionsDefault(UseRegistry registry) {
@@ -61,7 +61,7 @@
   }
 
   @Override
-  public final String toString(ClassNameMapper naming) {
+  public final String toString(DexEncodedMethod method, ClassNameMapper naming) {
     return "SynthesizedCode: " + sourceCode.toString();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
index 9e9a1ad..504cc4a 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
@@ -59,10 +59,15 @@
     return canonicalizeSignature(new FieldSignature(field.name.toString(), type));
   }
 
+  /**
+   * Deobfuscate a class name.
+   *
+   * Returns the deobfuscated name if a mapping was found. Otherwise it returns the passed in name.
+   */
   public String deobfuscateClassName(String name) {
     ClassNaming classNaming = classNameMappings.get(name);
     if (classNaming == null) {
-      return null;
+      return name;
     }
     return classNaming.originalName;
   }
diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
index ee0614f..17da59b 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
@@ -4,7 +4,6 @@
 package com.android.tools.r8.optimize;
 
 import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.Descriptor;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -98,11 +97,6 @@
     return searchClass.type;
   }
 
-  private boolean isNotFromLibrary(Descriptor item) {
-    DexClass clazz = appInfo.definitionFor(item.getHolder());
-    return clazz != null && !clazz.isLibraryClass();
-  }
-
   private DexEncodedMethod virtualLookup(DexMethod method) {
     return appInfo.lookupVirtualDefinition(method.getHolder(), method);
   }
@@ -162,12 +156,12 @@
     }
     DexProgramClass newHolder = null;
     // Recurse through supertype chain.
-    if (originalClass.superType.isSubtypeOf(targetClass.getType(), appInfo)) {
+    if (originalClass.superType.isSubtypeOf(targetClass.type, appInfo)) {
       DexClass superClass = appInfo.definitionFor(originalClass.superType);
       newHolder = findBridgeMethodHolder(superClass, targetClass, packageDescriptor);
     } else {
       for (DexType iface : originalClass.interfaces.values) {
-        if (iface.isSubtypeOf(targetClass.getType(), appInfo)) {
+        if (iface.isSubtypeOf(targetClass.type, appInfo)) {
           DexClass interfaceClass = appInfo.definitionFor(iface);
           newHolder = findBridgeMethodHolder(interfaceClass, targetClass, packageDescriptor);
         }
@@ -190,13 +184,23 @@
     for (DexField field : fields) {
       field = lense.lookupField(field, null);
       DexEncodedField target = lookup.apply(field.getHolder(), field);
-      // Rebind to the lowest library class or program class.
-      if (target != null && target.field != field) {
+      // Rebind to the lowest library class or program class. Do not rebind accesses to fields that
+      // are not public, as this might lead to access violation errors.
+      if (target != null && target.field != field && isVisibleFromOtherClasses(target)) {
         builder.map(field, validTargetFor(target.field, field, lookupTargetOnClass));
       }
     }
   }
 
+  private boolean isVisibleFromOtherClasses(DexEncodedField field) {
+    // If the field is not public, the visibility on the class can not be a further constraint.
+    if (!field.accessFlags.isPublic()) {
+      return true;
+    }
+    // If the field is public, then a non-public holder class will further constrain visibility.
+    return appInfo.definitionFor(field.field.getHolder()).accessFlags.isPublic();
+  }
+
   private static void privateMethodsCheck(DexProgramClass clazz, DexEncodedMethod method) {
     throw new Unreachable("Direct invokes should not require forwarding.");
   }
@@ -211,9 +215,9 @@
     computeMethodRebinding(appInfo.staticInvokes, appInfo::lookupStaticTarget,
         DexClass::findDirectTarget, DexProgramClass::addStaticMethod);
 
-    computeFieldRebinding(Sets.union(appInfo.staticFieldsRead, appInfo.staticFieldsWritten),
+    computeFieldRebinding(Sets.union(appInfo.staticFieldReads, appInfo.staticFieldWrites),
         appInfo::lookupStaticTarget, DexClass::findStaticTarget);
-    computeFieldRebinding(Sets.union(appInfo.instanceFieldsRead, appInfo.instanceFieldsWritten),
+    computeFieldRebinding(Sets.union(appInfo.instanceFieldReads, appInfo.instanceFieldWrites),
         appInfo::lookupInstanceTarget, DexClass::findInstanceTarget);
     return builder.build(lense, appInfo.dexItemFactory);
   }
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 2dab755..abdda65 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -37,6 +37,7 @@
 import com.google.common.collect.Sets;
 import com.google.common.collect.Sets.SetView;
 import java.util.ArrayDeque;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
@@ -47,6 +48,7 @@
 import java.util.Queue;
 import java.util.Set;
 import java.util.function.BiFunction;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
@@ -856,9 +858,8 @@
   }
 
   private Set<DexField> collectFields(Map<DexType, Set<DexField>> map) {
-    Set<DexField> set = Sets.newIdentityHashSet();
-    map.values().forEach(set::addAll);
-    return set;
+    return map.values().stream().flatMap(Collection::stream)
+        .collect(Collectors.toCollection(Sets::newIdentityHashSet));
   }
 
   Set<DexField> collectInstanceFieldsRead() {
@@ -877,6 +878,32 @@
     return Collections.unmodifiableSet(collectFields(staticFieldsWritten));
   }
 
+  private Set<DexField> collectReachedFields(Map<DexType, Set<DexField>> map,
+      Function<DexField, DexField> lookup) {
+    return map.values().stream().flatMap(set -> set.stream().map(lookup))
+        .collect(Collectors.toCollection(Sets::newIdentityHashSet));
+  }
+
+  private DexField tryLookupInstanceField(DexField field) {
+    DexEncodedField target = appInfo.lookupInstanceTarget(field.clazz, field);
+    return target == null ? field : target.field;
+  }
+
+  private DexField tryLookupStaticField(DexField field) {
+    DexEncodedField target = appInfo.lookupStaticTarget(field.clazz, field);
+    return target == null ? field : target.field;
+  }
+
+  Set<DexField> collectFieldsRead() {
+    return Sets.union(collectReachedFields(instanceFieldsRead, this::tryLookupInstanceField),
+        collectReachedFields(staticFieldsRead, this::tryLookupStaticField));
+  }
+
+  Set<DexField> collectFieldsWritten() {
+    return Sets.union(collectReachedFields(instanceFieldsWritten, this::tryLookupInstanceField),
+        collectReachedFields(staticFieldsWritten, this::tryLookupStaticField));
+  }
+
   private static class Action {
 
     final Kind kind;
@@ -981,31 +1008,29 @@
      */
     final Set<DexField> liveFields;
     /**
-     * Set of all fields which are read. Combines {@link #instanceFieldsRead} and
-     * {@link #staticFieldsRead}.
+     * Set of all fields which may be touched by a get operation. This is actual field definitions.
      */
     public final Set<DexField> fieldsRead;
     /**
-     * Set of all fields which are written. Combines {@link #instanceFieldsWritten} and
-     * {@link #staticFieldsWritten}.
+     * Set of all fields which may be touched by a put operation. This is actual field definitions.
      */
     public final Set<DexField> fieldsWritten;
     /**
-     * Set of all instance fields which are read.
+     * Set of all field ids used in instance field reads.
      */
-    public final Set<DexField> instanceFieldsRead;
+    public final Set<DexField> instanceFieldReads;
     /**
-     * Set of all instance fields which are written.
+     * Set of all field ids used in instance field writes.
      */
-    public final Set<DexField> instanceFieldsWritten;
+    public final Set<DexField> instanceFieldWrites;
     /**
-     * Set of all static fields which are read.
+     * Set of all field ids used in static static field reads.
      */
-    public final Set<DexField> staticFieldsRead;
+    public final Set<DexField> staticFieldReads;
     /**
-     * Set of all static fields which are written.
+     * Set of all field ids used in static field writes.
      */
-    public final Set<DexField> staticFieldsWritten;
+    public final Set<DexField> staticFieldWrites;
     /**
      * Set of all methods referenced in virtual invokes;
      */
@@ -1042,12 +1067,12 @@
       this.targetedMethods = toDescriptorSet(enqueuer.targetedMethods.getItems());
       this.liveMethods = toDescriptorSet(enqueuer.liveMethods.getItems());
       this.liveFields = toDescriptorSet(enqueuer.liveFields.getItems());
-      this.instanceFieldsRead = enqueuer.collectInstanceFieldsRead();
-      this.instanceFieldsWritten = enqueuer.collectInstanceFieldsWritten();
-      this.staticFieldsRead = enqueuer.collectStaticFieldsRead();
-      this.staticFieldsWritten = enqueuer.collectStaticFieldsWritten();
-      this.fieldsRead = Sets.union(staticFieldsRead, instanceFieldsRead);
-      this.fieldsWritten = Sets.union(staticFieldsWritten, instanceFieldsWritten);
+      this.instanceFieldReads = enqueuer.collectInstanceFieldsRead();
+      this.instanceFieldWrites = enqueuer.collectInstanceFieldsWritten();
+      this.staticFieldReads = enqueuer.collectStaticFieldsRead();
+      this.staticFieldWrites = enqueuer.collectStaticFieldsWritten();
+      this.fieldsRead = enqueuer.collectFieldsRead();
+      this.fieldsWritten = enqueuer.collectFieldsWritten();
       this.pinnedItems = Collections.unmodifiableSet(enqueuer.pinnedItems);
       this.virtualInvokes = joinInvokedMethods(enqueuer.virtualInvokes);
       this.superInvokes = joinInvokedMethods(enqueuer.superInvokes);
@@ -1055,8 +1080,8 @@
       this.staticInvokes = joinInvokedMethods(enqueuer.staticInvokes);
       this.noSideEffects = enqueuer.rootSet.noSideEffects;
       this.assumedValues = enqueuer.rootSet.assumedValues;
-      assert Sets.intersection(instanceFieldsRead, staticFieldsRead).size() == 0;
-      assert Sets.intersection(instanceFieldsWritten, staticFieldsWritten).size() == 0;
+      assert Sets.intersection(instanceFieldReads, staticFieldReads).size() == 0;
+      assert Sets.intersection(instanceFieldWrites, staticFieldWrites).size() == 0;
     }
 
     private AppInfoWithLiveness(AppInfoWithLiveness previous, DexApplication application) {
@@ -1066,11 +1091,12 @@
       this.targetedMethods = previous.targetedMethods;
       this.liveMethods = previous.liveMethods;
       this.liveFields = previous.liveFields;
-      this.instanceFieldsRead = previous.instanceFieldsRead;
-      this.instanceFieldsWritten = previous.instanceFieldsWritten;
-      this.staticFieldsRead = previous.staticFieldsRead;
-      this.staticFieldsWritten = previous.staticFieldsWritten;
+      this.instanceFieldReads = previous.instanceFieldReads;
+      this.instanceFieldWrites = previous.instanceFieldWrites;
+      this.staticFieldReads = previous.staticFieldReads;
+      this.staticFieldWrites = previous.staticFieldWrites;
       this.fieldsRead = previous.fieldsRead;
+      // TODO(herhut): We remove fields that are only written, so maybe update this.
       this.fieldsWritten = previous.fieldsWritten;
       this.pinnedItems = previous.pinnedItems;
       this.noSideEffects = previous.noSideEffects;
@@ -1079,8 +1105,8 @@
       this.superInvokes = previous.superInvokes;
       this.directInvokes = previous.directInvokes;
       this.staticInvokes = previous.staticInvokes;
-      assert Sets.intersection(instanceFieldsRead, staticFieldsRead).size() == 0;
-      assert Sets.intersection(instanceFieldsWritten, staticFieldsWritten).size() == 0;
+      assert Sets.intersection(instanceFieldReads, staticFieldReads).size() == 0;
+      assert Sets.intersection(instanceFieldWrites, staticFieldWrites).size() == 0;
     }
 
     private AppInfoWithLiveness(AppInfoWithLiveness previous, GraphLense lense) {
@@ -1090,12 +1116,12 @@
       this.targetedMethods = rewriteItems(previous.targetedMethods, lense::lookupMethod);
       this.liveMethods = rewriteItems(previous.liveMethods, lense::lookupMethod);
       this.liveFields = rewriteItems(previous.liveFields, lense::lookupField);
-      this.instanceFieldsRead = rewriteItems(previous.instanceFieldsRead, lense::lookupField);
-      this.instanceFieldsWritten = rewriteItems(previous.instanceFieldsWritten, lense::lookupField);
-      this.staticFieldsRead = rewriteItems(previous.staticFieldsRead, lense::lookupField);
-      this.staticFieldsWritten = rewriteItems(previous.staticFieldsWritten, lense::lookupField);
-      this.fieldsRead = Sets.union(staticFieldsRead, instanceFieldsRead);
-      this.fieldsWritten = Sets.union(staticFieldsWritten, instanceFieldsWritten);
+      this.instanceFieldReads = rewriteItems(previous.instanceFieldReads, lense::lookupField);
+      this.instanceFieldWrites = rewriteItems(previous.instanceFieldWrites, lense::lookupField);
+      this.staticFieldReads = rewriteItems(previous.staticFieldReads, lense::lookupField);
+      this.staticFieldWrites = rewriteItems(previous.staticFieldWrites, lense::lookupField);
+      this.fieldsRead = rewriteItems(previous.fieldsRead, lense::lookupField);
+      this.fieldsWritten = rewriteItems(previous.fieldsWritten, lense::lookupField);
       // TODO(herhut): Migrate these to Descriptors, as well.
       this.pinnedItems = previous.pinnedItems;
       this.noSideEffects = previous.noSideEffects;
@@ -1104,8 +1130,8 @@
       this.superInvokes = rewriteItems(previous.superInvokes, lense::lookupMethod);
       this.directInvokes = rewriteItems(previous.directInvokes, lense::lookupMethod);
       this.staticInvokes = rewriteItems(previous.staticInvokes, lense::lookupMethod);
-      assert Sets.intersection(instanceFieldsRead, staticFieldsRead).size() == 0;
-      assert Sets.intersection(instanceFieldsWritten, staticFieldsWritten).size() == 0;
+      assert Sets.intersection(instanceFieldReads, staticFieldReads).size() == 0;
+      assert Sets.intersection(instanceFieldWrites, staticFieldWrites).size() == 0;
     }
 
     private Set<DexMethod> joinInvokedMethods(Map<DexType, Set<DexMethod>> invokes) {
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 860fc45..9fcb50a 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -41,13 +41,14 @@
           "optimizationpasses",
           "target");
   private static final List<String> ignoredOptionalSingleArgOptions = ImmutableList
-      .of("keepdirectories");
+      .of("keepdirectories", "runtype", "laststageoutput");
   private static final List<String> ignoredFlagOptions = ImmutableList
       .of("forceprocessing", "dontusemixedcaseclassnames",
           "dontpreverify", "experimentalshrinkunusedprotofields",
           "filterlibraryjarswithorginalprogramjars",
           "dontskipnonpubliclibraryclasses",
           "dontskipnonpubliclibraryclassmembers",
+          "overloadaggressively",
           "invokebasemethod");
   private static final List<String> ignoredClassDescriptorOptions = ImmutableList
       .of("isclassnamestring",
diff --git a/src/main/java/com/android/tools/r8/shaking/SimpleClassMerger.java b/src/main/java/com/android/tools/r8/shaking/SimpleClassMerger.java
index a2864e4..d03c74b 100644
--- a/src/main/java/com/android/tools/r8/shaking/SimpleClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/SimpleClassMerger.java
@@ -27,9 +27,7 @@
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
 import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
@@ -44,6 +42,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiFunction;
+import java.util.stream.Collectors;
 
 /**
  * Merges Supertypes with a single implementation into their single subtype.
@@ -61,7 +60,7 @@
   private final GraphLense.Builder renamedMembersLense = GraphLense.builder();
   private final Map<DexType, DexType> mergedClasses = new IdentityHashMap<>();
   private final Timing timing;
-  private Set<DexMethod> invokes;
+  private Collection<DexMethod> invokes;
   private int numberOfMerges = 0;
 
   public SimpleClassMerger(DexApplication application, AppInfoWithLiveness appInfo,
@@ -81,25 +80,51 @@
         && clazz.type.getSingleSubtype() != null;
   }
 
-  private Set<DexMethod> getInvokes() {
-    if (invokes == null) {
+  private void addProgramMethods(Set<Wrapper<DexMethod>> set, DexMethod method,
+      Equivalence<DexMethod> equivalence) {
+    DexClass definition = appInfo.definitionFor(method.holder);
+    if (definition != null && definition.isProgramClass()) {
+      set.add(equivalence.wrap(method));
+    }
+  }
 
-      // TODO(herhut): Ignore invokes into the library, as those can only reference library types.
-      invokes = Sets.newIdentityHashSet();
-      invokes.addAll(appInfo.directInvokes);
-      invokes.addAll(appInfo.staticInvokes);
-      invokes.addAll(appInfo.superInvokes);
-      invokes.addAll(appInfo.virtualInvokes);
-      invokes.addAll(appInfo.targetedMethods);
-      invokes.addAll(appInfo.liveMethods);
-      for (DexEncodedMethod method : Iterables
-          .filter(appInfo.pinnedItems, DexEncodedMethod.class)) {
-        invokes.add(method.method);
-      }
+  private Collection<DexMethod> getInvokes() {
+    if (invokes == null) {
+      // Collect all reachable methods that are not within a library class. Those defined on
+      // library classes are known not to have program classes in their signature.
+      // Also filter methods that only use types from library classes in their signatures. We
+      // know that those won't conflict.
+      Set<Wrapper<DexMethod>> filteredInvokes = new HashSet<>();
+      Equivalence<DexMethod> equivalence = MethodSignatureEquivalence.get();
+      appInfo.targetedMethods.forEach(m -> addProgramMethods(filteredInvokes, m, equivalence));
+      invokes = filteredInvokes.stream().map(Wrapper::get).filter(this::removeNonProgram)
+          .collect(Collectors.toList());
     }
     return invokes;
   }
 
+  private boolean isProgramClass(DexType type) {
+    if (type.isArrayType()) {
+      type = type.toBaseType(appInfo.dexItemFactory);
+    }
+    if (type.isClassType()) {
+      DexClass clazz = appInfo.definitionFor(type);
+      if (clazz != null && clazz.isProgramClass()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean removeNonProgram(DexMethod dexMethod) {
+    for (DexType type : dexMethod.proto.parameters.values) {
+      if (isProgramClass(type)) {
+        return true;
+      }
+    }
+    return isProgramClass(dexMethod.proto.returnType);
+  }
+
   public GraphLense run() {
     timing.begin("merge");
     GraphLense mergingGraphLense = mergeClasses(graphLense);
@@ -426,7 +451,8 @@
         if (previous != null) {
           if (!previous.accessFlags.isBridge()) {
             if (!method.accessFlags.isBridge()) {
-              throw new CompilationError("Class merging produced invalid result.");
+              throw new CompilationError(
+                  "Class merging produced invalid result on: " + previous.toSourceString());
             } else {
               filtered.put(previous.method, previous);
             }
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index f801cdd..04f6786 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -5,20 +5,16 @@
 
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClassPromise;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexLibraryClass;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.KeyedDexItem;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.android.tools.r8.utils.InternalOptions;
 import java.util.ArrayList;
-import java.util.IdentityHashMap;
-import java.util.Map;
+import java.util.List;
 import java.util.Set;
 
 public class TreePruner {
@@ -52,22 +48,20 @@
   }
 
   private DexApplication.Builder removeUnused(DexApplication application) {
-    return new DexApplication.Builder(application, removeUnusedClassStructure(application));
+    return new DexApplication.Builder(application)
+        .replaceProgramClasses(getNewProgramClasses(application.classes()));
   }
 
-  private Map<DexType, DexClassPromise> removeUnusedClassStructure(DexApplication application) {
-    Map<DexType, DexClassPromise> classMap = new IdentityHashMap<>();
-    for (DexLibraryClass clazz : application.libraryClasses()) {
-      classMap.put(clazz.type, clazz);
-    }
-    for (DexProgramClass clazz : application.classes()) {
+  private List<DexProgramClass> getNewProgramClasses(List<DexProgramClass> classes) {
+    List<DexProgramClass> newClasses = new ArrayList<>();
+    for (DexProgramClass clazz : classes) {
       if (!appInfo.liveTypes.contains(clazz.type) && !options.debugKeepRules) {
         // The class is completely unused and we can remove it.
         if (Log.ENABLED) {
           Log.debug(getClass(), "Removing class: " + clazz);
         }
       } else {
-        classMap.put(clazz.type, clazz);
+        newClasses.add(clazz);
         if (!appInfo.instantiatedTypes.contains(clazz.type) && !options.debugKeepRules) {
           // The class is only needed as a type but never instantiated. Make it abstract to reflect
           // this.
@@ -89,7 +83,7 @@
         clazz.staticFields = reachableFields(clazz.staticFields());
       }
     }
-    return classMap;
+    return newClasses;
   }
 
   private <S extends PresortedComparable<S>, T extends KeyedDexItem<S>> int firstUnreachableIndex(
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index 453a250..389db15 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -7,8 +7,8 @@
 import static com.android.tools.r8.utils.FileUtils.isClassFile;
 import static com.android.tools.r8.utils.FileUtils.isDexFile;
 
+import com.android.tools.r8.ClassFileResourceProvider;
 import com.android.tools.r8.Resource;
-import com.android.tools.r8.ResourceProvider;
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.ClassKind;
@@ -49,14 +49,12 @@
 public class AndroidApp {
 
   public static final String DEFAULT_PROGUARD_MAP_FILE = "proguard.map";
-  public static final String DEFAULT_PROGUARD_SEEDS_FILE = "proguard.seeds";
-  public static final String DEFAULT_PACKAGE_DISTRIBUTION_FILE = "package.map";
 
   private final ImmutableList<Resource> programResources;
   private final ImmutableList<Resource> classpathResources;
   private final ImmutableList<Resource> libraryResources;
-  private final ImmutableList<ResourceProvider> classpathResourceProviders;
-  private final ImmutableList<ResourceProvider> libraryResourceProviders;
+  private final ImmutableList<ClassFileResourceProvider> classpathResourceProviders;
+  private final ImmutableList<ClassFileResourceProvider> libraryResourceProviders;
   private final Resource proguardMap;
   private final Resource proguardSeeds;
   private final Resource packageDistribution;
@@ -67,8 +65,8 @@
       ImmutableList<Resource> programResources,
       ImmutableList<Resource> classpathResources,
       ImmutableList<Resource> libraryResources,
-      ImmutableList<ResourceProvider> classpathResourceProviders,
-      ImmutableList<ResourceProvider> libraryResourceProviders,
+      ImmutableList<ClassFileResourceProvider> classpathResourceProviders,
+      ImmutableList<ClassFileResourceProvider> libraryResourceProviders,
       Resource proguardMap,
       Resource proguardSeeds,
       Resource packageDistribution,
@@ -178,12 +176,12 @@
   }
 
   /** Get classpath resource providers. */
-  public List<ResourceProvider> getClasspathResourceProviders() {
+  public List<ClassFileResourceProvider> getClasspathResourceProviders() {
     return classpathResourceProviders;
   }
 
   /** Get library resource providers. */
-  public List<ResourceProvider> getLibraryResourceProviders() {
+  public List<ClassFileResourceProvider> getLibraryResourceProviders() {
     return libraryResourceProviders;
   }
 
@@ -290,8 +288,6 @@
         Path fileName = directory.resolve(outputMode.getFileName(dexProgramSources.get(i), i));
         Files.copy(dexProgramSources.get(i).getStream(closer), fileName, options);
       }
-      writeProguardMap(closer, directory, overwrite);
-      writeProguardSeeds(closer, directory, overwrite);
     }
   }
 
@@ -334,17 +330,6 @@
           out.closeEntry();
         }
       }
-      // Write the proguard map to the archives containing directory.
-      // TODO(zerny): How do we want to determine the output location for the extra resources?
-      writeProguardMap(closer, archive.getParent(), overwrite);
-      writeProguardSeeds(closer, archive.getParent(), overwrite);
-    }
-  }
-
-  private void writeProguardMap(Closer closer, Path parent, boolean overwrite) throws IOException {
-    InputStream input = getProguardMap(closer);
-    if (input != null) {
-      Files.copy(input, parent.resolve(DEFAULT_PROGUARD_MAP_FILE), copyOptions(overwrite));
     }
   }
 
@@ -354,12 +339,16 @@
     out.write(ByteStreams.toByteArray(input));
   }
 
-  private void writeProguardSeeds(Closer closer, Path parent, boolean overwrite)
-      throws IOException {
+  public void writeProguardSeeds(Closer closer, OutputStream out) throws IOException {
     InputStream input = getProguardSeeds(closer);
-    if (input != null) {
-      Files.copy(input, parent.resolve(DEFAULT_PROGUARD_SEEDS_FILE), copyOptions(overwrite));
-    }
+    assert input != null;
+    out.write(ByteStreams.toByteArray(input));
+  }
+
+  public void writeMainDexList(Closer closer, OutputStream out) throws IOException {
+    InputStream input = getMainDexList(closer);
+    assert input != null;
+    out.write(ByteStreams.toByteArray(input));
   }
 
   private OpenOption[] openOptions(boolean overwrite) {
@@ -383,8 +372,8 @@
     private final List<Resource> programResources = new ArrayList<>();
     private final List<Resource> classpathResources = new ArrayList<>();
     private final List<Resource> libraryResources = new ArrayList<>();
-    private final List<ResourceProvider> classpathResourceProviders = new ArrayList<>();
-    private final List<ResourceProvider> libraryResourceProviders = new ArrayList<>();
+    private final List<ClassFileResourceProvider> classpathResourceProviders = new ArrayList<>();
+    private final List<ClassFileResourceProvider> libraryResourceProviders = new ArrayList<>();
     private Resource proguardMap;
     private Resource proguardSeeds;
     private Resource packageDistribution;
@@ -467,7 +456,7 @@
     /**
      * Add classpath resource provider.
      */
-    public Builder addClasspathResourceProvider(ResourceProvider provider) {
+    public Builder addClasspathResourceProvider(ClassFileResourceProvider provider) {
       classpathResourceProviders.add(provider);
       return this;
     }
@@ -492,7 +481,7 @@
     /**
      * Add library resource provider.
      */
-    public Builder addLibraryResourceProvider(ResourceProvider provider) {
+    public Builder addLibraryResourceProvider(ClassFileResourceProvider provider) {
       libraryResourceProviders.add(provider);
       return this;
     }
@@ -588,6 +577,14 @@
     }
 
     /**
+     * Set the main-dex list data.
+     */
+    public Builder setMainDexListData(byte[] content) {
+      mainDexList = content == null ? null : Resource.fromBytes(null, content);
+      return this;
+    }
+
+    /**
      * Build final AndroidApp.
      */
     public AndroidApp build() {
@@ -644,7 +641,7 @@
                 Resource.Kind.DEX, ByteStreams.toByteArray(stream)));
           } else if (isClassFile(name)) {
             containsClassData = true;
-            String descriptor = PreloadedResourceProvider.guessTypeDescriptor(name);
+            String descriptor = PreloadedClassFileProvider.guessTypeDescriptor(name);
             resources(classKind).add(Resource.fromBytes(Resource.Kind.CLASSFILE,
                 ByteStreams.toByteArray(stream), Collections.singleton(descriptor)));
           }
diff --git a/src/main/java/com/android/tools/r8/utils/ClassMap.java b/src/main/java/com/android/tools/r8/utils/ClassMap.java
new file mode 100644
index 0000000..d0f2cda
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ClassMap.java
@@ -0,0 +1,151 @@
+// Copyright (c) 2017, 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.utils;
+
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Predicate;
+
+/**
+ * Represents a collection of classes. Collection can be fully loaded,
+ * lazy loaded or have preloaded classes along with lazy loaded content.
+ */
+public abstract class ClassMap<T extends DexClass> {
+  // For each type which has ever been queried stores one class loaded from
+  // resources provided by different resource providers.
+  //
+  // NOTE: all access must be synchronized on `classes`.
+  private final Map<DexType, Value<T>> classes;
+
+  // Class provider if available. In case it's `null`, all classes of
+  // the collection must be pre-populated in `classes`.
+  private final ClassProvider<T> classProvider;
+
+  ClassMap(Map<DexType, Value<T>> classes, ClassProvider<T> classProvider) {
+    this.classes = classes == null ? new IdentityHashMap<>() : classes;
+    this.classProvider = classProvider;
+    assert this.classProvider == null || this.classProvider.getClassKind() == getClassKind();
+  }
+
+  /** Resolves a class conflict by selecting a class, may generate compilation error. */
+  abstract T resolveClassConflict(T a, T b);
+
+  /** Kind of the classes supported by this collection. */
+  abstract ClassKind getClassKind();
+
+  @Override
+  public String toString() {
+    synchronized (classes) {
+      return classes.size() + " loaded, provider: " +
+          (classProvider == null ? "none" : classProvider.toString());
+    }
+  }
+
+  /** Returns a definition for a class or `null` if there is no such class in the collection. */
+  public T get(DexType type) {
+    final Value<T> value = getOrCreateValue(type);
+
+    if (!value.ready) {
+      // Load the value in a context synchronized on value instance. This way
+      // we avoid locking the whole collection during expensive resource loading
+      // and classes construction operations.
+      synchronized (value) {
+        if (!value.ready && classProvider != null) {
+          classProvider.collectClass(type, clazz -> {
+            assert clazz != null;
+            assert getClassKind().isOfKind(clazz);
+            assert !value.ready;
+
+            if (clazz.type != type) {
+              throw new CompilationError("Class content provided for type descriptor "
+                  + type.toSourceString() + " actually defines class " + clazz.type
+                  .toSourceString());
+            }
+
+            if (value.clazz == null) {
+              value.clazz = clazz;
+            } else {
+              // The class resolution *may* generate a compilation error as one of
+              // possible resolutions. In this case we leave `value` in (false, null)
+              // state so in rare case of another thread trying to get the same class
+              // before this error is propagated it will get the same conflict.
+              T oldClass = value.clazz;
+              value.clazz = null;
+              value.clazz = resolveClassConflict(oldClass, clazz);
+            }
+          });
+        }
+        value.ready = true;
+      }
+    }
+
+    assert value.ready;
+    return value.clazz;
+  }
+
+  private Value<T> getOrCreateValue(DexType type) {
+    synchronized (classes) {
+      return classes.computeIfAbsent(type, k -> new Value<>());
+    }
+  }
+
+  /** Returns currently loaded classes */
+  public List<T> collectLoadedClasses() {
+    List<T> loadedClasses = new ArrayList<>();
+    synchronized (classes) {
+      for (Value<T> value : classes.values()) {
+        // Method collectLoadedClasses() must always be called when there
+        // is no risk of concurrent loading of the classes, otherwise the
+        // behaviour of this method is undefined. Note that value mutations
+        // are NOT synchronized in `classes`, so the assertion below does
+        // not enforce this requirement, but may help detect wrong behaviour.
+        assert value.ready : "";
+        if (value.clazz != null) {
+          loadedClasses.add(value.clazz);
+        }
+      }
+    }
+    return loadedClasses;
+  }
+
+  /** Forces loading of all the classes satisfying the criteria specified. */
+  public void forceLoad(Predicate<DexType> load) {
+    if (classProvider != null) {
+      Set<DexType> loaded;
+      synchronized (classes) {
+        loaded = classes.keySet();
+      }
+      Collection<DexType> types = classProvider.collectTypes();
+      for (DexType type : types) {
+        if (load.test(type) && !loaded.contains(type)) {
+          get(type); // force-load type.
+        }
+      }
+    }
+  }
+
+  // Represents a value in the class map.
+  final static class Value<T> {
+    volatile boolean ready;
+    T clazz;
+
+    Value() {
+      ready = false;
+      clazz = null;
+    }
+
+    Value(T clazz) {
+      this.clazz = clazz;
+      this.ready = true;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/ClassProvider.java b/src/main/java/com/android/tools/r8/utils/ClassProvider.java
new file mode 100644
index 0000000..25abdce
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ClassProvider.java
@@ -0,0 +1,187 @@
+// Copyright (c) 2017, 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.utils;
+
+import static com.android.tools.r8.utils.FileUtils.DEFAULT_DEX_FILENAME;
+
+import com.android.tools.r8.ClassFileResourceProvider;
+import com.android.tools.r8.Resource;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.JarApplicationReader;
+import com.android.tools.r8.graph.JarClassFileReader;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import com.google.common.io.Closer;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+
+/** Represents a provider for classes loaded from different sources. */
+public abstract class ClassProvider<T extends DexClass> {
+  private final ClassKind classKind;
+
+  ClassProvider(ClassKind classKind) {
+    this.classKind = classKind;
+  }
+
+  /** The kind of the classes created by the provider. */
+  final ClassKind getClassKind() {
+    return classKind;
+  }
+
+  /**
+   * The provider uses the callback to return all the classes that might
+   * be associated with the descriptor asked for.
+   *
+   * NOTE: the provider is not required to cache created classes and this
+   * method may create a new class instance in case it is called twice for
+   * the same type. For this reason it is recommended that the provider
+   * user only calls this method once per any given type.
+   *
+   * NOTE: thread-safe.
+   */
+  public abstract void collectClass(DexType type, Consumer<T> classConsumer);
+
+  /**
+   * Returns all the types of classes that might be produced by this provider.
+   *
+   * NOTE: thread-safe.
+   */
+  public abstract Collection<DexType> collectTypes();
+
+  /** Create class provider for java class resource provider. */
+  public static <T extends DexClass> ClassProvider<T> forClassFileResources(
+      ClassKind classKind, ClassFileResourceProvider provider, JarApplicationReader reader) {
+    return new ClassFileResourceReader<>(classKind, provider, reader);
+  }
+
+  /** Create class provider for preloaded classes, classes may have conflicting names. */
+  public static <T extends DexClass> ClassProvider<T> forPreloadedClasses(
+      ClassKind classKind, Collection<T> classes) {
+    ImmutableListMultimap.Builder<DexType, T> builder = ImmutableListMultimap.builder();
+    for (T clazz : classes) {
+      builder.put(clazz.type, clazz);
+    }
+    return new PreloadedClassProvider<>(classKind, builder.build());
+  }
+
+  /** Create class provider for preloaded classes. */
+  public static <T extends DexClass> ClassProvider<T> combine(
+      ClassKind classKind, List<ClassProvider<T>> providers) {
+    return new CombinedClassProvider<>(classKind, providers);
+  }
+
+  private static class ClassFileResourceReader<T extends DexClass> extends ClassProvider<T> {
+    private final ClassKind classKind;
+    private final ClassFileResourceProvider provider;
+    private final JarApplicationReader reader;
+
+    private ClassFileResourceReader(
+        ClassKind classKind, ClassFileResourceProvider provider, JarApplicationReader reader) {
+      super(classKind);
+      this.classKind = classKind;
+      this.provider = provider;
+      this.reader = reader;
+    }
+
+    @Override
+    public void collectClass(DexType type, Consumer<T> classConsumer) {
+      String descriptor = type.descriptor.toString();
+      Resource resource = provider.getResource(descriptor);
+      if (resource != null) {
+        try (Closer closer = Closer.create()) {
+          JarClassFileReader classReader =
+              new JarClassFileReader(reader, classKind.bridgeConsumer(classConsumer));
+          classReader.read(DEFAULT_DEX_FILENAME, classKind, resource.getStream(closer));
+        } catch (IOException e) {
+          throw new CompilationError("Failed to load class: " + descriptor, e);
+        }
+      }
+    }
+
+    @Override
+    public Collection<DexType> collectTypes() {
+      List<DexType> types = new ArrayList<>();
+      for (String descriptor : provider.getClassDescriptors()) {
+        types.add(reader.options.itemFactory.createType(descriptor));
+      }
+      return types;
+    }
+
+    @Override
+    public String toString() {
+      return "class-resource-provider(" + provider.toString() + ")";
+    }
+  }
+
+  private static class PreloadedClassProvider<T extends DexClass> extends ClassProvider<T> {
+    private final Multimap<DexType, T> classes;
+
+    private PreloadedClassProvider(ClassKind classKind, Multimap<DexType, T> classes) {
+      super(classKind);
+      this.classes = classes;
+    }
+
+    @Override
+    public void collectClass(DexType type, Consumer<T> classConsumer) {
+      for (T clazz : classes.get(type)) {
+        classConsumer.accept(clazz);
+      }
+    }
+
+    @Override
+    public Collection<DexType> collectTypes() {
+      return classes.keys();
+    }
+
+    @Override
+    public String toString() {
+      return "preloaded(" + classes.size() + ")";
+    }
+  }
+
+  private static class CombinedClassProvider<T extends DexClass> extends ClassProvider<T> {
+    private final List<ClassProvider<T>> providers;
+
+    private CombinedClassProvider(ClassKind classKind, List<ClassProvider<T>> providers) {
+      super(classKind);
+      this.providers = providers;
+    }
+
+    @Override
+    public void collectClass(DexType type, Consumer<T> classConsumer) {
+      for (ClassProvider<T> provider : providers) {
+        provider.collectClass(type, classConsumer);
+      }
+    }
+
+    @Override
+    public Collection<DexType> collectTypes() {
+      Set<DexType> types = Sets.newIdentityHashSet();
+      for (ClassProvider<T> provider : providers) {
+        types.addAll(provider.collectTypes());
+      }
+      return types;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder builder = new StringBuilder();
+      String prefix = "combined(";
+      for (ClassProvider<T> provider : providers) {
+        builder.append(prefix);
+        prefix = ", ";
+        builder.append(provider);
+      }
+      return builder.append(")").toString();
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java b/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java
new file mode 100644
index 0000000..ee00c39
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ClasspathClassCollection.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2017, 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.utils;
+
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexClasspathClass;
+
+/** Represents a collection of classpath classes. */
+public class ClasspathClassCollection extends ClassMap<DexClasspathClass> {
+  public ClasspathClassCollection(ClassProvider<DexClasspathClass> classProvider) {
+    super(null, classProvider);
+  }
+
+  @Override
+  DexClasspathClass resolveClassConflict(DexClasspathClass a, DexClasspathClass b) {
+    throw new CompilationError("Classpath type already present: " + a.type.toSourceString());
+  }
+
+  @Override
+  ClassKind getClassKind() {
+    return ClassKind.CLASSPATH;
+  }
+
+  @Override
+  public String toString() {
+    return "classpath classes: " + super.toString();
+  }
+}
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 ec430fd..eae33d1 100644
--- a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
@@ -88,11 +88,7 @@
         String clazz = descriptor.substring(1, descriptor.length() - 1)
             .replace(DESCRIPTOR_PACKAGE_SEPARATOR, JAVA_PACKAGE_SEPARATOR);
         String originalName =
-            classNameMapper == null ? null : classNameMapper.deobfuscateClassName(clazz);
-        if (originalName == null) {
-          // Class was not renamed, reconstruct the java name.
-          return clazz;
-        }
+            classNameMapper == null ? clazz : classNameMapper.deobfuscateClassName(clazz);
         return originalName;
       case '[':
         return descriptorToJavaType(descriptor.substring(1, descriptor.length()), classNameMapper)
diff --git a/src/main/java/com/android/tools/r8/utils/DirectoryClassFileProvider.java b/src/main/java/com/android/tools/r8/utils/DirectoryClassFileProvider.java
new file mode 100644
index 0000000..c060ead
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/DirectoryClassFileProvider.java
@@ -0,0 +1,76 @@
+// Copyright (c) 2017, 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.utils;
+
+import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
+
+import com.android.tools.r8.ClassFileResourceProvider;
+import com.android.tools.r8.Resource;
+import com.google.common.collect.Sets;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Lazy resource provider returning class file resources based
+ * on filesystem directory content.
+ */
+public final class DirectoryClassFileProvider implements ClassFileResourceProvider {
+  private final Path root;
+
+  private DirectoryClassFileProvider(Path root) {
+    this.root = root;
+  }
+
+  @Override
+  public Set<String> getClassDescriptors() {
+    HashSet<String> result = Sets.newHashSet();
+    collectClassDescriptors(root, result);
+    return result;
+  }
+
+  private void collectClassDescriptors(Path dir, Set<String> result) {
+    File file = dir.toFile();
+    if (file.exists()) {
+      File[] files = file.listFiles();
+      if (files != null) {
+        for (File child : files) {
+          if (child.isDirectory()) {
+            collectClassDescriptors(child.toPath(), result);
+          } else {
+            String relative = root.relativize(child.toPath()).toString();
+            if (relative.endsWith(CLASS_EXTENSION)) {
+              result.add("L" + relative.substring(
+                  0, relative.length() - CLASS_EXTENSION.length()) + ";");
+            }
+          }
+        }
+      }
+    }
+  }
+
+  @Override
+  public Resource getResource(String descriptor) {
+    assert DescriptorUtils.isClassDescriptor(descriptor);
+
+    // Build expected file path based on type descriptor.
+    String classBinaryName = DescriptorUtils.getClassBinaryNameFromDescriptor(descriptor);
+    Path filePath = root.resolve(classBinaryName + CLASS_EXTENSION);
+    File file = filePath.toFile();
+
+    return (file.exists() && !file.isDirectory())
+        ? Resource.fromFile(Resource.Kind.CLASSFILE, filePath) : null;
+  }
+
+  /** Create resource provider from directory path. */
+  public static ClassFileResourceProvider fromDirectory(Path dir) {
+    return new DirectoryClassFileProvider(dir.toAbsolutePath());
+  }
+
+  @Override
+  public String toString() {
+    return "directory(" + root + ")";
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/DirectoryResourceProvider.java b/src/main/java/com/android/tools/r8/utils/DirectoryResourceProvider.java
deleted file mode 100644
index b003d86..0000000
--- a/src/main/java/com/android/tools/r8/utils/DirectoryResourceProvider.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2017, 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.utils;
-
-import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
-
-import com.android.tools.r8.Resource;
-import com.android.tools.r8.ResourceProvider;
-import java.io.File;
-import java.nio.file.Path;
-
-/**
- * Lazy resource provider based on filesystem directory content.
- *
- * NOTE: only handles classfile resources.
- */
-public final class DirectoryResourceProvider implements ResourceProvider {
-  private final Path root;
-
-  private DirectoryResourceProvider(Path root) {
-    this.root = root;
-  }
-
-  @Override
-  public Resource getResource(String descriptor) {
-    assert DescriptorUtils.isClassDescriptor(descriptor);
-
-    // Build expected file path based on type descriptor.
-    String classBinaryName = DescriptorUtils.getClassBinaryNameFromDescriptor(descriptor);
-    Path filePath = root.resolve(classBinaryName + CLASS_EXTENSION);
-    File file = filePath.toFile();
-
-    return (file.exists() && !file.isDirectory())
-        ? Resource.fromFile(Resource.Kind.CLASSFILE, filePath) : null;
-  }
-
-  /** Create resource provider from directory path. */
-  public static ResourceProvider fromDirectory(Path dir) {
-    return new DirectoryResourceProvider(dir.toAbsolutePath());
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 5945741..7b1cfe1 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -7,12 +7,14 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.ir.conversion.CallGraph;
 import com.android.tools.r8.shaking.ProguardConfigurationRule;
 import com.android.tools.r8.shaking.ProguardTypeMatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.function.BiFunction;
 
 public class InternalOptions {
 
@@ -35,9 +37,6 @@
   public boolean skipDebugLineNumberOpt = false;
   public boolean skipClassMerging = true;
 
-  public boolean lazyClasspathLoading = false;
-  public boolean lazyLibraryLoading = false;
-
   // Number of threads to use while processing the dex files.
   public int numberOfThreads = NOT_SPECIFIED;
   // Print smali disassembly.
@@ -46,8 +45,6 @@
   public boolean verbose = false;
   // Silencing output.
   public boolean quiet = false;
-  // Eagerly fill dex files as much as possible.
-  public boolean fillDexFiles = false;
 
   public List<String> methodsFilter = ImmutableList.of();
   public int minApiLevel = Constants.DEFAULT_ANDROID_API;
@@ -69,6 +66,8 @@
   public Path seedsFile;
   public boolean printMapping;
   public Path printMappingFile;
+  public boolean printMainDexList;
+  public Path printMainDexListFile;
   public boolean ignoreMissingClasses = false;
   public boolean skipMinification = false;
   public String packagePrefix = "";
@@ -87,11 +86,14 @@
   public List<String> obfuscationDictionary = ImmutableList.of();
 
   public ImmutableList<ProguardConfigurationRule> mainDexKeepRules = ImmutableList.of();
+  public boolean minimalMainDex;
   public ImmutableList<ProguardConfigurationRule> keepRules = ImmutableList.of();
   public ImmutableSet<ProguardTypeMatcher> dontWarnPatterns = ImmutableSet.of();
 
   public String warningInvalidParameterAnnotations = null;
 
+  public boolean overwriteOutputs; // default value is set in D/R8Command
+
   public boolean printWarnings() {
     boolean printed = false;
     if (warningInvalidParameterAnnotations != null) {
@@ -101,9 +103,13 @@
     return printed;
   }
 
+  public boolean hasMethodsFilter() {
+    return methodsFilter.size() > 0;
+  }
+
   public boolean methodMatchesFilter(DexEncodedMethod method) {
     // Not specifying a filter matches all methods.
-    if (methodsFilter.size() == 0) {
+    if (!hasMethodsFilter()) {
       return true;
     }
     // Currently the filter is simple string equality on the qualified name.
@@ -133,7 +139,7 @@
 
   public static class TestingOptions {
 
-    public boolean randomizeCallGraphLeaves = false;
+    public BiFunction<List<DexEncodedMethod>, CallGraph.Leaves, List<DexEncodedMethod>> irOrdering;
   }
 
   public static class AttributeRemovalOptions {
diff --git a/src/main/java/com/android/tools/r8/utils/LazyClassCollection.java b/src/main/java/com/android/tools/r8/utils/LazyClassCollection.java
deleted file mode 100644
index 0e71973..0000000
--- a/src/main/java/com/android/tools/r8/utils/LazyClassCollection.java
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright (c) 2017, 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.utils;
-
-import com.android.tools.r8.Resource;
-import com.android.tools.r8.ResourceProvider;
-import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.ClassKind;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClassPromise;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.JarApplicationReader;
-import com.android.tools.r8.graph.LazyClassFileLoader;
-import com.google.common.collect.ImmutableList;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Represents a collection of classes loaded lazily from a set of lazy resource
- * providers. The collection is autonomous, it lazily collects promises but
- * does not choose the classes in cases of conflicts, delaying it until
- * the class is asked for.
- *
- * NOTE: only java class resources are allowed to be lazy loaded.
- */
-public final class LazyClassCollection {
-  // Stores promises for types which have ever been asked for before. Special value
-  // EmptyPromise.INSTANCE indicates there were no resources for this type in any of
-  // the resource providers.
-  //
-  // Promises are potentially coming from different providers and chained, but in majority
-  // of the cases there will only be one promise per type. We store promises for all
-  // the resource providers and resolve the classes at the time it is queried.
-  //
-  // Must be synchronized on `classes`.
-  private final Map<DexType, DexClassPromise> classes = new IdentityHashMap<>();
-
-  // Available lazy resource providers.
-  private final List<ResourceProvider> classpathProviders;
-  private final List<ResourceProvider> libraryProviders;
-
-  // Application reader to be used. Note that the reader may be reused in
-  // many loaders and may be used concurrently, it is considered to be
-  // thread-safe since its only state is internal options which we
-  // consider immutable after they are initialized (barring dex factory
-  // which is thread-safe).
-  private final JarApplicationReader reader;
-
-  public LazyClassCollection(JarApplicationReader reader,
-      List<ResourceProvider> classpathProviders, List<ResourceProvider> libraryProviders) {
-    this.classpathProviders = ImmutableList.copyOf(classpathProviders);
-    this.libraryProviders = ImmutableList.copyOf(libraryProviders);
-    this.reader = reader;
-  }
-
-  /**
-   * Returns a definition for a class or `null` if there is no such class.
-   * Parameter `dominator` represents the class promise that is considered
-   * to be already loaded, it may be null but if specified it may affect
-   * the conflict resolution. For example non-lazy loaded classpath class
-   * provided as `dominator` will conflict with lazy-loaded classpath classes.
-   */
-  public DexClassPromise get(DexType type, DexClassPromise dominator) {
-    DexClassPromise promise;
-
-    // Check if the promise already exists.
-    synchronized (classes) {
-      promise = classes.get(type);
-    }
-
-    if (promise == null) {
-      // Building a promise may be time consuming, we do it outside
-      // the lock so others don't have to wait.
-      promise = buildPromiseChain(type);
-
-      synchronized (classes) {
-        DexClassPromise existing = classes.get(type);
-        if (existing != null) {
-          promise = existing;
-        } else {
-          classes.put(type, promise);
-        }
-      }
-
-      assert promise != EmptyPromise.INSTANCE;
-    }
-
-    return promise == EmptyPromise.INSTANCE ? dominator : chooseClass(dominator, promise);
-  }
-
-  // Build chain of lazy promises or `null` if none of the providers
-  // provided resource for this type.
-  private DexClassPromise buildPromiseChain(DexType type) {
-    String descriptor = type.descriptor.toString();
-    DexClassPromise promise = buildPromiseChain(
-        type, descriptor, null, classpathProviders, ClassKind.CLASSPATH);
-    promise = buildPromiseChain(
-        type, descriptor, promise, libraryProviders, ClassKind.LIBRARY);
-    return promise == null ? EmptyPromise.INSTANCE : promise;
-  }
-
-  private DexClassPromise buildPromiseChain(DexType type, String descriptor,
-      DexClassPromise promise, List<ResourceProvider> providers, ClassKind classKind) {
-    for (ResourceProvider provider : providers) {
-      Resource resource = provider.getResource(descriptor);
-      if (resource == null) {
-        continue;
-      }
-
-      if (resource.kind != Resource.Kind.CLASSFILE) {
-        throw new CompilationError("Resource returned by resource provider for type " +
-            type.toSourceString() + " must be a class file resource.");
-      }
-
-      LazyClassFileLoader loader = new LazyClassFileLoader(type, resource, classKind, reader);
-      promise = (promise == null) ? loader : new DexClassPromiseChain(loader, promise);
-    }
-    return promise;
-  }
-
-  // Chooses the proper promise. Recursion is not expected to be deep.
-  private DexClassPromise chooseClass(DexClassPromise dominator, DexClassPromise candidate) {
-    DexClassPromise best = (dominator == null) ? candidate
-        : DexApplication.chooseClass(dominator, candidate, /* skipLibDups: */ true);
-    return (candidate instanceof DexClassPromiseChain)
-        ? chooseClass(best, ((DexClassPromiseChain) candidate).next) : best;
-  }
-
-  private static final class EmptyPromise implements DexClassPromise {
-    static final EmptyPromise INSTANCE = new EmptyPromise();
-
-    @Override
-    public DexType getType() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public Resource.Kind getOrigin() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public boolean isProgramClass() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public boolean isClasspathClass() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public boolean isLibraryClass() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public DexClass get() {
-      throw new Unreachable();
-    }
-  }
-
-  private static final class DexClassPromiseChain implements DexClassPromise {
-    final DexClassPromise promise;
-    final DexClassPromise next;
-
-    private DexClassPromiseChain(DexClassPromise promise, DexClassPromise next) {
-      assert promise != null;
-      assert next != null;
-      this.promise = promise;
-      this.next = next;
-    }
-
-    @Override
-    public DexType getType() {
-      return promise.getType();
-    }
-
-    @Override
-    public Resource.Kind getOrigin() {
-      return promise.getOrigin();
-    }
-
-    @Override
-    public boolean isProgramClass() {
-      return promise.isProgramClass();
-    }
-
-    @Override
-    public boolean isClasspathClass() {
-      return promise.isClasspathClass();
-    }
-
-    @Override
-    public boolean isLibraryClass() {
-      return promise.isLibraryClass();
-    }
-
-    @Override
-    public DexClass get() {
-      return promise.get();
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/utils/LibraryClassCollection.java b/src/main/java/com/android/tools/r8/utils/LibraryClassCollection.java
new file mode 100644
index 0000000..e11e660
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/LibraryClassCollection.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2017, 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.utils;
+
+import com.android.tools.r8.Resource;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexLibraryClass;
+import com.android.tools.r8.logging.Log;
+
+/** Represents a collection of library classes. */
+public class LibraryClassCollection extends ClassMap<DexLibraryClass> {
+  public LibraryClassCollection(ClassProvider<DexLibraryClass> classProvider) {
+    super(null, classProvider);
+  }
+
+  @Override
+  DexLibraryClass resolveClassConflict(DexLibraryClass a, DexLibraryClass b) {
+    if (a.origin != Resource.Kind.CLASSFILE || b.origin != Resource.Kind.CLASSFILE) {
+      // We only support conflicts for classes both coming from jar files.
+      throw new CompilationError(
+          "Library type already present: " + a.type.toSourceString());
+    }
+    if (Log.ENABLED) {
+      Log.warn(DexApplication.class,
+          "Class `%s` was specified twice as a library type.", a.type.toSourceString());
+    }
+    return a;
+  }
+
+  @Override
+  ClassKind getClassKind() {
+    return ClassKind.LIBRARY;
+  }
+
+  @Override
+  public String toString() {
+    return "library classes: " + super.toString();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/PreloadedResourceProvider.java b/src/main/java/com/android/tools/r8/utils/PreloadedClassFileProvider.java
similarity index 74%
rename from src/main/java/com/android/tools/r8/utils/PreloadedResourceProvider.java
rename to src/main/java/com/android/tools/r8/utils/PreloadedClassFileProvider.java
index fcb89d4..07c136d 100644
--- a/src/main/java/com/android/tools/r8/utils/PreloadedResourceProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/PreloadedClassFileProvider.java
@@ -7,10 +7,13 @@
 import static com.android.tools.r8.utils.FileUtils.isArchive;
 import static com.android.tools.r8.utils.FileUtils.isClassFile;
 
+import com.android.tools.r8.ClassFileResourceProvider;
 import com.android.tools.r8.Resource;
-import com.android.tools.r8.ResourceProvider;
 import com.android.tools.r8.errors.CompilationError;
+import com.google.common.collect.Sets;
 import com.google.common.io.ByteStreams;
+
+import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.file.Path;
@@ -18,23 +21,25 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
 import java.util.zip.ZipInputStream;
 
-/**
- * Lazy resource provider based on preloaded/prebuilt context.
- *
- * NOTE: only handles classfile resources.
- */
-public final class PreloadedResourceProvider implements ResourceProvider {
+/** Lazy Java class file resource provider based on preloaded/prebuilt context. */
+public final class PreloadedClassFileProvider implements ClassFileResourceProvider {
   private final Map<String, byte[]> content;
 
-  private PreloadedResourceProvider(Map<String, byte[]> content) {
+  private PreloadedClassFileProvider(Map<String, byte[]> content) {
     this.content = content;
   }
 
   @Override
+  public Set<String> getClassDescriptors() {
+    return Sets.newHashSet(content.keySet());
+  }
+
+  @Override
   public Resource getResource(String descriptor) {
     byte[] bytes = content.get(descriptor);
     if (bytes == null) {
@@ -44,7 +49,7 @@
   }
 
   /** Create preloaded content resource provider from archive file. */
-  public static ResourceProvider fromArchive(Path archive) throws IOException {
+  public static ClassFileResourceProvider fromArchive(Path archive) throws IOException {
     assert isArchive(archive);
     Builder builder = builder();
     try (ZipInputStream stream = new ZipInputStream(new FileInputStream(archive.toFile()))) {
@@ -73,13 +78,21 @@
     assert name != null;
     assert name.endsWith(CLASS_EXTENSION) :
         "Name " + name + " must have " + CLASS_EXTENSION + " suffix";
-    String descriptor = name.substring(0, name.length() - CLASS_EXTENSION.length());
+    String fileName =
+            File.separatorChar == '/' ? name.toString() :
+                    name.toString().replace(File.separatorChar, '/');
+    String descriptor = fileName.substring(0, fileName.length() - CLASS_EXTENSION.length());
     if (descriptor.contains(".")) {
-      throw new CompilationError("Unexpected file name in the archive: " + name);
+      throw new CompilationError("Unexpected file name in the archive: " + fileName);
     }
     return 'L' + descriptor + ';';
   }
 
+  @Override
+  public String toString() {
+    return content.size() + " preloaded resources";
+  }
+
   /** Create a new empty builder. */
   public static Builder builder() {
     return new Builder();
@@ -100,9 +113,9 @@
       return this;
     }
 
-    public PreloadedResourceProvider build() {
+    public PreloadedClassFileProvider build() {
       assert content != null;
-      PreloadedResourceProvider provider = new PreloadedResourceProvider(content);
+      PreloadedClassFileProvider provider = new PreloadedClassFileProvider(content);
       content = null;
       return provider;
     }
diff --git a/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java b/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java
new file mode 100644
index 0000000..a37eb92
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ProgramClassCollection.java
@@ -0,0 +1,63 @@
+// Copyright (c) 2017, 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.utils;
+
+import com.android.tools.r8.Resource;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.ClassKind;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.desugar.LambdaRewriter;
+import java.util.IdentityHashMap;
+import java.util.List;
+
+/** Represents a collection of library classes. */
+public class ProgramClassCollection extends ClassMap<DexProgramClass> {
+  public static ProgramClassCollection create(List<DexProgramClass> classes) {
+    // We have all classes preloaded, but not necessarily without conflicts.
+    IdentityHashMap<DexType, Value<DexProgramClass>> map = new IdentityHashMap<>();
+    for (DexProgramClass clazz : classes) {
+      Value<DexProgramClass> value = map.get(clazz.type);
+      if (value == null) {
+        value = new Value<>(clazz);
+        map.put(clazz.type, value);
+      } else {
+        value.clazz = resolveClassConflictImpl(value.clazz, clazz);
+      }
+    }
+    return new ProgramClassCollection(map);
+  }
+
+  private ProgramClassCollection(IdentityHashMap<DexType, Value<DexProgramClass>> classes) {
+    super(classes, null);
+  }
+
+  @Override
+  public String toString() {
+    return "program classes: " + super.toString();
+  }
+
+  @Override
+  DexProgramClass resolveClassConflict(DexProgramClass a, DexProgramClass b) {
+    return resolveClassConflictImpl(a, b);
+  }
+
+  @Override
+  ClassKind getClassKind() {
+    return ClassKind.PROGRAM;
+  }
+
+  private static DexProgramClass resolveClassConflictImpl(DexProgramClass a, DexProgramClass b) {
+    // Currently only allow collapsing synthetic lambda classes.
+    if (a.getOrigin() == Resource.Kind.DEX
+        && b.getOrigin() == Resource.Kind.DEX
+        && a.accessFlags.isSynthetic()
+        && b.accessFlags.isSynthetic()
+        && LambdaRewriter.hasLambdaClassPrefix(a.type)
+        && LambdaRewriter.hasLambdaClassPrefix(b.type)) {
+      return a;
+    }
+    throw new CompilationError("Program type already present: " + a.type.toSourceString());
+  }
+}
diff --git a/src/test/debugTestResourcesJava8/DebugDefaultMethod.java b/src/test/debugTestResourcesJava8/DebugInterfaceMethod.java
similarity index 77%
rename from src/test/debugTestResourcesJava8/DebugDefaultMethod.java
rename to src/test/debugTestResourcesJava8/DebugInterfaceMethod.java
index db216b3..b407698 100644
--- a/src/test/debugTestResourcesJava8/DebugDefaultMethod.java
+++ b/src/test/debugTestResourcesJava8/DebugInterfaceMethod.java
@@ -2,13 +2,17 @@
 // 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.
 
-public class DebugDefaultMethod {
+public class DebugInterfaceMethod {
 
   interface I {
     default void doSomething(String msg) {
       String name = getClass().getName();
       System.out.println(name + ": " + msg);
     }
+
+    static void printString(String msg) {
+      System.out.println(msg);
+    }
   }
 
   static class DefaultImpl implements I {
@@ -27,9 +31,14 @@
     i.doSomething("Test");
   }
 
+  private static void testStaticMethod() {
+    I.printString("I'm a static method in interface");
+  }
+
   public static void main(String[] args) {
     testDefaultMethod(new DefaultImpl());
     testDefaultMethod(new OverrideImpl());
+    testStaticMethod();
   }
 
 }
diff --git a/src/test/debugTestResourcesJava8/DebugLambda.java b/src/test/debugTestResourcesJava8/DebugLambda.java
index c3b8695..007cd0c 100644
--- a/src/test/debugTestResourcesJava8/DebugLambda.java
+++ b/src/test/debugTestResourcesJava8/DebugLambda.java
@@ -16,8 +16,52 @@
     printInt(() -> i + j);
   }
 
-  public static void main(String[] args) {
-    DebugLambda.testLambda(5, 10);
+  private static void printInt2(I i) {
+    System.out.println(i.getInt());
   }
 
+  public static void testLambdaWithMethodReference() {
+    printInt2(DebugLambda::returnOne);
+  }
+
+  private static int returnOne() {
+    return 1;
+  }
+
+  private static void printInt3(BinaryOpInterface i, int a, int b) {
+    System.out.println(i.binaryOp(a, b));
+  }
+
+  public static void testLambdaWithArguments(int i, int j) {
+    printInt3((a, b) -> {
+      return a + b;
+    }, i, j);
+  }
+
+  interface ObjectProvider {
+    Object foo(String a, String b, String c);
+  }
+
+  private static void testLambdaWithMethodReferenceAndConversion(ObjectProvider objectProvider) {
+    System.out.println(objectProvider.foo("A", "B", "C"));
+  }
+
+  public static void main(String[] args) {
+    DebugLambda.testLambda(5, 10);
+    DebugLambda.testLambdaWithArguments(5, 10);
+    DebugLambda.testLambdaWithMethodReference();
+    DebugLambda.testLambdaWithMethodReferenceAndConversion(DebugLambda::concatObjects);
+  }
+
+  private static Object concatObjects(Object... objects) {
+    StringBuilder sb = new StringBuilder();
+    for (Object o : objects) {
+      sb.append(o.toString());
+    }
+    return sb.toString();
+  }
+
+  interface BinaryOpInterface {
+    int binaryOp(int a, int b);
+  }
 }
diff --git a/src/test/examples/memberrebinding/Test.java b/src/test/examples/memberrebinding/Memberrebinding.java
similarity index 97%
rename from src/test/examples/memberrebinding/Test.java
rename to src/test/examples/memberrebinding/Memberrebinding.java
index 62a2440..74c99fd 100644
--- a/src/test/examples/memberrebinding/Test.java
+++ b/src/test/examples/memberrebinding/Memberrebinding.java
@@ -6,7 +6,7 @@
 import memberrebinding.subpackage.PublicClass;
 import memberrebindinglib.AnIndependentInterface;
 
-public class Test {
+public class Memberrebinding {
 
   public static void main(String[] args) {
     ClassAtBottomOfChain bottomInstance = new ClassAtBottomOfChain();
diff --git a/src/test/examples/memberrebinding2/Test.java b/src/test/examples/memberrebinding2/Memberrebinding.java
similarity index 96%
rename from src/test/examples/memberrebinding2/Test.java
rename to src/test/examples/memberrebinding2/Memberrebinding.java
index d4b005e..13cde8c 100644
--- a/src/test/examples/memberrebinding2/Test.java
+++ b/src/test/examples/memberrebinding2/Memberrebinding.java
@@ -5,7 +5,7 @@
 
 import memberrebinding2.subpackage.PublicClass;
 
-public class Test {
+public class Memberrebinding {
 
   public static void main(String[] args) {
     ClassAtBottomOfChain bottomInstance = new ClassAtBottomOfChain();
diff --git a/src/test/examples/memberrebinding2/keep-rules.txt b/src/test/examples/memberrebinding2/keep-rules.txt
new file mode 100644
index 0000000..ae40c43
--- /dev/null
+++ b/src/test/examples/memberrebinding2/keep-rules.txt
@@ -0,0 +1,12 @@
+# Copyright (c) 2016, 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.
+
+# Keep the application entry point. Get rid of everything that is not
+# reachable from there.
+-keep public class memberrebinding2.Memberrebinding {
+  public static void main(...);
+}
+
+# Remove once b/62048823 is fixed.
+-allowaccessmodification
\ No newline at end of file
diff --git a/src/test/examples/memberrebinding3/Test.java b/src/test/examples/memberrebinding3/Memberrebinding.java
similarity index 78%
rename from src/test/examples/memberrebinding3/Test.java
rename to src/test/examples/memberrebinding3/Memberrebinding.java
index d37f263..83d8bbb 100644
--- a/src/test/examples/memberrebinding3/Test.java
+++ b/src/test/examples/memberrebinding3/Memberrebinding.java
@@ -3,16 +3,19 @@
 // BSD-style license that can be found in the LICENSE file.
 package memberrebinding3;
 
-public class Test extends ClassAtBottomOfChain {
+public class Memberrebinding extends ClassAtBottomOfChain {
 
+  @Override
   void bottomMethod() {
 
   }
 
+  @Override
   void middleMethod() {
 
   }
 
+  @Override
   void topMethod() {
 
   }
@@ -24,6 +27,6 @@
   }
 
   public static void main(String[] args) {
-    new Test().test();
+    new Memberrebinding().test();
   }
 }
diff --git a/src/test/examplesAndroidN/memberrebinding4/Test.java b/src/test/examplesAndroidN/memberrebinding4/Memberrebinding.java
similarity index 93%
rename from src/test/examplesAndroidN/memberrebinding4/Test.java
rename to src/test/examplesAndroidN/memberrebinding4/Memberrebinding.java
index 6fc2ad5..a699537 100644
--- a/src/test/examplesAndroidN/memberrebinding4/Test.java
+++ b/src/test/examplesAndroidN/memberrebinding4/Memberrebinding.java
@@ -5,7 +5,7 @@
 
 import memberrebinding4.subpackage.PublicInterface;
 
-public class Test {
+public class Memberrebinding {
 
   static class Inner implements PublicInterface {
 
diff --git a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
index 728f769..db81f17 100644
--- a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
@@ -18,6 +18,8 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -80,17 +82,20 @@
         Assert.assertEquals(1, descriptors.size());
         String classDescriptor = descriptors.iterator().next();
         classDescriptor = classDescriptor.substring(1, classDescriptor.length() - 1);
-        fileToResource.put(classDescriptor + ".class", resource);
+        String classFilePath = classDescriptor + ".class";
+        if (File.separatorChar != '/') {
+          classFilePath = classFilePath.replace('/', File.separatorChar);
+        }
+        fileToResource.put(classFilePath, resource);
       }
       return fileToResource;
     }
 
     private Path makeRelative(Path testJarFile, Path classFile) {
-      classFile = classFile.toAbsolutePath();
       Path regularParent =
-          testJarFile.getParent().resolve(Paths.get("classes")).toAbsolutePath();
+          testJarFile.getParent().resolve(Paths.get("classes"));
       Path legacyParent = regularParent.resolve(Paths.get("..",
-          regularParent.getFileName().toString() + "Legacy", "classes")).toAbsolutePath();
+          regularParent.getFileName().toString() + "Legacy", "classes"));
 
       if (classFile.startsWith(regularParent)) {
         return regularParent.relativize(classFile);
@@ -102,9 +107,9 @@
     private List<String> collectClassFiles(Path testJarFile) {
       List<String> result = new ArrayList<>();
       // Collect Java 8 classes.
-      collectClassFiles(getClassesRoot(testJarFile).toFile(), result);
+      collectClassFiles(getClassesRoot(testJarFile), result);
       // Collect legacy classes.
-      collectClassFiles(getLegacyClassesRoot(testJarFile).toFile(), result);
+      collectClassFiles(getLegacyClassesRoot(testJarFile), result);
       Collections.sort(result);
       return result;
     }
@@ -121,15 +126,18 @@
       return parent.resolve(legacyPath);
     }
 
-    private void collectClassFiles(File dir, List<String> result) {
-      File[] files = dir.listFiles();
-      if (files != null) {
-        for (File file : files) {
-          if (file.isDirectory()) {
-            collectClassFiles(file, result);
-          } else {
-            result.add(file.getAbsolutePath());
+    private void collectClassFiles(Path dir, List<String> result) {
+      if (Files.exists(dir)) {
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
+          for (Path entry: stream) {
+            if (Files.isDirectory(entry)) {
+              collectClassFiles(entry, result);
+            } else {
+              result.add(entry.toString());
+            }
           }
+        } catch (IOException x) {
+          throw new AssertionError(x);
         }
       }
     }
diff --git a/src/test/java/com/android/tools/r8/D8ResourceProviderRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
similarity index 79%
rename from src/test/java/com/android/tools/r8/D8ResourceProviderRunExamplesAndroidOTest.java
rename to src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
index 7cef1a4..34cd83c 100644
--- a/src/test/java/com/android/tools/r8/D8ResourceProviderRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8LazyRunExamplesAndroidOTest.java
@@ -4,12 +4,12 @@
 
 package com.android.tools.r8;
 
-import com.android.tools.r8.utils.DirectoryResourceProvider;
-import com.android.tools.r8.utils.PreloadedResourceProvider;
+import com.android.tools.r8.utils.DirectoryClassFileProvider;
+import com.android.tools.r8.utils.PreloadedClassFileProvider;
 import java.io.IOException;
 import java.nio.file.Path;
 
-public class D8ResourceProviderRunExamplesAndroidOTest
+public class D8LazyRunExamplesAndroidOTest
     extends D8IncrementalRunExamplesAndroidOTest {
   class D8LazyTestRunner extends D8IncrementalTestRunner {
 
@@ -25,13 +25,13 @@
 
     private void addClasspathPath(Path location, D8Command.Builder builder) {
       builder.addClasspathResourceProvider(
-          DirectoryResourceProvider.fromDirectory(location.resolve("..")));
+          DirectoryClassFileProvider.fromDirectory(location.resolve("..")));
     }
 
     @Override
     void addLibraryReference(D8Command.Builder builder, Path location) throws IOException {
       builder.addLibraryResourceProvider(
-          PreloadedResourceProvider.fromArchive(location));
+          PreloadedClassFileProvider.fromArchive(location));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/D8RegularLazyRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8NonLazyRunExamplesAndroidOTest.java
similarity index 95%
rename from src/test/java/com/android/tools/r8/D8RegularLazyRunExamplesAndroidOTest.java
rename to src/test/java/com/android/tools/r8/D8NonLazyRunExamplesAndroidOTest.java
index 38acabe..42d3c47 100644
--- a/src/test/java/com/android/tools/r8/D8RegularLazyRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8NonLazyRunExamplesAndroidOTest.java
@@ -8,7 +8,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
-public class D8RegularLazyRunExamplesAndroidOTest
+public class D8NonLazyRunExamplesAndroidOTest
     extends D8IncrementalRunExamplesAndroidOTest {
   class D8LazyTestRunner extends D8IncrementalTestRunner {
 
diff --git a/src/test/java/com/android/tools/r8/JctfTestSpecifications.java b/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
index b1934dd..f7cbee8 100644
--- a/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
+++ b/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
@@ -4686,8 +4686,7 @@
           // 1) t02
           // java.lang.AssertionError: java.lang.AssertionError: expected:<5> but was:<4>
 
-          .put("lang.Thread.interrupt.Thread_interrupt_A04",
-              match(D8_COMPILER, runtimes(DexVm.ART_6_0_1)))
+          .put("lang.Thread.interrupt.Thread_interrupt_A04", any())
           // Been running fine for a while then this happened on a bot:
           // 1) t01
           // java.lang.AssertionError: expected:<BLOCKED> but was:<RUNNABLE>
diff --git a/src/test/java/com/android/tools/r8/R8EntryPointTests.java b/src/test/java/com/android/tools/r8/R8EntryPointTests.java
new file mode 100644
index 0000000..c83cea6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/R8EntryPointTests.java
@@ -0,0 +1,124 @@
+// Copyright (c) 2017, 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.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardRuleParserException;
+import com.android.tools.r8.utils.FileUtils;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class R8EntryPointTests extends TestBase {
+
+  private static final String MAPPING = "mapping.txt";
+  private static final String SEEDS = "seeds.txt";
+  private static final Path INPUT_JAR =
+      Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, "minification" + FileUtils.JAR_EXTENSION);
+  private static final Path PROGUARD_FLAGS =
+      Paths.get(ToolHelper.EXAMPLES_DIR, "minification",  "keep-rules.txt");
+
+  private Path testFlags;
+
+  @Before
+  public void setup() throws IOException {
+    testFlags = temp.newFile("local.flags").toPath();
+    FileUtils.writeTextFile(testFlags, ImmutableList.of(
+        "-printseeds " + SEEDS,
+        "-printmapping " + MAPPING));
+  }
+
+  @Test
+  public void testRun1Dir() throws IOException, CompilationException, ProguardRuleParserException {
+    Path out = temp.newFolder("outdex").toPath();
+    R8.run(getCommand(out));
+    Assert.assertTrue(Files.isRegularFile(out.resolve(FileUtils.DEFAULT_DEX_FILENAME)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  @Test
+  public void testRun1Zip() throws IOException, CompilationException, ProguardRuleParserException {
+    Path out = temp.newFolder("outdex").toPath().resolve("dex.zip");
+    R8.run(getCommand(out));
+    Assert.assertTrue(Files.isRegularFile(out));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  @Test
+  public void testRun2Dir() throws IOException, CompilationException, ProguardRuleParserException {
+    Path out = temp.newFolder("outdex").toPath();
+    ExecutorService executor = Executors.newWorkStealingPool(2);
+    try {
+      R8.run(getCommand(out), executor);
+    } finally {
+      executor.shutdown();
+    }
+    Assert.assertTrue(Files.isRegularFile(out.resolve(FileUtils.DEFAULT_DEX_FILENAME)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  @Test
+  public void testRun2Zip() throws IOException, CompilationException, ProguardRuleParserException {
+    Path out = temp.newFolder("outdex").toPath().resolve("dex.zip");
+    ExecutorService executor = Executors.newWorkStealingPool(2);
+    try {
+      R8.run(getCommand(out), executor);
+    } finally {
+      executor.shutdown();
+    }
+    Assert.assertTrue(Files.isRegularFile(out));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  @Test
+  public void testMainDir() throws IOException, InterruptedException {
+    Path out = temp.newFolder("outdex").toPath();
+    ProcessResult r8 = ToolHelper.forkR8(Paths.get("."),
+        "--lib", ToolHelper.getDefaultAndroidJar(),
+        "--output", out.toString(),
+        "--pg-conf", PROGUARD_FLAGS.toString(),
+        "--pg-conf", testFlags.toString(),
+        INPUT_JAR.toString());
+    Assert.assertEquals(0, r8.exitCode);
+    Assert.assertTrue(Files.isRegularFile(out.resolve(FileUtils.DEFAULT_DEX_FILENAME)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  @Test
+  public void testMainZip() throws IOException, InterruptedException {
+    Path out = temp.newFolder("outdex").toPath().resolve("dex.zip");
+    ProcessResult r8 = ToolHelper.forkR8(Paths.get("."),
+        "--lib", ToolHelper.getDefaultAndroidJar(),
+        "--output", out.toString(),
+        "--pg-conf", PROGUARD_FLAGS.toString(),
+        "--pg-conf", testFlags.toString(),
+        INPUT_JAR.toString());
+    Assert.assertEquals(0, r8.exitCode);
+    Assert.assertTrue(Files.isRegularFile(out));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(MAPPING)));
+    Assert.assertTrue(Files.isRegularFile(testFlags.getParent().resolve(SEEDS)));
+  }
+
+  private R8Command getCommand(Path out) throws CompilationException, IOException {
+    return R8Command.builder()
+      .addLibraryFiles(Paths.get(ToolHelper.getDefaultAndroidJar()))
+      .addProgramFiles(INPUT_JAR)
+      .setOutputPath(out)
+      .addProguardConfigurationFiles(PROGUARD_FLAGS, testFlags)
+      .build();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index 66844af..13a4c24 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -989,7 +989,7 @@
             builder.setMinApiLevel(minSdkVersion);
           }
           D8Output output = D8.run(builder.build());
-          output.write(Paths.get(resultPath));
+          output.write(Paths.get(resultPath), true);
           break;
         }
       case R8:
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
index a264f48..5e265aa 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
+import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.JarBuilder;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -40,7 +41,6 @@
 public class R8RunExamplesTest {
 
   private static final String EXAMPLE_DIR = ToolHelper.EXAMPLES_BUILD_DIR;
-  private static final String DEFAULT_DEX_FILENAME = "classes.dex";
 
   // For local testing on a specific Art version(s) change this set. e.g. to
   // ImmutableSet.of(DexVm.ART_DEFAULT) or pass the option -Ddex_vm=<version> to the Java VM.
@@ -103,8 +103,8 @@
         "regress_37875803.Regress",
         "regress_37955340.Regress",
         "regress_62300145.Regress",
-        "memberrebinding2.Test",
-        "memberrebinding3.Test",
+        "memberrebinding2.Memberrebinding",
+        "memberrebinding3.Memberrebinding",
         "minification.Minification",
         "enclosingmethod.Main",
         "interfaceinlining.Main",
@@ -123,7 +123,7 @@
   private static String[] makeTest(
       DexTool tool, CompilerUnderTest compiler, CompilationMode mode, String clazz) {
     String pkg = clazz.substring(0, clazz.lastIndexOf('.'));
-    return new String[] {pkg, tool.name(), compiler.name(), mode.name(), clazz};
+    return new String[]{pkg, tool.name(), compiler.name(), mode.name(), clazz};
   }
 
   @Rule
@@ -161,7 +161,7 @@
   }
 
   private Path getOriginalDexFile() {
-    return Paths.get(EXAMPLE_DIR, pkg, DEFAULT_DEX_FILENAME);
+    return Paths.get(EXAMPLE_DIR, pkg, FileUtils.DEFAULT_DEX_FILENAME);
   }
 
   @Rule
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 28d4872..3f31686 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -96,6 +96,15 @@
   /**
    * Compile an application with R8.
    */
+  protected AndroidApp compileWithR8(List<Class> classes, Consumer<InternalOptions> optionsConsumer)
+      throws CompilationException, ProguardRuleParserException, ExecutionException, IOException {
+    R8Command command = ToolHelper.prepareR8CommandBuilder(readClasses(classes)).build();
+    return ToolHelper.runR8(command, optionsConsumer);
+  }
+
+  /**
+   * Compile an application with R8.
+   */
   protected AndroidApp compileWithR8(AndroidApp app, Consumer<InternalOptions> optionsConsumer)
       throws CompilationException, ProguardRuleParserException, ExecutionException, IOException {
     R8Command command = ToolHelper.prepareR8CommandBuilder(app).build();
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index d7fd468..e74eb2c 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -14,7 +14,6 @@
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -41,6 +40,7 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import joptsimple.internal.Strings;
+import org.junit.Assume;
 import org.junit.rules.TemporaryFolder;
 
 public class ToolHelper {
@@ -53,6 +53,8 @@
   public static final String EXAMPLES_ANDROID_O_BUILD_DIR = BUILD_DIR + "test/examplesAndroidO/";
   public static final String SMALI_BUILD_DIR = BUILD_DIR + "test/smali/";
 
+  public static final String LINE_SEPARATOR = System.getProperty("line.separator");
+
   private static final String ANDROID_JAR_PATTERN = "third_party/android_jar/lib-v%d/android.jar";
   private static final int DEFAULT_MIN_SDK = 14;
 
@@ -379,6 +381,10 @@
     return getPlatform().startsWith("Mac");
   }
 
+  public static boolean isWindows() {
+    return getPlatform().startsWith("Windows");
+  }
+
   public static boolean artSupported() {
     if (!isLinux() && !isMac()) {
       System.err.println("Testing on your platform is not fully supported. " +
@@ -462,9 +468,7 @@
       optionsConsumer.accept(options);
     }
     CompilationResult result = R8.runForTesting(app, options);
-    if (command.getOutputPath() != null) {
-      result.androidApp.write(command.getOutputPath(), OutputMode.Indexed);
-    }
+    R8.writeOutputs(command, options, result.androidApp);
     return result;
   }
 
@@ -519,6 +523,7 @@
   }
 
   public static ProcessResult runDX(String[] args) throws IOException {
+    Assume.assumeTrue(ToolHelper.artSupported());
     DXCommandBuilder builder = new DXCommandBuilder();
     for (String arg : args) {
       builder.appendProgramArgument(arg);
@@ -601,6 +606,7 @@
   }
 
   private static ProcessResult runArtProcess(ArtCommandBuilder builder) throws IOException {
+    Assume.assumeTrue(ToolHelper.artSupported());
     ProcessResult result = runProcess(builder.asProcessBuilder());
     if (result.exitCode != 0) {
       fail("Unexpected art failure: '" + result.stderr + "'\n" + result.stdout);
@@ -640,6 +646,7 @@
   }
 
   public static void runDex2Oat(Path file, Path outFile) throws IOException {
+    Assume.assumeTrue(ToolHelper.artSupported());
     assert Files.exists(file);
     assert ByteStreams.toByteArray(Files.newInputStream(file)).length > 0;
     List<String> command = new ArrayList<>();
diff --git a/src/test/java/com/android/tools/r8/compatdx/CompatDxTests.java b/src/test/java/com/android/tools/r8/compatdx/CompatDxTests.java
index 4131b86..81f660a 100644
--- a/src/test/java/com/android/tools/r8/compatdx/CompatDxTests.java
+++ b/src/test/java/com/android/tools/r8/compatdx/CompatDxTests.java
@@ -8,11 +8,15 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.maindexlist.MainDexListTests;
+import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.StringUtils.BraceType;
+import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -21,6 +25,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
@@ -95,9 +100,14 @@
   }
 
   @Test
-  public void singleDexProgramIsTooLarge() throws IOException {
+  public void singleDexProgramIsTooLarge() throws IOException, ExecutionException {
+    // Generate an application that will not fit into a single dex file.
+    AndroidApp generated = MainDexListTests.generateApplication(
+        ImmutableList.of("A", "B"), Constants.ANDROID_L_API, Constants.U16BIT_MAX / 2 + 1);
+    Path applicationJar = temp.newFile("application.jar").toPath();
+    generated.write(applicationJar, OutputMode.Indexed, true);
     thrown.expect(CompilationError.class);
-    runDexer(MainDexListTests.getTwoLargeClassesAppPath().toString());
+    runDexer(applicationJar.toString());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/d8/DexVersionTests.java b/src/test/java/com/android/tools/r8/d8/DexVersionTests.java
index 0d72a52..2cdb4d7 100644
--- a/src/test/java/com/android/tools/r8/d8/DexVersionTests.java
+++ b/src/test/java/com/android/tools/r8/d8/DexVersionTests.java
@@ -38,17 +38,17 @@
     D8Command.Builder arithmeticBuilder = D8Command.builder().addProgramFiles(ARITHMETIC_JAR);
     D8Command.Builder arrayAccessBuilder = D8Command.builder().addProgramFiles(ARRAYACCESS_JAR);
     D8Output output = D8.run(arrayAccessBuilder.build());
-    output.write(defaultApiFolder1.getRoot().toPath());
+    output.write(defaultApiFolder1.getRoot().toPath(), true);
     output = D8.run(arrayAccessBuilder.setMinApiLevel(Constants.ANDROID_O_API).build());
-    output.write(androidOApiFolder1.getRoot().toPath());
+    output.write(androidOApiFolder1.getRoot().toPath(), true);
     output = D8.run(arrayAccessBuilder.setMinApiLevel(Constants.ANDROID_N_API).build());
-    output.write(androidNApiFolder1.getRoot().toPath());
+    output.write(androidNApiFolder1.getRoot().toPath(), true);
     output = D8.run(arithmeticBuilder.build());
-    output.write(defaultApiFolder2.getRoot().toPath());
+    output.write(defaultApiFolder2.getRoot().toPath(), true);
     output = D8.run(arithmeticBuilder.setMinApiLevel(Constants.ANDROID_O_API).build());
-    output.write(androidOApiFolder2.getRoot().toPath());
+    output.write(androidOApiFolder2.getRoot().toPath(), true);
     output = D8.run(arithmeticBuilder.setMinApiLevel(Constants.ANDROID_N_API).build());
-    output.write(androidNApiFolder2.getRoot().toPath());
+    output.write(androidNApiFolder2.getRoot().toPath(), true);
   }
 
   private Path default1() {
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index 9cffe15..4cef632 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -20,6 +20,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Queue;
 import java.util.TreeMap;
 import java.util.function.Consumer;
@@ -245,7 +246,10 @@
   }
 
   protected final JUnit3Wrapper.Command checkNoLocal() {
-    return inspect(t -> Assert.assertTrue(t.getLocalNames().isEmpty()));
+    return inspect(t -> {
+      List<String> localNames = t.getLocalNames();
+      Assert.assertTrue("Local variables: " + String.join(",", localNames), localNames.isEmpty());
+    });
   }
 
   protected final JUnit3Wrapper.Command checkLine(String sourceFile, int line) {
@@ -475,11 +479,13 @@
       }
 
       public void checkLocal(String localName) {
-        getVariableAt(getLocation(), localName);
+        Optional<Variable> localVar = getVariableAt(getLocation(), localName);
+        Assert.assertTrue("No local '" + localName + "'", localVar.isPresent());
       }
 
       public void checkLocal(String localName, Value expectedValue) {
-        Variable localVar = getVariableAt(getLocation(), localName);
+        Optional<Variable> localVar = getVariableAt(getLocation(), localName);
+        Assert.assertTrue("No local '" + localName + "'", localVar.isPresent());
 
         // Get value
         CommandPacket commandPacket = new CommandPacket(
@@ -488,8 +494,8 @@
         commandPacket.setNextValueAsThreadID(getThreadId());
         commandPacket.setNextValueAsFrameID(getFrameId());
         commandPacket.setNextValueAsInt(1);
-        commandPacket.setNextValueAsInt(localVar.getSlot());
-        commandPacket.setNextValueAsByte(localVar.getTag());
+        commandPacket.setNextValueAsInt(localVar.get().getSlot());
+        commandPacket.setNextValueAsByte(localVar.get().getTag());
         ReplyPacket replyPacket = getMirror().performCommand(commandPacket);
         checkReplyPacket(replyPacket, "StackFrame.GetValues command");
         int valuesCount = replyPacket.getNextValueAsInt();
@@ -594,11 +600,10 @@
       return index >= varStart && index < varEnd;
     }
 
-    private Variable getVariableAt(Location location, String localName) {
+    private Optional<Variable> getVariableAt(Location location, String localName) {
       return getVariablesAt(location).stream()
           .filter(v -> localName.equals(v.getName()))
-          .findFirst()
-          .get();
+          .findFirst();
     }
 
     private List<Variable> getVariablesAt(Location location) {
@@ -858,13 +863,16 @@
 
         @Override
         public void perform(JUnit3Wrapper testBase) {
-          Variable v = testBase.getVariableAt(testBase.debuggeeState.location, localName);
+          Optional<Variable> localVar = testBase
+              .getVariableAt(testBase.debuggeeState.location, localName);
+          Assert.assertTrue("No local '" + localName + "'", localVar.isPresent());
+
           CommandPacket setValues = new CommandPacket(StackFrameCommandSet.CommandSetID,
               StackFrameCommandSet.SetValuesCommand);
           setValues.setNextValueAsThreadID(testBase.getDebuggeeState().getThreadId());
           setValues.setNextValueAsFrameID(testBase.getDebuggeeState().getFrameId());
           setValues.setNextValueAsInt(1);
-          setValues.setNextValueAsInt(v.getSlot());
+          setValues.setNextValueAsInt(localVar.get().getSlot());
           setValues.setNextValueAsValue(newValue);
           ReplyPacket replyPacket = testBase.getMirror().performCommand(setValues);
           testBase.checkReplyPacket(replyPacket, "StackFrame.SetValues");
diff --git a/src/test/java/com/android/tools/r8/debug/DefaultMethodTest.java b/src/test/java/com/android/tools/r8/debug/InterfaceMethodTest.java
similarity index 61%
rename from src/test/java/com/android/tools/r8/debug/DefaultMethodTest.java
rename to src/test/java/com/android/tools/r8/debug/InterfaceMethodTest.java
index e0eb5ea..a7dcb60 100644
--- a/src/test/java/com/android/tools/r8/debug/DefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/debug/InterfaceMethodTest.java
@@ -9,13 +9,13 @@
 import java.util.List;
 import org.junit.Test;
 
-public class DefaultMethodTest extends DebugTestBase {
+public class InterfaceMethodTest extends DebugTestBase {
 
-  private static final String SOURCE_FILE = "DebugDefaultMethod.java";
+  private static final String SOURCE_FILE = "DebugInterfaceMethod.java";
 
   @Test
   public void testDefaultMethod() throws Throwable {
-    String debuggeeClass = "DebugDefaultMethod";
+    String debuggeeClass = "DebugInterfaceMethod";
     String parameterName = "msg";
     String localVariableName = "name";
 
@@ -23,13 +23,17 @@
     commands.add(breakpoint(debuggeeClass, "testDefaultMethod"));
     commands.add(run());
     commands.add(checkMethod(debuggeeClass, "testDefaultMethod"));
-    commands.add(checkLine(SOURCE_FILE, 27));
+    commands.add(checkLine(SOURCE_FILE, 31));
     if (!supportsDefaultMethod()) {
       // We desugared default method. This means we're going to step through an extra (forward)
       // method first.
       commands.add(stepInto());
     }
     commands.add(stepInto());
+    // TODO(shertz) we should see the local variable this even when desugaring.
+    if (supportsDefaultMethod()) {
+      commands.add(checkLocal("this"));
+    }
     commands.add(checkLocal(parameterName));
     commands.add(stepOver());
     commands.add(checkLocal(parameterName));
@@ -43,7 +47,7 @@
 
   @Test
   public void testOverrideDefaultMethod() throws Throwable {
-    String debuggeeClass = "DebugDefaultMethod";
+    String debuggeeClass = "DebugInterfaceMethod";
     String parameterName = "msg";
     String localVariableName = "newMsg";
 
@@ -52,13 +56,34 @@
     commands.add(run());
     commands.add(run() /* resume after 1st breakpoint */);
     commands.add(checkMethod(debuggeeClass, "testDefaultMethod"));
-    commands.add(checkLine(SOURCE_FILE, 27));
+    commands.add(checkLine(SOURCE_FILE, 31));
     commands.add(stepInto());
-    commands.add(checkMethod("DebugDefaultMethod$OverrideImpl", "doSomething"));
+    commands.add(checkMethod("DebugInterfaceMethod$OverrideImpl", "doSomething"));
+    commands.add(checkLocal("this"));
+    commands.add(checkLocal(parameterName));
+    commands.add(stepOver());
+    commands.add(checkLocal("this"));
+    commands.add(checkLocal(parameterName));
+    commands.add(checkLocal(localVariableName));
+    commands.add(run());
+
+    runDebugTestJava8(debuggeeClass, commands);
+  }
+
+  @Test
+  public void testStaticMethod() throws Throwable {
+    String debuggeeClass = "DebugInterfaceMethod";
+    String parameterName = "msg";
+
+    List<Command> commands = new ArrayList<>();
+    commands.add(breakpoint(debuggeeClass, "testStaticMethod"));
+    commands.add(run());
+    commands.add(checkMethod(debuggeeClass, "testStaticMethod"));
+    commands.add(checkLine(SOURCE_FILE, 35));
+    commands.add(stepInto());
     commands.add(checkLocal(parameterName));
     commands.add(stepOver());
     commands.add(checkLocal(parameterName));
-    commands.add(checkLocal(localVariableName));
     commands.add(run());
 
     runDebugTestJava8(debuggeeClass, commands);
diff --git a/src/test/java/com/android/tools/r8/debug/LambdaTest.java b/src/test/java/com/android/tools/r8/debug/LambdaTest.java
index 52d9c70..6bdbb90 100644
--- a/src/test/java/com/android/tools/r8/debug/LambdaTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LambdaTest.java
@@ -4,17 +4,18 @@
 
 package com.android.tools.r8.debug;
 
+import org.junit.Assert;
 import org.junit.Test;
 
+// TODO(shertz) test local variables
 public class LambdaTest extends DebugTestBase {
 
   public static final String SOURCE_FILE = "DebugLambda.java";
 
   @Test
-  public void testLambdaDebugging() throws Throwable {
+  public void testLambda_ExpressionOnSameLine() throws Throwable {
     String debuggeeClass = "DebugLambda";
     String initialMethodName = "printInt";
-    // TODO(shertz) test local variables
     runDebugTestJava8(debuggeeClass,
         breakpoint(debuggeeClass, initialMethodName),
         run(),
@@ -24,4 +25,56 @@
         checkLine(SOURCE_FILE, 16),
         run());
   }
+
+  @Test
+  public void testLambda_StatementOnNewLine() throws Throwable {
+    String debuggeeClass = "DebugLambda";
+    String initialMethodName = "printInt3";
+    runDebugTestJava8(debuggeeClass,
+        breakpoint(debuggeeClass, initialMethodName),
+        run(),
+        checkMethod(debuggeeClass, initialMethodName),
+        checkLine(SOURCE_FILE, 32),
+        stepInto(INTELLIJ_FILTER),
+        checkLine(SOURCE_FILE, 37),
+        run());
+  }
+
+  @Test
+  public void testLambda_StaticMethodReference_Trivial() throws Throwable {
+    String debuggeeClass = "DebugLambda";
+    String initialMethodName = "printInt2";
+    runDebugTestJava8(debuggeeClass,
+        breakpoint(debuggeeClass, initialMethodName),
+        run(),
+        checkMethod(debuggeeClass, initialMethodName),
+        checkLine(SOURCE_FILE, 20),
+        stepInto(INTELLIJ_FILTER),
+        isRunningJava() ? LambdaTest::doNothing : stepInto(INTELLIJ_FILTER),
+        checkMethod(debuggeeClass, "returnOne"),
+        checkLine(SOURCE_FILE, 28),
+        checkNoLocal(),
+        run());
+  }
+
+  @Test
+  public void testLambda_StaticMethodReference_NonTrivial() throws Throwable {
+    String debuggeeClass = "DebugLambda";
+    String initialMethodName = "testLambdaWithMethodReferenceAndConversion";
+    runDebugTestJava8(debuggeeClass,
+        breakpoint(debuggeeClass, initialMethodName),
+        run(),
+        checkMethod(debuggeeClass, initialMethodName),
+        checkLine(SOURCE_FILE, 46),
+        stepInto(INTELLIJ_FILTER),
+        inspect(t -> Assert.assertTrue(t.getCurrentMethodName().startsWith("lambda$"))),
+        stepInto(INTELLIJ_FILTER),
+        checkMethod(debuggeeClass, "concatObjects"),
+        checkLine(SOURCE_FILE, 57),
+        checkLocal("objects"),
+        run());
+  }
+
+  private static void doNothing(JUnit3Wrapper jUnit3Wrapper) {
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/debuginfo/LocalsInSwitchTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/LocalsInSwitchTestRunner.java
index 020809a..af726bf 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/LocalsInSwitchTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/LocalsInSwitchTestRunner.java
@@ -5,6 +5,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.AndroidApp;
 import org.junit.Test;
 
@@ -17,7 +18,8 @@
     AndroidApp d8App = compileWithD8(clazz);
     AndroidApp dxApp = getDxCompiledSources();
 
-    String expected = "55\n1862\n15130\n";
+    String expected = "55" + ToolHelper.LINE_SEPARATOR + "1862" + ToolHelper.LINE_SEPARATOR
+            + "15130" + ToolHelper.LINE_SEPARATOR;
     assertEquals(expected, runOnJava(clazz));
     assertEquals(expected, runOnArt(d8App, clazz.getCanonicalName()));
     assertEquals(expected, runOnArt(dxApp, clazz.getCanonicalName()));
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SynchronizedMethodTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/SynchronizedMethodTestRunner.java
index 7370ca2..7cee4a3 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/SynchronizedMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/SynchronizedMethodTestRunner.java
@@ -5,6 +5,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.AndroidApp;
 import org.junit.Test;
 
@@ -17,7 +18,7 @@
     AndroidApp d8App = compileWithD8(clazz);
     AndroidApp dxApp = getDxCompiledSources();
 
-    String expected = "42\n42\n";
+    String expected = "42" + ToolHelper.LINE_SEPARATOR + "42" + ToolHelper.LINE_SEPARATOR;
     assertEquals(expected, runOnJava(clazz));
     assertEquals(expected, runOnArt(d8App, clazz.getCanonicalName()));
     assertEquals(expected, runOnArt(dxApp, clazz.getCanonicalName()));
diff --git a/src/test/java/com/android/tools/r8/dex/ExtraFileTest.java b/src/test/java/com/android/tools/r8/dex/ExtraFileTest.java
index 26067c7..d1e46f3 100644
--- a/src/test/java/com/android/tools/r8/dex/ExtraFileTest.java
+++ b/src/test/java/com/android/tools/r8/dex/ExtraFileTest.java
@@ -25,7 +25,7 @@
   private static final String EXAMPLE_DIR = ToolHelper.EXAMPLES_BUILD_DIR;
   private static final String EXAMPLE_DEX = "memberrebinding/classes.dex";
   private static final String EXAMPLE_LIB = "memberrebindinglib/classes.dex";
-  private static final String EXAMPLE_CLASS = "memberrebinding.Test";
+  private static final String EXAMPLE_CLASS = "memberrebinding.Memberrebinding";
   private static final String EXAMPLE_PACKAGE_MAP = "memberrebinding/package.map";
   private static final String EXAMPLE_PROGUARD_MAP = "memberrebinding/proguard.map";
 
@@ -47,6 +47,7 @@
         R8Command.builder()
             .addProgramFiles(original)
             .setOutputPath(out)
+            .setMinApiLevel(Constants.ANDROID_L_API) // Allow native multidex.
             .setProguardMapFile(proguardMap)
             .setPackageDistributionFile(packageMap)
             .build();
diff --git a/src/test/java/com/android/tools/r8/internal/CompilationTestBase.java b/src/test/java/com/android/tools/r8/internal/CompilationTestBase.java
index 80a1324..d5e66b8 100644
--- a/src/test/java/com/android/tools/r8/internal/CompilationTestBase.java
+++ b/src/test/java/com/android/tools/r8/internal/CompilationTestBase.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.R8RunArtTestsTest.CompilerUnderTest;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.ArtErrorParser;
@@ -67,7 +68,11 @@
         builder.addProguardConfigurationFiles(Paths.get(pgConf));
       }
       builder.setMode(mode);
-      outputApp = ToolHelper.runR8(builder.build());
+      outputApp = ToolHelper.runR8(builder.build(),
+                  options -> {
+                    options.printSeeds = false;
+                    options.minApiLevel = Constants.ANDROID_L_API;
+                  });
     } else {
       assert compiler == CompilerUnderTest.D8;
       outputApp =
@@ -75,6 +80,7 @@
               D8Command.builder()
                   .addProgramFiles(ListUtils.map(inputs, Paths::get))
                   .setMode(mode)
+                  .setMinApiLevel(Constants.ANDROID_L_API)
                   .build());
     }
     Path out = temp.getRoot().toPath().resolve("all.zip");
diff --git a/src/test/java/com/android/tools/r8/internal/R8DisassemblerTest.java b/src/test/java/com/android/tools/r8/internal/R8DisassemblerTest.java
index 1f20559..d455841 100644
--- a/src/test/java/com/android/tools/r8/internal/R8DisassemblerTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8DisassemblerTest.java
@@ -6,8 +6,8 @@
 import static com.android.tools.r8.utils.AndroidApp.DEFAULT_PROGUARD_MAP_FILE;
 
 import com.android.tools.r8.CompilationException;
+import com.android.tools.r8.Disassemble;
 import com.android.tools.r8.R8;
-import com.android.tools.r8.R8Command;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.FileUtils;
 import java.io.IOException;
@@ -27,11 +27,8 @@
 
   static final String APP_DIR = "third_party/gmscore/v5/";
 
-  public boolean deobfuscate;
-
-  @Test
-  public void disassemble() throws IOException, ExecutionException, ProguardRuleParserException,
-      CompilationException {
+  public void testDisassemble(boolean deobfuscate, boolean smali)
+      throws IOException, ExecutionException, ProguardRuleParserException, CompilationException {
     // This test only ensures that we do not break disassembling of dex code. It does not
     // check the generated code. To make it fast, we get rid of the output.
     PrintStream originalOut = System.out;
@@ -40,7 +37,8 @@
     }));
 
     try {
-      R8Command.Builder builder = R8Command.builder();
+      Disassemble.DisassembleCommand.Builder builder = Disassemble.DisassembleCommand.builder();
+      builder.setUseSmali(smali);
       if (deobfuscate) {
         builder.setProguardMapFile(Paths.get(APP_DIR, DEFAULT_PROGUARD_MAP_FILE));
       }
@@ -54,4 +52,24 @@
       System.setOut(originalOut);
     }
   }
+
+  @Test
+  public void test1() throws  Exception {
+    testDisassemble(false, false);
+  }
+
+  @Test
+  public void test2() throws  Exception {
+    testDisassemble(false, true);
+  }
+
+  @Test
+  public void test3() throws  Exception {
+    testDisassemble(true, false);
+  }
+
+  @Test
+  public void test4() throws  Exception {
+    testDisassemble(true, true);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
index 2bc8dba..74f9ef9 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
@@ -10,6 +10,9 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.Resource;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.conversion.CallGraph;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.OutputMode;
@@ -19,17 +22,30 @@
 import java.io.InputStream;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import org.junit.Test;
 
 public class R8GMSCoreDeterministicTest extends GMSCoreCompilationTestBase {
 
+  public List<DexEncodedMethod> shuffle(List<DexEncodedMethod> methods, CallGraph.Leaves leaves) {
+    Collections.shuffle(methods);
+    return methods;
+  }
+
   private AndroidApp doRun()
       throws IOException, ProguardRuleParserException, CompilationException, ExecutionException {
     R8Command command =
         R8Command.builder().addProgramFiles(Paths.get(GMSCORE_V7_DIR, GMSCORE_APK)).build();
-    return ToolHelper.runR8(command, options -> options.testing.randomizeCallGraphLeaves = true);
+    return ToolHelper.runR8(
+        command, options -> {
+          // For this test just do random shuffle.
+          options.testing.irOrdering = this::shuffle;
+          // Only use one thread to process to process in the order decided by the callback.
+          options.numberOfThreads = 1;
+          options.minApiLevel = Constants.ANDROID_L_API;
+        });
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreFixedPointTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreFixedPointTest.java
index b6d3dac..376ccf3 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreFixedPointTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreFixedPointTest.java
@@ -7,6 +7,7 @@
 
 import com.android.tools.r8.CompilationException;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApp;
 import java.io.IOException;
@@ -21,14 +22,18 @@
       throws ExecutionException, IOException, ProguardRuleParserException, CompilationException {
     // First compilation.
     AndroidApp app = AndroidApp.fromProgramDirectory(Paths.get(GMSCORE_V7_DIR));
-    AndroidApp app1 = ToolHelper.runR8(app);
+    AndroidApp app1 =
+        ToolHelper.runR8(app, options -> options.minApiLevel = Constants.ANDROID_L_API);
 
     // Second compilation.
     // Add option --skip-outline-opt for second compilation. The second compilation can find
     // additional outlining opportunities as member rebinding from the first compilation can move
     // methods.
     // See b/33410508 and b/33475705.
-    AndroidApp app2 = ToolHelper.runR8(app1, options -> options.outline.enabled = false);
+    AndroidApp app2 = ToolHelper.runR8(app1, options -> {
+      options.outline.enabled = false;
+      options.minApiLevel = Constants.ANDROID_L_API;
+    });
 
     // TODO: Require that the results of the two compilations are the same.
     assertEquals(
diff --git a/src/test/java/com/android/tools/r8/ir/deterministic/DeterministicProcessingTest.java b/src/test/java/com/android/tools/r8/ir/deterministic/DeterministicProcessingTest.java
index eaf9fe3..6acacda 100644
--- a/src/test/java/com/android/tools/r8/ir/deterministic/DeterministicProcessingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/deterministic/DeterministicProcessingTest.java
@@ -10,38 +10,121 @@
 import com.android.tools.r8.CompilationException;
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.conversion.CallGraph;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.smali.SmaliTestBase;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DexInspector;
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import org.junit.Test;
 
 public class DeterministicProcessingTest extends SmaliTestBase {
+  public List<DexEncodedMethod> shuffle(List<DexEncodedMethod> methods, CallGraph.Leaves leaves) {
+    Collections.shuffle(methods);
+    return methods;
+  }
 
+  // This test will process the code a number of times each time shuffling the order in which
+  // the methods are processed. It does not do a exhaustive probing of all permutations, so if
+  // this fails it might not fail consistently, but under all circumstances a failure does reveal
+  // non-determinism in the IR-processing.
   @Test
-  public void test()
+  public void shuffleOrderTest()
       throws IOException, ExecutionException, ProguardRuleParserException, CompilationException {
-    final int ITERATIONS = 10;
+    final int ITERATIONS = 25;
     R8Command.Builder builder =
         R8Command.builder()
             .addProgramFiles(ToolHelper.getClassFileForTestClass(TestClass.class))
             .addLibraryFiles(Paths.get(ToolHelper.getDefaultAndroidJar()));
-    List<byte[]> results = new ArrayList<>();
+    byte[] expectedDex = null;
     for (int i = 0; i < ITERATIONS; i++) {
       AndroidApp result =
           ToolHelper.runR8(
-              builder.build(), options -> options.testing.randomizeCallGraphLeaves = true);
+              builder.build(), options -> {
+                // For this test just do random shuffle.
+                options.testing.irOrdering = this::shuffle;
+                // Only use one thread to process to process in the order decided by the callback.
+                options.numberOfThreads = 1;
+              });
       List<byte[]> dex = result.writeToMemory();
       assertEquals(1, dex.size());
+      if (i == 0) {
+        assert expectedDex == null;
+        expectedDex = dex.get(0);
+      } else {
+        assertArrayEquals(expectedDex, dex.get(0));
+      }
+    }
+  }
+
+  // Global variables used by the shuffler callback.
+  int iteration = 0;
+  Class testClass = null;
+
+  public List<DexEncodedMethod> permutationsOfTwo(
+      List<DexEncodedMethod> methods, CallGraph.Leaves leaves) {
+    if (!leaves.brokeCycles()) {
+      return methods;
+    }
+    methods.sort(Comparator.comparing(DexEncodedMethod::qualifiedName));
+    assertEquals(2, methods.size());
+    String className = testClass.getTypeName();
+    // Check that we are permutating the expected methods.
+    assertEquals(className + ".a", methods.get(0).qualifiedName());
+    assertEquals(className + ".b", methods.get(1).qualifiedName());
+    if (iteration == 1) {
+      Collections.swap(methods, 0, 1);
+    }
+    return methods;
+  }
+
+  public void runTest(Class clazz, boolean inline) throws Exception {
+    final int ITERATIONS = 2;
+    testClass = clazz;
+    R8Command.Builder builder =
+        R8Command.builder()
+            .addProgramFiles(ToolHelper.getClassFileForTestClass(clazz))
+            .addLibraryFiles(Paths.get(ToolHelper.getDefaultAndroidJar()));
+    List<byte[]> results = new ArrayList<>();
+    for (iteration = 0; iteration < ITERATIONS; iteration++) {
+      AndroidApp result =
+          ToolHelper.runR8(
+              builder.build(), options -> {
+                options.inlineAccessors = inline;
+                // Callback to determine IR processing order.
+                options.testing.irOrdering = this::permutationsOfTwo;
+                // Only use one thread to process to process in the order decided by the callback.
+                options.numberOfThreads = 1;
+              });
+      List<byte[]> dex = result.writeToMemory();
+      DexInspector x = new DexInspector(result);
+      assertEquals(1, dex.size());
       results.add(dex.get(0));
-      System.out.println(dex.get(0).length);
     }
     for (int i = 0; i < ITERATIONS - 1; i++) {
       assertArrayEquals(results.get(i), results.get(i + 1));
     }
   }
+
+  @Test
+  public void testReturnArguments() throws Exception {
+    runTest(TestClassReturnsArgument.class, false);
+  }
+
+  @Test
+  public void testReturnConstant() throws Exception {
+    runTest(TestClassReturnsConstant.class, false);
+  }
+
+  @Test
+  public void testInline() throws Exception {
+    runTest(TestClassInline.class, true);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/deterministic/TestClassInline.java b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassInline.java
new file mode 100644
index 0000000..aa50f02
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassInline.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2017, 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.deterministic;
+
+public class TestClassInline {
+
+  public static boolean alwaysFalse() {
+    return false;
+  }
+
+  public static int a() {
+    return b();
+  }
+
+  public static int b() {
+    if (alwaysFalse()) {
+      a();
+      return 0;
+    }
+    return 1;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsArgument.java b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsArgument.java
new file mode 100644
index 0000000..ac70401
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsArgument.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.deterministic;
+
+import java.util.Random;
+
+public class TestClassReturnsArgument {
+
+  public static int a(int x) {
+    return b(new Random().nextInt());
+  }
+
+  public static int b(int x) {
+    a(1);
+    return x;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsConstant.java b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsConstant.java
new file mode 100644
index 0000000..7d63f60
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/deterministic/TestClassReturnsConstant.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.deterministic;
+
+import java.util.Random;
+
+public class TestClassReturnsConstant {
+
+  public static int a(int x) {
+    return b(new Random().nextInt());
+  }
+
+  public static int b(int x) {
+    a(x);
+    return 1;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/IdenticalAfterRegisterAllocationTest.java b/src/test/java/com/android/tools/r8/ir/regalloc/IdenticalAfterRegisterAllocationTest.java
index 0df0031..08e90c0 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/IdenticalAfterRegisterAllocationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/IdenticalAfterRegisterAllocationTest.java
@@ -36,6 +36,11 @@
     public boolean argumentValueUsesHighRegister(Value value, int instructionNumber) {
       return false;
     }
+
+    @Override
+    public int getArgumentOrAllocateRegisterForValue(Value value, int instructionNumber) {
+      return value.getNumber();
+    }
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/jasmin/BooleanByteConfusion.java b/src/test/java/com/android/tools/r8/jasmin/BooleanByteConfusion.java
new file mode 100644
index 0000000..2db35c4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/jasmin/BooleanByteConfusion.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2017, 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.jasmin;
+
+import static junit.framework.TestCase.assertEquals;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+
+public class BooleanByteConfusion extends JasminTestBase {
+
+  private void runTest(JasminBuilder builder, String main) throws Exception {
+    String javaResult = runOnJava(builder, main);
+    String artResult = runOnArt(builder, main);
+    assertEquals(javaResult, artResult);
+    String dxArtResult = runOnArtDx(builder, main);
+    assertEquals(javaResult, dxArtResult);
+  }
+
+  @Test
+  public void booleanByteConfusion() throws Exception {
+    JasminBuilder builder = new JasminBuilder();
+    JasminBuilder.ClassBuilder clazz = builder.addClass("Test");
+
+    // public static void foo(boolean condition) {
+    //   boolean[][] array = null;
+    //   if (condition) {
+    //     array = new boolean[][] { {true}, {false} };
+    //   }
+    //   if (array != null) {
+    //     System.out.println(array[0][0]);
+    //     System.out.println(array[1][0]);
+    //   } else {
+    //     System.out.println("null array");
+    //   }
+    // }
+    clazz.addStaticMethod("foo", ImmutableList.of("Z"), "V",
+        ".limit stack 10",
+        ".limit locals 10",
+        "  aconst_null",
+        // Compiling with new versions of javac seem to always put in this check cast, but it
+        // is not strictly required and some versions of javac seem to not emit it. The class
+        // file is still valid and runs, so we should be able to deal with it as well.
+        //
+        // "  checkcast [[Z",
+        //
+        "  astore_1",
+        "  iload_0",
+        "  ifeq Target",
+        "  iconst_2",
+        "  anewarray [Z",
+        "  dup",
+        "  iconst_0",
+        "  iconst_1",
+        "  newarray boolean",
+        "  dup",
+        "  iconst_0",
+        "  iconst_1",
+        "  bastore",
+        "  aastore",
+        "  dup",
+        "  iconst_1",
+        "  iconst_1",
+        "  newarray boolean",
+        "  dup",
+        "  iconst_0",
+        "  iconst_0",
+        "  bastore",
+        "  aastore",
+        "  astore_1",
+        "Target:",
+        "  aload_1",
+        "  ifnull PrintNull",
+        "  getstatic java/lang/System/out Ljava/io/PrintStream;",
+        "  aload_1",
+        "  iconst_0",
+        "  aaload",
+        "  iconst_0",
+        "  baload",
+        "  invokevirtual java/io/PrintStream/println(Z)V",
+        "  getstatic java/lang/System.out Ljava/io/PrintStream;",
+        "  aload_1",
+        "  iconst_1",
+        "  aaload",
+        "  iconst_0",
+        "  baload",
+        "  invokevirtual java/io/PrintStream.println(Z)V",
+        "  goto Return",
+        "PrintNull:",
+        "  getstatic java/lang/System.out Ljava/io/PrintStream;",
+        "  ldc \"null array\"",
+        "  invokevirtual java/io/PrintStream.println(Ljava/lang/String;)V",
+        "Return:",
+        "  return");
+
+    // public static void main(String args[]) {
+    //   foo(true);
+    //   foo(false);
+    // }
+    clazz.addMainMethod(
+        ".limit stack 2",
+        ".limit locals 10",
+        "  iconst_1",
+        "  invokestatic Test/foo(Z)V",
+        "  iconst_0",
+        "  invokestatic Test/foo(Z)V",
+        "  return");
+
+    runTest(builder, clazz.name);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jasmin/InvalidClassNames.java b/src/test/java/com/android/tools/r8/jasmin/InvalidClassNames.java
new file mode 100644
index 0000000..1812fe1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/jasmin/InvalidClassNames.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2017, 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.jasmin;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.fail;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.errors.CompilationError;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InvalidClassNames extends JasminTestBase {
+
+  public boolean runsOnJVM;
+  public String name;
+
+  public InvalidClassNames(String name, boolean runsOnJVM) {
+    this.name = name;
+    this.runsOnJVM = runsOnJVM;
+  }
+
+  private void runTest(JasminBuilder builder, String main, String expected) throws Exception {
+    if (runsOnJVM) {
+      String javaResult = runOnJava(builder, main);
+      assertEquals(expected, javaResult);
+    }
+    String artResult = null;
+    try {
+      artResult = runOnArt(builder, main);
+    } catch (CompilationError t) {
+      // Ignore.
+    } catch (Throwable t) {
+      t.printStackTrace(System.out);
+      fail("Invalid dex class names should be compilation errors.");
+    }
+    assert artResult == null : "Invalid dex class names should be rejected.";
+  }
+
+  @Parameters
+  public static Collection<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+        { new String(new int[] { 0x00a0 }, 0, 1), true },
+        { new String(new int[] { 0x2000 }, 0, 1), !ToolHelper.isWindows() },
+        { new String(new int[] { 0x200f }, 0, 1), !ToolHelper.isWindows() },
+        { new String(new int[] { 0x2028 }, 0, 1), !ToolHelper.isWindows() },
+        { new String(new int[] { 0x202f }, 0, 1), !ToolHelper.isWindows() },
+        { new String(new int[] { 0xd800 }, 0, 1), false },
+        { new String(new int[] { 0xdfff }, 0, 1), false },
+        { new String(new int[] { 0xfff0 }, 0, 1), !ToolHelper.isWindows() },
+        { new String(new int[] { 0xffff }, 0, 1), !ToolHelper.isWindows() },
+        { "a/b/c/a/D/", true },
+        { "a<b", !ToolHelper.isWindows() },
+        { "a>b", !ToolHelper.isWindows() },
+        { "<a>b", !ToolHelper.isWindows() },
+        { "<a>", !ToolHelper.isWindows() }
+    });
+  }
+
+  @Test
+  public void invalidClassName() throws Exception {
+    JasminBuilder builder = new JasminBuilder();
+    JasminBuilder.ClassBuilder clazz = builder.addClass(name);
+    clazz.addMainMethod(
+        ".limit stack 2",
+        ".limit locals 1",
+        "  getstatic java/lang/System/out Ljava/io/PrintStream;",
+        "  ldc \"MAIN\"",
+        "  invokevirtual java/io/PrintStream.print(Ljava/lang/String;)V",
+        "  return");
+
+    runTest(builder, clazz.name, "MAIN");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jasmin/InvalidDebugInfoTests.java b/src/test/java/com/android/tools/r8/jasmin/InvalidDebugInfoTests.java
index 984e40e..155438f 100644
--- a/src/test/java/com/android/tools/r8/jasmin/InvalidDebugInfoTests.java
+++ b/src/test/java/com/android/tools/r8/jasmin/InvalidDebugInfoTests.java
@@ -5,6 +5,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.ToolHelper;
 import com.google.common.collect.ImmutableList;
 import org.junit.Test;
 
@@ -66,7 +67,7 @@
         "  invokestatic Test/foo(I)V",
         "  return");
 
-    String expected = "42\n0\n";
+    String expected = "42" + ToolHelper.LINE_SEPARATOR + "0" + ToolHelper.LINE_SEPARATOR;
     String javaResult = runOnJava(builder, clazz.name);
     assertEquals(expected, javaResult);
     String artResult = runOnArtD8(builder, clazz.name);
@@ -115,7 +116,7 @@
         "  invokestatic Test/foo(II)V",
         "  return");
 
-    String expected = "42\n";
+    String expected = "42" + ToolHelper.LINE_SEPARATOR;
     String javaResult = runOnJava(builder, clazz.name);
     assertEquals(expected, javaResult);
     String artResult = runOnArtD8(builder, clazz.name);
diff --git a/src/test/java/com/android/tools/r8/jasmin/InvalidFieldNames.java b/src/test/java/com/android/tools/r8/jasmin/InvalidFieldNames.java
new file mode 100644
index 0000000..791ecca
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/jasmin/InvalidFieldNames.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2017, 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.jasmin;
+
+import static junit.framework.TestCase.assertEquals;
+
+import com.android.tools.r8.errors.CompilationError;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InvalidFieldNames extends JasminTestBase {
+
+  public boolean runsOnJVM;
+  public String name;
+
+  public InvalidFieldNames(String name, boolean runsOnJVM) {
+    this.name = name;
+    this.runsOnJVM = runsOnJVM;
+  }
+
+  private void runTest(JasminBuilder builder, String main, String expected) throws Exception {
+    if (runsOnJVM) {
+      String javaResult = runOnJava(builder, main);
+      assertEquals(expected, javaResult);
+    }
+    String artResult = null;
+    try {
+      artResult = runOnArt(builder, main);
+    } catch (CompilationError t) {
+      // Ignore.
+    }
+    assert artResult == null : "Invalid dex class names should be rejected.";
+  }
+
+  @Parameters
+  public static Collection<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+        { new String(new int[] { 0x00a0 }, 0, 1), true },
+        { new String(new int[] { 0x2000 }, 0, 1), true },
+        { new String(new int[] { 0x200f }, 0, 1), true },
+        { new String(new int[] { 0x2028 }, 0, 1), true },
+        { new String(new int[] { 0x202f }, 0, 1), true },
+        { new String(new int[] { 0xd800 }, 0, 1), true },
+        { new String(new int[] { 0xdfff }, 0, 1), true },
+        { new String(new int[] { 0xfff0 }, 0, 1), true },
+        { new String(new int[] { 0xffff }, 0, 1), true },
+        { "a/b", false },
+        { "<a", false },
+        { "a>", true },
+        { "a<b>", true },
+        { "<a>b", true }
+    });
+  }
+
+  @Test
+  public void invalidFieldNames() throws Exception {
+    JasminBuilder builder = new JasminBuilder();
+    JasminBuilder.ClassBuilder clazz = builder.addClass("Test");
+
+    clazz.addStaticField(name, "I", "42");
+
+    clazz.addMainMethod(
+        ".limit stack 2",
+        ".limit locals 1",
+        "  getstatic java/lang/System/out Ljava/io/PrintStream;",
+        "  getstatic Test/" + name + " I",
+        "  invokevirtual java/io/PrintStream.print(I)V",
+        "  return");
+
+    runTest(builder, clazz.name, "42");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jasmin/InvalidMethodNames.java b/src/test/java/com/android/tools/r8/jasmin/InvalidMethodNames.java
new file mode 100644
index 0000000..f8b7615
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/jasmin/InvalidMethodNames.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2017, 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.jasmin;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.fail;
+
+import com.android.tools.r8.errors.CompilationError;
+import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InvalidMethodNames extends JasminTestBase {
+
+  public boolean runsOnJVM;
+  public String name;
+
+  public InvalidMethodNames(String name, boolean runsOnJVM) {
+    this.name = name;
+    this.runsOnJVM = runsOnJVM;
+  }
+
+  private void runTest(JasminBuilder builder, String main, String expected) throws Exception {
+    if (runsOnJVM) {
+      String javaResult = runOnJava(builder, main);
+      assertEquals(expected, javaResult);
+    }
+    String artResult = null;
+    try {
+      artResult = runOnArt(builder, main);
+    } catch (CompilationError t) {
+      // Ignore.
+    } catch (Throwable t) {
+      t.printStackTrace(System.out);
+      fail("Invalid dex class names should be compilation errors.");
+    }
+    assert artResult == null : "Invalid dex class names should be rejected.";
+  }
+
+  @Parameters
+  public static Collection<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+        { new String(new int[] { 0x00a0 }, 0, 1), true },
+        { new String(new int[] { 0x2000 }, 0, 1), true },
+        { new String(new int[] { 0x200f }, 0, 1), true },
+        { new String(new int[] { 0x2028 }, 0, 1), true },
+        { new String(new int[] { 0x202f }, 0, 1), true },
+        { new String(new int[] { 0xd800 }, 0, 1), true },
+        { new String(new int[] { 0xdfff }, 0, 1), true },
+        { new String(new int[] { 0xfff0 }, 0, 1), true },
+        { new String(new int[] { 0xffff }, 0, 1), true },
+        { "a/b", false },
+        { "<a", false },
+        { "a>", true },
+        { "<a>", false }
+    });
+  }
+
+  @Test
+  public void invalidMethodName() throws Exception {
+    JasminBuilder builder = new JasminBuilder();
+    JasminBuilder.ClassBuilder clazz = builder.addClass("Test");
+
+    clazz.addStaticMethod(name, ImmutableList.of(), "V",
+        ".limit stack 2",
+        ".limit locals 0",
+        "  getstatic java/lang/System/out Ljava/io/PrintStream;",
+        "  ldc \"CALLED\"",
+        "  invokevirtual java/io/PrintStream.print(Ljava/lang/String;)V",
+        "  return");
+
+    clazz.addMainMethod(
+        ".limit stack 0",
+        ".limit locals 1",
+        "  invokestatic Test/" + name + "()V",
+        "  return");
+
+    runTest(builder, clazz.name, "CALLED");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jasmin/InvokeSpecialTests.java b/src/test/java/com/android/tools/r8/jasmin/InvokeSpecialTests.java
index 197b4d1..c74464f 100644
--- a/src/test/java/com/android/tools/r8/jasmin/InvokeSpecialTests.java
+++ b/src/test/java/com/android/tools/r8/jasmin/InvokeSpecialTests.java
@@ -5,7 +5,9 @@
 
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.ToolHelper;
 import com.google.common.collect.ImmutableList;
+import org.junit.AssumptionViolatedException;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -72,7 +74,9 @@
 
     // TODO(zerny): Should we fail early on the above code? Art fails with a verification error
     // because Test.foo is expected to be in the direct method table.
-    thrown.expect(AssertionError.class);
+    if (ToolHelper.artSupported()) {
+      thrown.expect(AssertionError.class);
+    }
     String artResult = runOnArt(builder, clazz.name);
     assertEquals(expected, artResult);
   }
diff --git a/src/test/java/com/android/tools/r8/jasmin/JasminBuilder.java b/src/test/java/com/android/tools/r8/jasmin/JasminBuilder.java
index e7511e5..7f65c60 100644
--- a/src/test/java/com/android/tools/r8/jasmin/JasminBuilder.java
+++ b/src/test/java/com/android/tools/r8/jasmin/JasminBuilder.java
@@ -6,6 +6,7 @@
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -25,6 +26,7 @@
   public static class ClassBuilder {
     public final String name;
     private final List<String> methods = new ArrayList<>();
+    private final List<String> fields = new ArrayList<>();
     private boolean makeInit = false;
 
     public ClassBuilder(String name) {
@@ -85,6 +87,12 @@
       return new MethodSignature(name, returnJavaType, argumentJavaTypes);
     }
 
+    public FieldSignature addStaticField(String name, String type, String value) {
+      fields.add(
+          ".field public static " + name + " " + type + (value != null ? (" = " + value) : ""));
+      return new FieldSignature(name, type);
+    }
+
     @Override
     public String toString() {
       StringBuilder builder = new StringBuilder();
@@ -101,6 +109,9 @@
             .append("  return\n")
             .append(".end method\n");
       }
+      for (String field : fields) {
+        builder.append(field).append("\n");
+      }
       for (String method : methods) {
         builder.append(method).append("\n");
       }
diff --git a/src/test/java/com/android/tools/r8/jasmin/JasminTestBase.java b/src/test/java/com/android/tools/r8/jasmin/JasminTestBase.java
index 615e289..6ceb912 100644
--- a/src/test/java/com/android/tools/r8/jasmin/JasminTestBase.java
+++ b/src/test/java/com/android/tools/r8/jasmin/JasminTestBase.java
@@ -24,6 +24,7 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.StringReader;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
@@ -42,7 +43,9 @@
     for (ClassBuilder clazz : builder.getClasses()) {
       ClassFile file = new ClassFile();
       file.readJasmin(new StringReader(clazz.toString()), clazz.name, true);
-      file.write(new FileOutputStream(out.toPath().resolve(clazz.name + ".class").toFile()));
+      Path path = out.toPath().resolve(clazz.name + ".class");
+      Files.createDirectories(path.getParent());
+      file.write(new FileOutputStream(path.toFile()));
     }
     return ToolHelper.runJava(ImmutableList.of(out.getPath()), main);
   }
diff --git a/src/test/java/com/android/tools/r8/jasmin/JumpSubroutineTests.java b/src/test/java/com/android/tools/r8/jasmin/JumpSubroutineTests.java
index 34ddd69..bd060b5 100644
--- a/src/test/java/com/android/tools/r8/jasmin/JumpSubroutineTests.java
+++ b/src/test/java/com/android/tools/r8/jasmin/JumpSubroutineTests.java
@@ -8,6 +8,7 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.utils.AndroidApp;
 import com.google.common.collect.ImmutableList;
@@ -308,7 +309,8 @@
         "  invokestatic Test/foo()V",
         "  return");
 
-    runTest(builder, clazz.name, "Got zero\nGot non-zero\n");
+    runTest(builder, clazz.name, "Got zero" + ToolHelper.LINE_SEPARATOR + "Got non-zero"
+            + ToolHelper.LINE_SEPARATOR);
   }
 
   @Test
@@ -351,7 +353,9 @@
         "  invokestatic Test/foo()V",
         "  return");
 
-    runTest(builder, clazz.name, "Got zero\nGot non-zero, calling nested\nIn nested subroutine\n");
+    runTest(builder, clazz.name, "Got zero" + ToolHelper.LINE_SEPARATOR
+            + "Got non-zero, calling nested" + ToolHelper.LINE_SEPARATOR + "In nested subroutine"
+            + ToolHelper.LINE_SEPARATOR);
   }
 
   @Test
@@ -527,7 +531,8 @@
         "  invokestatic Test/foo()V",
         "  return");
 
-    runTest(builder, clazz.name, "Divided by zero\nDivided by non-zero\n");
+    runTest(builder, clazz.name, "Divided by zero" + ToolHelper.LINE_SEPARATOR
+            + "Divided by non-zero" + ToolHelper.LINE_SEPARATOR);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/jasmin/TryCatchStateTests.java b/src/test/java/com/android/tools/r8/jasmin/TryCatchStateTests.java
index 92f99f8..a24ffd2 100644
--- a/src/test/java/com/android/tools/r8/jasmin/TryCatchStateTests.java
+++ b/src/test/java/com/android/tools/r8/jasmin/TryCatchStateTests.java
@@ -5,6 +5,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.ToolHelper;
 import com.google.common.collect.ImmutableList;
 import org.junit.Test;
 
@@ -49,7 +50,7 @@
         "  invokevirtual java/io/PrintStream/print(I)V",
         "  return");
 
-    String expected = "0\n6";
+    String expected = "0" + ToolHelper.LINE_SEPARATOR + "6";
     String javaResult = runOnJava(builder, clazz.name);
     assertEquals(expected, javaResult);
     String artResult = runOnArt(builder, clazz.name);
@@ -97,7 +98,7 @@
         "  invokevirtual java/io/PrintStream/print(I)V",
         "  return");
 
-    String expected = "12\n21";
+    String expected = "12" + ToolHelper.LINE_SEPARATOR + "21";
     String javaResult = runOnJava(builder, clazz.name);
     assertEquals(expected, javaResult);
     String artResult = runOnArt(builder, clazz.name);
@@ -148,7 +149,7 @@
         "  invokevirtual java/io/PrintStream/print(I)V",
         "  return");
 
-    String expected = "12\n21";
+    String expected = "12" + ToolHelper.LINE_SEPARATOR + "21";
     String javaResult = runOnJava(builder, clazz.name);
     assertEquals(expected, javaResult);
     String artResult = runOnArt(builder, clazz.name);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/HelloWorldMain.java b/src/test/java/com/android/tools/r8/maindexlist/HelloWorldMain.java
new file mode 100644
index 0000000..b70e73f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/HelloWorldMain.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2017, 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.maindexlist;
+
+public class HelloWorldMain {
+
+  public static void main(String[] args) {
+    System.out.println("Hello, world!");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
new file mode 100644
index 0000000..f8ca2a8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2017, 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.maindexlist;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.FileUtils;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import org.junit.Test;
+
+public class MainDexListOutputTest extends TestBase {
+  @Test
+  public void testNoMainDex() throws Exception {
+    Path mainDexList = temp.newFile().toPath();
+    compileWithR8(ImmutableList.of(HelloWorldMain.class),
+        options -> {
+          options.printMainDexList = true;
+          options.printMainDexListFile = mainDexList;
+        });
+    // Empty main dex list.
+    assertEquals(0, FileUtils.readTextFile(mainDexList).size());
+  }
+
+  @Test
+  public void testWithMainDex() throws Exception {
+    Path mainDexRules = writeTextToTempFile(keepMainProguardConfiguration(HelloWorldMain.class));
+    R8Command command =
+        ToolHelper.prepareR8CommandBuilder(readClasses(HelloWorldMain.class))
+            .addMainDexRules(mainDexRules)
+            .build();
+    Path mainDexList = temp.newFile().toPath();
+    ToolHelper.runR8(command,
+        options -> {
+          options.printMainDexList = true;
+          options.printMainDexListFile = mainDexList;
+        });
+    // Main dex list with the single class.
+    assertEquals(
+        ImmutableList.of(HelloWorldMain.class.getTypeName().replace('.', '/') + ".class"),
+        FileUtils.readTextFile(mainDexList));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
index 44c2156..a0a77d1 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
@@ -3,15 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.maindexlist;
 
-import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
 import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.CompilationException;
+import com.android.tools.r8.D8Command;
 import com.android.tools.r8.R8Command;
+import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.dex.ApplicationWriter;
 import com.android.tools.r8.dex.Constants;
@@ -39,11 +39,13 @@
 import com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator;
 import com.android.tools.r8.ir.regalloc.RegisterAllocator;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
+import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.DexInspector;
+import com.android.tools.r8.utils.DexInspector.FoundClassSubject;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
@@ -52,122 +54,101 @@
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.ImmutableList;
-import com.google.common.io.ByteStreams;
-import com.google.common.io.Closer;
+import com.google.common.collect.Lists;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
 
-public class MainDexListTests {
-
-  private static final Path BASE =
-      Paths.get("src", "test", "java", "com", "android", "tools", "r8", "maindexlist");
-
-  private static boolean verifyApplications = true;
-  private static boolean regenerateApplications = false;
+public class MainDexListTests extends TestBase {
 
   private static final int MAX_METHOD_COUNT = Constants.U16BIT_MAX;
+
   private static final List<String> TWO_LARGE_CLASSES = ImmutableList.of("A", "B");
-  private static final String TWO_LARGE_CLASSES_APP = "two-large-classes.zip";
+  private static final int MANY_CLASSES_COUNT = 10000;
+  private static final int MANY_CLASSES_SINGLE_DEX_METHODS_PER_CLASS = 2;
+  private static final int MANY_CLASSES_MULTI_DEX_METHODS_PER_CLASS = 10;
+  private static List<String> MANY_CLASSES;
 
-  private static final int MANY_CLASSES_COUNT = 1000;
-  private static final List<String> MANY_CLASSES;
-  private static final String MANY_CLASSES_APP = "many-classes.zip";
+  @ClassRule
+  public static TemporaryFolder generatedApplicationsFolder = new TemporaryFolder();
 
-  static {
+  // Generate the test applications in a @BeforeClass method, as they are used by several tests.
+  @BeforeClass
+  public static void generateTestApplications() throws Throwable {
     ImmutableList.Builder<String> builder = ImmutableList.builder();
     for (int i = 0; i < MANY_CLASSES_COUNT; ++i) {
       String pkg = i % 2 == 0 ? "a" : "b";
       builder.add(pkg + ".Class" + i);
     }
     MANY_CLASSES = builder.build();
+
+    // Generates an application with many classes, every even in one package and every odd in
+    // another. Keep the number of methods low enough for single dex application.
+    AndroidApp generated = generateApplication(
+        MANY_CLASSES, Constants.DEFAULT_ANDROID_API, MANY_CLASSES_SINGLE_DEX_METHODS_PER_CLASS);
+    generated.write(getManyClassesSingleDexAppPath(), OutputMode.Indexed, false);
+
+    // Generates an application with many classes, every even in one package and every odd in
+    // another. Add enough methods so the application cannot fit into one dex file.
+    generated = generateApplication(
+        MANY_CLASSES, Constants.ANDROID_L_API, MANY_CLASSES_MULTI_DEX_METHODS_PER_CLASS);
+    generated.write(getManyClassesMultiDexAppPath(), OutputMode.Indexed, false);
+
+    // Generates an application with two classes, each with the maximum possible number of methods.
+    generated = generateApplication(TWO_LARGE_CLASSES, Constants.ANDROID_N_API, MAX_METHOD_COUNT);
+    generated.write(getTwoLargeClassesAppPath(), OutputMode.Indexed, false);
   }
 
-  public static Path getTwoLargeClassesAppPath() {
-    return BASE.resolve(TWO_LARGE_CLASSES_APP);
+  private static Path getTwoLargeClassesAppPath() {
+    return generatedApplicationsFolder.getRoot().toPath().resolve("two-large-classes.zip");
   }
 
-  public static Path getManyClassesAppPath() {
-    return BASE.resolve(MANY_CLASSES_APP);
+  private static Path getManyClassesSingleDexAppPath() {
+    return generatedApplicationsFolder.getRoot().toPath().resolve("many-classes-mono.zip");
   }
 
-  // Generates an application with two classes, each with the maximum possible number of methods.
-  @Test
-  public void generateTwoLargeClasses() throws IOException, ExecutionException {
-    if (!verifyApplications && !regenerateApplications) {
-      return;
-    }
-    AndroidApp generated = generateApplication(TWO_LARGE_CLASSES, MAX_METHOD_COUNT);
-    if (regenerateApplications) {
-      generated.write(getTwoLargeClassesAppPath(), OutputMode.Indexed, true);
-    } else {
-      AndroidApp cached = AndroidApp.fromProgramFiles(getTwoLargeClassesAppPath());
-      compareToCachedVersion(cached, generated, TWO_LARGE_CLASSES_APP);
-    }
+  private static Path getManyClassesMultiDexAppPath() {
+    return generatedApplicationsFolder.getRoot().toPath().resolve("many-classes-stereo.zip");
   }
 
-  // Generates an application with many classes, every even in one package and every odd in another.
-  @Test
-  public void generateManyClasses() throws IOException, ExecutionException {
-    if (!verifyApplications && !regenerateApplications) {
-      return;
-    }
-    AndroidApp generated = generateApplication(MANY_CLASSES, 1);
-    if (regenerateApplications) {
-      generated.write(getManyClassesAppPath(), OutputMode.Indexed, true);
-    } else {
-      AndroidApp cached = AndroidApp.fromProgramFiles(getManyClassesAppPath());
-      compareToCachedVersion(cached, generated, MANY_CLASSES_APP);
-    }
-  }
-
-  private static void compareToCachedVersion(AndroidApp cached, AndroidApp generated, String name)
-      throws IOException {
-    assertEquals("On-disk cached app (" + name + ") differs in file count from regeneration"
-            + "Set 'regenerateApplications = true' and rerun this test to update the cache.",
-        cached.getDexProgramResources().size(), generated.getDexProgramResources().size());
-    try (Closer closer = Closer.create()) {
-      for (int i = 0; i < cached.getDexProgramResources().size(); i++) {
-        byte[] cachedBytes =
-            ByteStreams.toByteArray(cached.getDexProgramResources().get(i).getStream(closer));
-        byte[] generatedBytes =
-            ByteStreams.toByteArray(generated.getDexProgramResources().get(i).getStream(closer));
-        assertArrayEquals("On-disk cached app differs in byte content from regeneration"
-                + "Set 'regenerateApplications = true' and rerun this test to update the cache.",
-            cachedBytes, generatedBytes);
-      }
-    }
-  }
-
-  @Rule
-  public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
-
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
   @Test
+  public void checkGeneratedFileFitInSingleDexFile() {
+    assertTrue(MANY_CLASSES_COUNT * MANY_CLASSES_SINGLE_DEX_METHODS_PER_CLASS <= MAX_METHOD_COUNT);
+  }
+
+  @Test
+  public void checkGeneratedFileNeedsTwoDexFiles() {
+    assertTrue(MANY_CLASSES_COUNT * MANY_CLASSES_MULTI_DEX_METHODS_PER_CLASS > MAX_METHOD_COUNT);
+  }
+
+  @Test
   public void putFirstClassInMainDexList() throws Throwable {
-    verifyMainDexContains(TWO_LARGE_CLASSES.subList(0, 1), getTwoLargeClassesAppPath());
+    verifyMainDexContains(TWO_LARGE_CLASSES.subList(0, 1), getTwoLargeClassesAppPath(), false);
   }
 
   @Test
   public void putSecondClassInMainDexList() throws Throwable {
-    verifyMainDexContains(TWO_LARGE_CLASSES.subList(1, 2), getTwoLargeClassesAppPath());
+    verifyMainDexContains(TWO_LARGE_CLASSES.subList(1, 2), getTwoLargeClassesAppPath(), false);
   }
 
   @Test
   public void cannotFitBothIntoMainDex() throws Throwable {
     thrown.expect(CompilationError.class);
-    verifyMainDexContains(TWO_LARGE_CLASSES, getTwoLargeClassesAppPath());
+    verifyMainDexContains(TWO_LARGE_CLASSES, getTwoLargeClassesAppPath(), false);
   }
 
   @Test
@@ -179,7 +160,28 @@
         mainDexBuilder.add(clazz);
       }
     }
-    verifyMainDexContains(mainDexBuilder.build(), getManyClassesAppPath());
+    verifyMainDexContains(mainDexBuilder.build(), getManyClassesSingleDexAppPath(), true);
+    verifyMainDexContains(mainDexBuilder.build(), getManyClassesMultiDexAppPath(), false);
+  }
+
+  @Test
+  public void singleClassInMainDex() throws Throwable {
+    ImmutableList<String> mainDex = ImmutableList.of(MANY_CLASSES.get(0));
+    verifyMainDexContains(mainDex, getManyClassesSingleDexAppPath(), true);
+    verifyMainDexContains(mainDex, getManyClassesMultiDexAppPath(), false);
+  }
+
+  @Test
+  public void allClassesInMainDex() throws Throwable {
+    // Degenerated case with an app thats fit into a single dex, and where the main dex list
+    // contains all classes.
+    verifyMainDexContains(MANY_CLASSES, getManyClassesSingleDexAppPath(), true);
+  }
+
+  @Test
+  public void cannotFitAllIntoMainDex() throws Throwable {
+    thrown.expect(CompilationError.class);
+    verifyMainDexContains(MANY_CLASSES, getManyClassesMultiDexAppPath(), false);
   }
 
   @Test
@@ -207,11 +209,147 @@
     MainDexList.parse(mainDexList, factory);
   }
 
-  private static String typeToEntry(String type) {
-    return type.replace(".", "/") + CLASS_EXTENSION;
+  @Test
+  public void checkDeterminism() throws Exception {
+    // Synthesize a dex containing a few empty classes including some in the default package.
+    // Everything can fit easaly in a single dex file.
+    String[] classes = {
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "A1",
+        "A2",
+        "A3",
+        "A4",
+        "A5",
+        "maindexlist/A",
+        "maindexlist/B",
+        "maindexlist/C",
+        "maindexlist/D",
+        "maindexlist/E",
+        "maindexlist/F",
+        "maindexlist/A1",
+        "maindexlist/A2",
+        "maindexlist/A3",
+        "maindexlist/A4",
+        "maindexlist/A5"
+    };
+    JasminBuilder jasminBuilder = new JasminBuilder();
+    for (String name : classes) {
+      jasminBuilder.addClass(name);
+    }
+    Path input = temp.newFolder().toPath().resolve("input.zip");
+    ToolHelper.runR8(jasminBuilder.build()).writeToZip(input, OutputMode.Indexed);
+
+    // Prepare different main dex lists.
+    ArrayList<Path> mainLists = new ArrayList<>();
+    // Lets first without a main dex list.
+    mainLists.add(null);
+
+    // List with all classes.
+    List<String> mainList = new ArrayList<>();
+    for (int i = 0; i < classes.length; i++) {
+      mainList.add(classes[i] + ".class");
+    }
+    addMainListFile(mainLists, mainList);
+
+    // Full list in reverse order
+    addMainListFile(mainLists, Lists.reverse(mainList));
+
+    // Partial list without first entries (those in default package).
+    mainList.clear();
+    for (int i = classes.length / 2; i < classes.length; i++) {
+      mainList.add(classes[i] + ".class");
+    }
+    addMainListFile(mainLists, mainList);
+
+    // Same in reverese order
+    addMainListFile(mainLists, Lists.reverse(mainList));
+
+    // Mixed partial list.
+    mainList.clear();
+    for (int i = 0; i < classes.length; i += 2) {
+      mainList.add(classes[i] + ".class");
+    }
+    addMainListFile(mainLists, mainList);
+
+    // Another different mixed partial list.
+    mainList.clear();
+    for (int i = 1; i < classes.length; i += 2) {
+      mainList.add(classes[i] + ".class");
+    }
+    addMainListFile(mainLists, mainList);
+
+    // Build with all main dex lists.
+    Path tmp = temp.getRoot().toPath();
+    for (int i = 0; i < mainLists.size(); i++) {
+      Path out = tmp.resolve(String.valueOf(i));
+      Files.createDirectories(out);
+      D8Command.Builder builder = D8Command.builder()
+          .addProgramFiles(input)
+          .setOutputPath(out);
+      if (mainLists.get(i) != null) {
+        builder.setMainDexListFile(mainLists.get(i));
+      }
+      ToolHelper.runD8(builder.build());
+    }
+
+    // Check: no secondary dex and resulting dex is always the same.
+    assertFalse(Files.exists(tmp.resolve(String.valueOf(0)).resolve("classes2.dex")));
+    byte[] ref = Files.readAllBytes(
+        tmp.resolve(String.valueOf(0)).resolve(FileUtils.DEFAULT_DEX_FILENAME));
+    for (int i = 1; i < mainLists.size(); i++) {
+      assertFalse(Files.exists(tmp.resolve(String.valueOf(i)).resolve("classes2.dex")));
+      byte[] checked = Files.readAllBytes(
+          tmp.resolve(String.valueOf(i)).resolve(FileUtils.DEFAULT_DEX_FILENAME));
+      assertArrayEquals(ref, checked);
+    }
   }
 
-  private void verifyMainDexContains(List<String> mainDex, Path app)
+  private void addMainListFile(ArrayList<Path> mainLists, List<String> content)
+      throws IOException {
+    Path listFile = temp.newFile().toPath();
+    FileUtils.writeTextFile(listFile, content);
+    mainLists.add(listFile);
+  }
+
+  private static String typeToEntry(String type) {
+    return type.replace(".", "/") + FileUtils.CLASS_EXTENSION;
+  }
+
+  private void failedToFindClassInExpectedFile(Path outDir, String clazz) throws IOException {
+    Files.list(outDir)
+        .filter(FileUtils::isDexFile)
+        .forEach(
+            p -> {
+              try {
+                DexInspector i = new DexInspector(AndroidApp.fromProgramFiles(p));
+                assertFalse("Found " + clazz + " in file " + p, i.clazz(clazz).isPresent());
+              } catch (IOException | ExecutionException e) {
+                e.printStackTrace();
+              }
+            });
+    fail("Failed to find class " + clazz + "in any file...");
+  }
+
+  private void assertMainDexClass(FoundClassSubject clazz, List<String> mainDex) {
+    if (!mainDex.contains(clazz.toString())) {
+      StringBuilder builder = new StringBuilder();
+      for (int i = 0; i < mainDex.size(); i++) {
+        builder.append(i == 0 ? "[" : ", ");
+        builder.append(mainDex.get(i));
+      }
+      builder.append("]");
+      fail("Class " + clazz + " found in main dex, " +
+          "only expected explicit main dex classes " + builder +" in main dex file");
+    }
+  }
+
+  private void doVerifyMainDexContains(
+      List<String> mainDex, Path app, boolean singleDexApp, boolean minimalMainDex)
       throws IOException, CompilationException, ExecutionException, ProguardRuleParserException {
     AndroidApp originalApp = AndroidApp.fromProgramFiles(app);
     DexInspector originalInspector = new DexInspector(originalApp);
@@ -219,53 +357,52 @@
       assertTrue("Class " + clazz + " does not exist in input",
           originalInspector.clazz(clazz).isPresent());
     }
-    Path outDir = temp.newFolder("out").toPath();
-    Path mainDexList = temp.getRoot().toPath().resolve("main-dex-list.txt");
+    Path outDir = temp.newFolder().toPath();
+    Path mainDexList = temp.newFile().toPath();
     FileUtils.writeTextFile(mainDexList, ListUtils.map(mainDex, MainDexListTests::typeToEntry));
-    Path packageDistribution = temp.getRoot().toPath().resolve("package.map");
-    FileUtils.writeTextFile(packageDistribution, ImmutableList.of("a.*:2", "b.*:1"));
     R8Command command =
         R8Command.builder()
             .addProgramFiles(app)
-            .setPackageDistributionFile(packageDistribution)
             .setMainDexListFile(mainDexList)
+            .setMinimalMainDex(minimalMainDex)
             .setOutputPath(outDir)
             .setTreeShaking(false)
             .setMinification(false)
             .build();
     ToolHelper.runR8(command);
-    assertTrue("Output run only produced one dex file. Invalid test",
-        1 < Files.list(outDir).filter(FileUtils::isDexFile).count());
+    if (!singleDexApp && !minimalMainDex) {
+      assertTrue("Output run only produced one dex file.",
+          1 < Files.list(outDir).filter(FileUtils::isDexFile).count());
+    }
     DexInspector inspector =
         new DexInspector(AndroidApp.fromProgramFiles(outDir.resolve("classes.dex")));
     for (String clazz : mainDex) {
       if (!inspector.clazz(clazz).isPresent()) {
-        Files.list(outDir)
-            .filter(FileUtils::isDexFile)
-            .forEach(
-                p -> {
-                  try {
-                    DexInspector i = new DexInspector(AndroidApp.fromProgramFiles(p));
-                    assertFalse("Found " + clazz + " in file " + p, i.clazz(clazz).isPresent());
-                  } catch (IOException | ExecutionException e) {
-                    e.printStackTrace();
-                  }
-                });
-        fail("Failed to find class " + clazz + "in any file...");
+        failedToFindClassInExpectedFile(outDir, clazz);
       }
     }
+    if (minimalMainDex) {
+      inspector.forAllClasses(clazz -> assertMainDexClass(clazz, mainDex));
+    }
   }
 
-  private static AndroidApp generateApplication(List<String> classes, int methodCount)
+  private void verifyMainDexContains(List<String> mainDex, Path app, boolean singleDexApp)
+      throws Throwable {
+    doVerifyMainDexContains(mainDex, app, singleDexApp, false);
+    doVerifyMainDexContains(mainDex, app, singleDexApp, true);
+  }
+
+  public static AndroidApp generateApplication(List<String> classes, int minApi, int methodCount)
       throws IOException, ExecutionException {
     Timing timing = new Timing("MainDexListTests");
     InternalOptions options = new InternalOptions();
+    options.minApiLevel = minApi;
     DexItemFactory factory = options.itemFactory;
     DexApplication.Builder builder = new DexApplication.Builder(factory, timing);
     for (String clazz : classes) {
       DexString desc = factory.createString(DescriptorUtils.javaTypeToDescriptor(clazz));
       DexType type = factory.createType(desc);
-      DexEncodedMethod[] virtualMethods = new DexEncodedMethod[methodCount];
+      DexEncodedMethod[] directMethods = new DexEncodedMethod[methodCount];
       for (int i = 0; i < methodCount; i++) {
         DexAccessFlags access = new DexAccessFlags();
         access.setPublic();
@@ -283,11 +420,11 @@
                 DexAnnotationSetRefList.empty(),
                 code);
         IRCode ir = code.buildIR(method, options);
-        RegisterAllocator allocator = new LinearScanRegisterAllocator(ir);
+        RegisterAllocator allocator = new LinearScanRegisterAllocator(ir, options);
         method.setCode(ir, allocator, factory);
-        virtualMethods[i] = method;
+        directMethods[i] = method;
       }
-      builder.addClassPromise(
+      builder.addProgramClass(
           new DexProgramClass(
               type,
               null,
@@ -298,8 +435,8 @@
               DexAnnotationSet.empty(),
               DexEncodedField.EMPTY_ARRAY,
               DexEncodedField.EMPTY_ARRAY,
-              DexEncodedMethod.EMPTY_ARRAY,
-              virtualMethods));
+              directMethods,
+              DexEncodedMethod.EMPTY_ARRAY));
     }
     DexApplication application = builder.build();
     AppInfoWithSubtyping appInfo = new AppInfoWithSubtyping(application);
@@ -342,8 +479,8 @@
     }
 
     @Override
-    public boolean traceInstruction(int instructionIndex, IRBuilder builder) {
-      return true;
+    public int traceInstruction(int instructionIndex, IRBuilder builder) {
+      return instructionIndex;
     }
 
     @Override
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index ae0f650..2549ff1 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -144,7 +144,7 @@
       String[] refList = new String(Files.readAllBytes(
           expectedMainDexList), StandardCharsets.UTF_8).split("\n");
       for (int i = 0; i < refList.length; i++) {
-        String reference = refList[i];
+        String reference = refList[i].trim();
         String computed = resultMainDexList.get(i);
         if (reference.contains("-$$Lambda$")) {
           // For lambda classes we check that there is a lambda class for the right containing
diff --git a/src/test/java/com/android/tools/r8/maindexlist/many-classes.zip b/src/test/java/com/android/tools/r8/maindexlist/many-classes.zip
deleted file mode 100644
index 3c1530d..0000000
--- a/src/test/java/com/android/tools/r8/maindexlist/many-classes.zip
+++ /dev/null
Binary files differ
diff --git a/src/test/java/com/android/tools/r8/maindexlist/two-large-classes.zip b/src/test/java/com/android/tools/r8/maindexlist/two-large-classes.zip
deleted file mode 100644
index 97b5fde..0000000
--- a/src/test/java/com/android/tools/r8/maindexlist/two-large-classes.zip
+++ /dev/null
Binary files differ
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
index 55bd373..c617c25 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
@@ -105,7 +105,8 @@
   }
 
   private static void inspectOriginalMain(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding.Test").method(DexInspector.MAIN);
+    MethodSubject main = inspector.clazz("memberrebinding.Memberrebinding")
+        .method(DexInspector.MAIN);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(MemberRebindingTest::coolInvokes);
     assertTrue(iterator.next().holder().is("memberrebinding.ClassAtBottomOfChain"));
@@ -132,7 +133,8 @@
   }
 
   private static void inspectMain(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding.Test").method(DexInspector.MAIN);
+    MethodSubject main = inspector.clazz("memberrebinding.Memberrebinding")
+        .method(DexInspector.MAIN);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(MemberRebindingTest::coolInvokes);
     assertTrue(iterator.next().holder().is("memberrebinding.ClassAtBottomOfChain"));
@@ -162,7 +164,8 @@
   }
 
   private static void inspectOriginalMain2(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding2.Test").method(DexInspector.MAIN);
+    MethodSubject main = inspector.clazz("memberrebinding2.Memberrebinding")
+        .method(DexInspector.MAIN);
     Iterator<FieldAccessInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isFieldAccess);
     // Run through instance put, static put, instance get and instance get.
@@ -177,7 +180,8 @@
   }
 
   private static void inspectMain2(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding2.Test").method(DexInspector.MAIN);
+    MethodSubject main = inspector.clazz("memberrebinding2.Memberrebinding")
+        .method(DexInspector.MAIN);
     Iterator<FieldAccessInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isFieldAccess);
     // Run through instance put, static put, instance get and instance get.
@@ -185,7 +189,7 @@
       assertTrue(iterator.next().holder().is("memberrebinding2.ClassAtBottomOfChain"));
       assertTrue(iterator.next().holder().is("memberrebinding2.ClassInMiddleOfChain"));
       assertTrue(iterator.next().holder().is("memberrebinding2.SuperClassOfAll"));
-      assertTrue(iterator.next().holder().is("memberrebinding2.subpackage.PackagePrivateClass"));
+      assertTrue(iterator.next().holder().is("memberrebinding2.subpackage.PublicClass"));
     }
     assertTrue(iterator.next().holder().is("java.lang.System"));
     assertFalse(iterator.hasNext());
@@ -195,7 +199,7 @@
       new MethodSignature("test", "void", new String[]{});
 
   private static void inspectOriginal3(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding3.Test").method(TEST);
+    MethodSubject main = inspector.clazz("memberrebinding3.Memberrebinding").method(TEST);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isInvoke);
     assertTrue(iterator.next().holder().is("memberrebinding3.ClassAtBottomOfChain"));
@@ -205,7 +209,7 @@
   }
 
   private static void inspect3(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding3.Test").method(TEST);
+    MethodSubject main = inspector.clazz("memberrebinding3.Memberrebinding").method(TEST);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isInvoke);
     assertTrue(iterator.next().holder().is("memberrebinding3.ClassAtBottomOfChain"));
@@ -215,19 +219,19 @@
   }
 
   private static void inspectOriginal4(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding4.Test").method(TEST);
+    MethodSubject main = inspector.clazz("memberrebinding4.Memberrebinding").method(TEST);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isInvoke);
-    assertTrue(iterator.next().holder().is("memberrebinding4.Test$Inner"));
+    assertTrue(iterator.next().holder().is("memberrebinding4.Memberrebinding$Inner"));
     assertTrue(iterator.next().holder().is("memberrebinding4.subpackage.PublicInterface"));
     assertFalse(iterator.hasNext());
   }
 
   private static void inspect4(DexInspector inspector) {
-    MethodSubject main = inspector.clazz("memberrebinding4.Test").method(TEST);
+    MethodSubject main = inspector.clazz("memberrebinding4.Memberrebinding").method(TEST);
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isInvoke);
-    assertTrue(iterator.next().holder().is("memberrebinding4.Test$Inner"));
+    assertTrue(iterator.next().holder().is("memberrebinding4.Memberrebinding$Inner"));
     assertTrue(iterator.next().holder().is("memberrebinding4.subpackage.PublicInterface"));
     assertFalse(iterator.hasNext());
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
index 5d5bc17..05b06af 100644
--- a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
@@ -11,6 +11,7 @@
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.graph.DexAccessFlags;
 import com.android.tools.r8.graph.DexItemFactory;
 import java.io.IOException;
@@ -45,6 +46,8 @@
       INVALID_PROGUARD_DIR + "including-2.flags";
   private static final String LIBRARY_JARS =
       VALID_PROGUARD_DIR + "library-jars.flags";
+  private static final String LIBRARY_JARS_WIN =
+          VALID_PROGUARD_DIR + "library-jars-win.flags";
   private static final String SEEDS =
       VALID_PROGUARD_DIR + "seeds.flags";
   private static final String SEEDS_2 =
@@ -59,6 +62,8 @@
       VALID_PROGUARD_DIR + "dontskipnonpubliclibraryclasses.flags";
   private static final String DONT_SKIP_NON_PUBLIC_LIBRARY_CLASS_MEMBERS =
       VALID_PROGUARD_DIR + "dontskipnonpubliclibraryclassmembers.flags";
+  private static final String OVERLOAD_AGGRESIVELY =
+      VALID_PROGUARD_DIR + "overloadaggressively.flags";
   private static final String DONT_OPTIMIZE =
       VALID_PROGUARD_DIR + "dontoptimize.flags";
   private static final String SKIP_NON_PUBLIC_LIBRARY_CLASSES =
@@ -281,7 +286,11 @@
   @Test
   public void parseLibraryJars() throws IOException, ProguardRuleParserException {
     ProguardConfigurationParser parser = new ProguardConfigurationParser(new DexItemFactory());
-    parser.parse(Paths.get(LIBRARY_JARS));
+    if (!ToolHelper.isLinux() && !ToolHelper.isMac()) {
+      parser.parse(Paths.get(LIBRARY_JARS_WIN));
+    } else {
+      parser.parse(Paths.get(LIBRARY_JARS));
+    }
     assertEquals(4, parser.getConfig().getLibraryjars().size());
   }
 
@@ -332,6 +341,13 @@
   }
 
   @Test
+  public void parseOverloadAggressively()
+      throws IOException, ProguardRuleParserException {
+    ProguardConfigurationParser parser = new ProguardConfigurationParser(new DexItemFactory());
+    parser.parse(Paths.get(OVERLOAD_AGGRESIVELY));
+  }
+
+  @Test
   public void parseDontOptimize()
       throws IOException, ProguardRuleParserException {
     ProguardConfigurationParser parser = new ProguardConfigurationParser(new DexItemFactory());
@@ -372,4 +388,15 @@
     );
     parser.parse(proguardConfig);
   }
+
+  @Test
+  public void parseCustomFlags() throws Exception {
+    ProguardConfigurationParser parser = new ProguardConfigurationParser(new DexItemFactory());
+    // Custom Proguard flags -runtype and -laststageoutput are ignored.
+    Path proguardConfig = writeTextToTempFile(
+        "-runtype FINAL                    ",
+        "-laststageoutput /some/file/name  "
+    );
+    parser.parse(proguardConfig);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
index f5b2b1a..8f46572 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
@@ -11,13 +11,16 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.errors.CompilationError;
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.PrintStream;
+import java.io.StringReader;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
 import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
@@ -95,7 +98,11 @@
     actualMapping = new String(Files.readAllBytes(outputmapping), StandardCharsets.UTF_8);
     String refMapping = new String(Files.readAllBytes(
         Paths.get(EXAMPLES_DIR, "shaking1", "print-mapping.ref")), StandardCharsets.UTF_8);
-    Assert.assertEquals(refMapping, actualMapping);
+    Assert.assertEquals(sorted(refMapping), sorted(actualMapping));
   }
 
+  private static String sorted(String str) {
+    return new BufferedReader(new StringReader(str))
+        .lines().sorted().collect(Collectors.joining("\n"));
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
index 4530e2e..0904569 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.DexAccessFlags;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.DexInspector;
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
@@ -126,7 +127,11 @@
             .addLibraryFiles(ListUtils.map(libs, Paths::get))
             .setMinification(minify)
             .build();
-    ToolHelper.runR8(command, options -> options.inlineAccessors = inline);
+    ToolHelper.runR8(command, options -> {
+      options.inlineAccessors = inline;
+      options.printMapping = true;
+      options.printMappingFile = out.resolve(AndroidApp.DEFAULT_PROGUARD_MAP_FILE);
+    });
   }
 
   public static void shaking1HasNoClassUnused(DexInspector inspector) {
@@ -542,7 +547,9 @@
             "assumevalues3",
             "assumevalues4",
             "assumevalues5",
-            "annotationremoval");
+            "annotationremoval",
+            "memberrebinding2",
+            "memberrebinding3");
 
     // Keys can be the name of the test or the name of the test followed by a colon and the name
     // of the keep file.
diff --git a/src/test/java/com/android/tools/r8/smali/CatchSuccessorFallthroughTest.java b/src/test/java/com/android/tools/r8/smali/CatchSuccessorFallthroughTest.java
index 5e67ad1..ca30f76 100644
--- a/src/test/java/com/android/tools/r8/smali/CatchSuccessorFallthroughTest.java
+++ b/src/test/java/com/android/tools/r8/smali/CatchSuccessorFallthroughTest.java
@@ -93,7 +93,7 @@
             assertTrue(
                 defBlock.getInstructions().get(defBlock.getInstructions().size() - 2).isInvoke());
             for (BasicBlock returnPredecessor : block.getPredecessors()) {
-              if (defBlock.isCatchSuccessor(returnPredecessor)) {
+              if (defBlock.hasCatchSuccessor(returnPredecessor)) {
                 hasExceptionalPredecessor = true;
               } else if (defBlock == returnPredecessor) {
                 // Normal flow goes to return.
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliDisassembleTest.java b/src/test/java/com/android/tools/r8/smali/SmaliDisassembleTest.java
index b1fd38f..66d0304 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliDisassembleTest.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliDisassembleTest.java
@@ -68,7 +68,9 @@
             "    mul-int/2addr       v2, v1\n" +
             "    div-int/2addr       v3, v2\n" +
             "    return              v3\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -122,7 +124,9 @@
             "      0x00000001 -> :label_5  # 1\n" +
             "      0x00000002 -> :label_7  # 2\n" +
             "    .end sparse-switch\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -176,7 +180,9 @@
             "      :label_5\n" +
             "      :label_7\n" +
             "    .end packed-switch\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -217,7 +223,9 @@
             "      0x02  # 2\n" +
             "      0xff  # 255\n" +
             "    .end array-data\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -258,7 +266,9 @@
             "      0x0002  # 2\n" +
             "      0xffff  # 65535\n" +
             "    .end array-data\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -299,7 +309,9 @@
             "      0x00000002  # 2\n" +
             "      0xffffffff  # 4294967295\n" +
             "    .end array-data\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
@@ -340,14 +352,15 @@
             "      0x0000000000000002  # 2\n" +
             "      0xffffffffffffffff  # -1\n" +
             "    .end array-data\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
     roundTripRawSmali(expected);
   }
 
-
   @Test
   public void interfaceClass() {
     SmaliBuilder builder = new SmaliBuilder();
@@ -362,7 +375,33 @@
             ".super Ljava/lang/Object;\n" +
             "\n" +
             ".method public abstract test()I\n" +
-            ".end method\n";
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
+
+    assertEquals(expected, application.smali(new InternalOptions()));
+
+    roundTripRawSmali(expected);
+  }
+
+  @Test
+  public void implementsInterface() {
+    SmaliBuilder builder = new SmaliBuilder();
+    builder.addClass("Test", "java.lang.Object", ImmutableList.of("java.util.List"));
+    builder.addAbstractMethod("int", "test", ImmutableList.of());
+    DexApplication application = buildApplication(builder);
+    assertEquals(1, Iterables.size(application.classes()));
+
+    String expected =
+        ".class public LTest;\n" +
+            "\n" +
+            ".super Ljava/lang/Object;\n" +
+            ".implements Ljava/util/List;\n" +
+            "\n" +
+            ".method public abstract test()I\n" +
+            ".end method\n" +
+            "\n" +
+            "# End of class LTest;\n";
 
     assertEquals(expected, application.smali(new InternalOptions()));
 
diff --git a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
index 3665a86..6b377f4 100644
--- a/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
+++ b/src/test/java/com/android/tools/r8/smali/SmaliTestBase.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.utils.OutputMode;
 import com.android.tools.r8.utils.Smali;
 import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import java.io.IOException;
 import java.nio.file.Path;
@@ -77,11 +78,27 @@
     abstract class Builder {
       String name;
       String superName;
+      List<String> implementedInterfaces;
       List<String> source = new ArrayList<>();
 
-      Builder(String name, String superName) {
+      Builder(String name, String superName, List<String> implementedInterfaces) {
         this.name = name;
         this.superName = superName;
+        this.implementedInterfaces = implementedInterfaces;
+      }
+
+      protected void appendSuper(StringBuilder builder) {
+        builder.append(".super ");
+        builder.append(DescriptorUtils.javaTypeToDescriptor(superName));
+        builder.append("\n");
+      }
+
+      protected void appendImplementedInterfaces(StringBuilder builder) {
+        for (String implementedInterface : implementedInterfaces) {
+          builder.append(".implements ");
+          builder.append(DescriptorUtils.javaTypeToDescriptor(implementedInterface));
+          builder.append("\n");
+        }
       }
 
       protected void writeSource(StringBuilder builder) {
@@ -94,8 +111,8 @@
 
     public class ClassBuilder extends Builder {
 
-      ClassBuilder(String name, String superName) {
-        super(name, superName);
+      ClassBuilder(String name, String superName, List<String> implementedInterfaces) {
+        super(name, superName, implementedInterfaces);
       }
 
       public String toString() {
@@ -103,9 +120,9 @@
         builder.append(".class public ");
         builder.append(DescriptorUtils.javaTypeToDescriptor(name));
         builder.append("\n");
-        builder.append(".super ");
-        builder.append(DescriptorUtils.javaTypeToDescriptor(superName));
-        builder.append("\n\n");
+        appendSuper(builder);
+        appendImplementedInterfaces(builder);
+        builder.append("\n");
         writeSource(builder);
         return builder.toString();
       }
@@ -114,7 +131,7 @@
     public class InterfaceBuilder extends Builder {
 
       InterfaceBuilder(String name, String superName) {
-        super(name, superName);
+        super(name, superName, ImmutableList.of());
       }
 
       public String toString() {
@@ -122,9 +139,9 @@
         builder.append(".class public interface abstract ");
         builder.append(DescriptorUtils.javaTypeToDescriptor(name));
         builder.append("\n");
-        builder.append(".super ");
-        builder.append(DescriptorUtils.javaTypeToDescriptor(superName));
-        builder.append("\n\n");
+        appendSuper(builder);
+        appendImplementedInterfaces(builder);
+        builder.append("\n");
         writeSource(builder);
         return builder.toString();
       }
@@ -162,9 +179,13 @@
     }
 
     public void addClass(String name, String superName) {
+      addClass(name, superName, ImmutableList.of());
+    }
+
+    public void addClass(String name, String superName, List<String> implementedInterfaces) {
       assert !classes.containsKey(name);
       currentClassName = name;
-      classes.put(name, new ClassBuilder(name, superName));
+      classes.put(name, new ClassBuilder(name, superName, implementedInterfaces));
     }
 
     public void addInterface(String name) {
diff --git a/src/test/java/com/android/tools/r8/utils/ArtCommandBuilderTest.java b/src/test/java/com/android/tools/r8/utils/ArtCommandBuilderTest.java
index 0344a27..fa3497b 100644
--- a/src/test/java/com/android/tools/r8/utils/ArtCommandBuilderTest.java
+++ b/src/test/java/com/android/tools/r8/utils/ArtCommandBuilderTest.java
@@ -9,10 +9,17 @@
 import com.android.tools.r8.ToolHelper.ArtCommandBuilder;
 import com.android.tools.r8.ToolHelper.DexVm;
 import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.Before;
 import org.junit.Test;
 
 public class ArtCommandBuilderTest {
 
+  @Before
+  public void setUp() {
+    Assume.assumeTrue(ToolHelper.artSupported());
+  }
+
   @Test
   public void noArguments() {
     ArtCommandBuilder builder = new ArtCommandBuilder();
diff --git a/src/test/proguard/valid/library-jars-win.flags b/src/test/proguard/valid/library-jars-win.flags
new file mode 100644
index 0000000..c6ffbb4
--- /dev/null
+++ b/src/test/proguard/valid/library-jars-win.flags
@@ -0,0 +1,2 @@
+-libraryjars some/library.jar
+-libraryjars some/library.jar;some/other/library.jar;yet/another/library.jar
\ No newline at end of file
diff --git a/src/test/proguard/valid/overloadaggressively.flags b/src/test/proguard/valid/overloadaggressively.flags
new file mode 100644
index 0000000..312ebff
--- /dev/null
+++ b/src/test/proguard/valid/overloadaggressively.flags
@@ -0,0 +1,5 @@
+# Copyright (c) 2017, 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.
+
+-overloadaggressively
diff --git a/third_party/android_cts_baseline.tar.gz.sha1 b/third_party/android_cts_baseline.tar.gz.sha1
index 7126671..5efd8e5 100644
--- a/third_party/android_cts_baseline.tar.gz.sha1
+++ b/third_party/android_cts_baseline.tar.gz.sha1
@@ -1 +1 @@
-3914f251fc8b8669b2ec92766696267c1a9ac7ff
\ No newline at end of file
+499d86b9b9eba837261c2d10e5b76f3a3a9a9952
\ No newline at end of file
diff --git a/third_party/android_jar/lib-v21.tar.gz.sha1 b/third_party/android_jar/lib-v21.tar.gz.sha1
new file mode 100644
index 0000000..8d42abc
--- /dev/null
+++ b/third_party/android_jar/lib-v21.tar.gz.sha1
@@ -0,0 +1 @@
+83d20da35ba7b7b1a8b48a2da8dfe3b95d59392a
\ No newline at end of file
diff --git a/third_party/gmail/gmail_android_170604.16.tar.gz.sha1 b/third_party/gmail/gmail_android_170604.16.tar.gz.sha1
new file mode 100644
index 0000000..f57ba90
--- /dev/null
+++ b/third_party/gmail/gmail_android_170604.16.tar.gz.sha1
@@ -0,0 +1 @@
+161c569821a5c9b4cb8e99de764f3449191af084
\ No newline at end of file
diff --git a/third_party/gmscore/latest.tar.gz.sha1 b/third_party/gmscore/latest.tar.gz.sha1
new file mode 100644
index 0000000..0a0d4d4
--- /dev/null
+++ b/third_party/gmscore/latest.tar.gz.sha1
@@ -0,0 +1 @@
+d38c56b1c4583393fda2bff933a8d09443e5c792
\ No newline at end of file
diff --git a/third_party/jctf.tar.gz.sha1 b/third_party/jctf.tar.gz.sha1
index 73cc756..35ec1ba 100644
--- a/third_party/jctf.tar.gz.sha1
+++ b/third_party/jctf.tar.gz.sha1
@@ -1 +1 @@
-d9256a5987d50372f916d367cb8e8e5286a10caa
+93c13a164ca54db72273642d27308e325526fd38
\ No newline at end of file
diff --git a/third_party/proguard/proguard_internal_159423826.tar.gz.sha1 b/third_party/proguard/proguard_internal_159423826.tar.gz.sha1
new file mode 100644
index 0000000..8fdbf19
--- /dev/null
+++ b/third_party/proguard/proguard_internal_159423826.tar.gz.sha1
@@ -0,0 +1 @@
+933e970c611a306ef5d755234820188bc50c4c60
\ No newline at end of file
diff --git a/third_party/youtube/youtube.android_11.47.tar.gz.sha1 b/third_party/youtube/youtube.android_11.47.tar.gz.sha1
deleted file mode 100644
index db94984..0000000
--- a/third_party/youtube/youtube.android_11.47.tar.gz.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3c763fc5b033497dabdfff2ecd27475cfa7759a4
\ No newline at end of file
diff --git a/third_party/youtube/youtube.android_12.22.tar.gz.sha1 b/third_party/youtube/youtube.android_12.22.tar.gz.sha1
new file mode 100644
index 0000000..8f6813c
--- /dev/null
+++ b/third_party/youtube/youtube.android_12.22.tar.gz.sha1
@@ -0,0 +1 @@
+73c4880898d734064815d0426d8fe84ee6d075b4
\ No newline at end of file
diff --git a/tools/compare_cts_results.py b/tools/compare_cts_results.py
index 95e29d1..00901ec 100755
--- a/tools/compare_cts_results.py
+++ b/tools/compare_cts_results.py
@@ -9,9 +9,10 @@
 from os.path import basename
 import argparse
 import os
-import re
 import sys
 
+import utils
+
 class Module:
   def __init__(self):
     self.test_cases = {}
@@ -90,35 +91,19 @@
 
 # Read CTS test_result.xml from file and merge into result_tree
 def add_to_result_tree(result_tree, file_xml, file_idx):
-  re_module = re.compile('<Module name="([^"]*)"')
-  re_test_case = re.compile('<TestCase name="([^"]*)"')
-  re_test = re.compile('<Test result="(pass|fail)" name="([^"]*)"')
   module = None
   test_case = None
-  with open(file_xml) as f:
-    for line in f:
-      m = re_module.search(line)
-      if m:
-        module_name = m.groups()[0]
-        module = result_tree.setdefault(module_name, Module())
-        module.set_file_index_present(file_idx)
-        continue
-
-      m = re_test_case.search(line)
-      if m:
-        test_case_name = m.groups()[0]
-        test_case = module.get_test_case_maybe_create(test_case_name)
-        test_case.set_file_index_present(file_idx)
-        continue
-
-      m = re_test.search(line)
-      if m:
-        outcome = m.groups()[0]
-        test_name = m.groups()[1]
-        assert outcome in ["fail", "pass"]
-
-        v = test_case.get_test_maybe_create(test_name)
-        v.set_file_index_outcome(outcome == 'pass', file_idx)
+  for x in utils.read_cts_test_result(file_xml):
+    if type(x) is utils.CtsModule:
+      module = result_tree.setdefault(x.name, Module())
+      module.set_file_index_present(file_idx)
+    elif type(x) is utils.CtsTestCase:
+      test_case = module.get_test_case_maybe_create(x.name)
+      test_case.set_file_index_present(file_idx)
+    else:
+      assert(type(x) is utils.CtsTest)
+      v = test_case.get_test_maybe_create(x.name)
+      v.set_file_index_outcome(x.outcome, file_idx)
 
 # main tree_report function
 def tree_report(result_tree, files, diff_only):
diff --git a/tools/gmail_data.py b/tools/gmail_data.py
new file mode 100644
index 0000000..d09a3e8
--- /dev/null
+++ b/tools/gmail_data.py
@@ -0,0 +1,35 @@
+# Copyright (c) 2017, 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.
+
+import glob
+import os
+import utils
+
+THIRD_PARTY = os.path.join(utils.REPO_ROOT, 'third_party')
+BASE = os.path.join(THIRD_PARTY, 'gmail')
+
+V170604_16_BASE = os.path.join(BASE, 'gmail_android_170604.16')
+V170604_16_PREFIX = os.path.join(V170604_16_BASE, 'Gmail_release_unstripped')
+
+# NOTE: We always use android.jar for SDK v25 for now.
+ANDROID_JAR = os.path.join(THIRD_PARTY, 'android_jar', 'lib-v25', 'android.jar')
+
+VERSIONS = {
+  '170604.16': {
+    'dex' : {
+      'inputs': [os.path.join(V170604_16_BASE, 'Gmail_release_unsigned.apk')],
+      'pgmap': '%s_proguard.map' % V170604_16_PREFIX,
+      'libraries' : [ANDROID_JAR],
+      'r8-flags': '--ignore-missing-classes',
+    },
+    'deploy' : {
+      'inputs': ['%s_deploy.jar' % V170604_16_PREFIX],
+      'pgconf': ['%s_proguard.config' % V170604_16_PREFIX],
+    },
+    'proguarded' : {
+      'inputs': ['%s_proguard.jar' % V170604_16_PREFIX],
+      'pgmap': '%s_proguard.map' % V170604_16_PREFIX,
+    }
+  },
+}
diff --git a/tools/gradle.py b/tools/gradle.py
index 1945557..f30b3f4 100755
--- a/tools/gradle.py
+++ b/tools/gradle.py
@@ -14,7 +14,10 @@
 
 GRADLE_DIR = os.path.join(utils.REPO_ROOT, 'third_party', 'gradle')
 GRADLE_SHA1 = os.path.join(GRADLE_DIR, 'gradle.tar.gz.sha1')
-GRADLE = os.path.join(GRADLE_DIR, 'gradle', 'bin', 'gradle')
+if utils.IsWindows():
+  GRADLE = os.path.join(GRADLE_DIR, 'gradle', 'bin', 'gradle.bat')
+else:
+  GRADLE = os.path.join(GRADLE_DIR, 'gradle', 'bin', 'gradle')
 
 def PrintCmd(s):
   if type(s) is list:
diff --git a/tools/proguard.py b/tools/proguard.py
new file mode 100755
index 0000000..58c049f
--- /dev/null
+++ b/tools/proguard.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# Copyright (c) 2017, 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.
+
+# Run ProGuard, Google's internal version
+
+from __future__ import print_function
+import os
+import subprocess
+import sys
+
+import utils
+
+PROGUARD_JAR = os.path.join(utils.REPO_ROOT, 'third_party', 'proguard',
+    'proguard_internal_159423826', 'ProGuard_deploy.jar')
+
+def run(args):
+  cmd = ['java', '-jar', PROGUARD_JAR]
+  cmd.extend(args)
+  print('-- ' + ' '.join(cmd))
+  subprocess.check_call(cmd)
+
+def Main():
+  run(sys.argv[1:])
+
+if __name__ == '__main__':
+  sys.exit(Main())
diff --git a/tools/run-r8-on-gmscore.py b/tools/run-r8-on-gmscore.py
index c00a58d..6d09760 100755
--- a/tools/run-r8-on-gmscore.py
+++ b/tools/run-r8-on-gmscore.py
@@ -5,7 +5,8 @@
 
 import sys
 
-import run_r8_on_app
+import run_on_app
 
 if __name__ == '__main__':
-  sys.exit(run_r8_on_app.main())
+  # Default compiler is R8.
+  sys.exit(run_on_app.main())
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
new file mode 100755
index 0000000..ddc1e47
--- /dev/null
+++ b/tools/run_on_app.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+# Copyright (c) 2017, 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.
+
+import optparse
+import os
+import r8
+import d8
+import sys
+import utils
+import time
+
+import gmscore_data
+import youtube_data
+import gmail_data
+
+TYPES = ['dex', 'deploy', 'proguarded']
+APPS = ['gmscore', 'youtube', 'gmail']
+
+def ParseOptions():
+  result = optparse.OptionParser()
+  result.add_option('--compiler',
+                    help='',
+                    default='r8',
+                    choices=['d8', 'r8'])
+  result.add_option('--app',
+                    help='',
+                    default='gmscore',
+                    choices=APPS)
+  result.add_option('--type',
+                    help='Default for R8: deploy, for D8: proguarded',
+                    choices=TYPES)
+  result.add_option('--out',
+                    help='',
+                    default=os.getcwd())
+  result.add_option('--no-build',
+                    help='',
+                    default=False,
+                    action='store_true')
+  result.add_option('--no-libraries',
+                    help='',
+                    default=False,
+                    action='store_true')
+  result.add_option('--no-debug',
+                    help='Run without debug asserts.',
+                    default=False,
+                    action='store_true')
+  result.add_option('--version',
+                    help='')
+  result.add_option('-k',
+                    help='Override the default ProGuard keep rules')
+  result.add_option('--compiler-flags',
+                    help='Additional option(s) for the compiler. ' +
+                         'If passing several options use a quoted string.')
+  result.add_option('--r8-flags',
+                    help='Additional option(s) for the compiler. ' +
+                         'Same as --compiler-flags, keeping it for backward compatibility. ' +
+                         'If passing several options use a quoted string.')
+  result.add_option('--track-memory-to-file',
+                    help='Track how much memory the jvm is using while ' +
+                    ' compiling. Output to the specified file.')
+  result.add_option('--profile',
+                    help='Profile R8 run.',
+                    default=False,
+                    action='store_true')
+  result.add_option('--dump-args-file',
+                    help='Dump a file with the arguments for the specified ' +
+                    'configuration. For use as a @<file> argument to perform ' +
+                    'the run.')
+  result.add_option('--print-runtimeraw',
+                    metavar='BENCHMARKNAME',
+                    help='Prints the line \'<BENCHMARKNAME>(RunTimeRaw):' +
+                         ' <elapsed> ms\' at the end where <elapsed> is' +
+                         ' the elapsed time in milliseconds.')
+  return result.parse_args()
+
+# Most apps have the -printmapping and -printseeds in the Proguard
+# configuration. However we don't want to write these files in these
+# locations. Instead generate an auxiliary Proguard configuration
+# placing these two output files together with the dex output.
+def GenerateAdditionalProguardConfiguration(temp, outdir):
+  name = "output.config"
+  with open(os.path.join(temp, name), 'w') as file:
+    file.write('-printmapping ' + os.path.join(outdir, 'proguard.map') + "\n")
+    file.write('-printseeds ' + os.path.join(outdir, 'proguard.seeds') + "\n")
+    return os.path.abspath(file.name)
+
+def main():
+  app_provided_pg_conf = False;
+  (options, args) = ParseOptions()
+  outdir = options.out
+  data = None
+  if options.app == 'gmscore':
+    options.version = options.version or 'v9'
+    data = gmscore_data
+  elif options.app == 'youtube':
+    options.version = options.version or '12.22'
+    data = youtube_data
+  elif options.app == 'gmail':
+    options.version = options.version or '170604.16'
+    data = gmail_data
+  else:
+    raise 'Unexpected'
+
+  if not options.version in data.VERSIONS.keys():
+    print 'No version %s for application %s' % (options.version, options.app)
+    print 'Valid versions are %s' % data.VERSIONS.keys()
+    return 1
+
+  version = data.VERSIONS[options.version]
+
+  if not options.type:
+    options.type = 'deploy' if options.compiler == 'r8' \
+        else 'proguarded'
+
+  if options.type not in version:
+    print 'No type %s for version %s' % (options.type, options.version)
+    print 'Valid types are %s' % version.keys()
+    return 1
+  values = version[options.type]
+  inputs = None
+  # For R8 'deploy' the JAR is located using the Proguard configuration -injars option.
+  if 'inputs' in values and (options.compiler != 'r8' or options.type != 'deploy'):
+    inputs = values['inputs']
+
+  args.extend(['--output', outdir])
+
+  if options.compiler == 'r8':
+    if 'pgmap' in values:
+      args.extend(['--pg-map', values['pgmap']])
+    if 'pgconf' in values and not options.k:
+      for pgconf in values['pgconf']:
+        args.extend(['--pg-conf', pgconf])
+        app_provided_pg_conf = True
+    if options.k:
+      args.extend(['--pg-conf', options.k])
+    if 'multidexrules' in values:
+      for rules in values['multidexrules']:
+        args.extend(['--multidex-rules', rules])
+
+  if not options.no_libraries and 'libraries' in values:
+    for lib in values['libraries']:
+      args.extend(['--lib', lib])
+
+  if not outdir.endswith('.zip') and not outdir.endswith('.jar') and not os.path.exists(outdir):
+    os.makedirs(outdir)
+
+  if options.compiler == 'r8':
+    if 'r8-flags' in values:
+      args.extend(values['r8-flags'].split(' '))
+
+  if options.compiler_flags:
+    args.extend(options.compiler_flags.split(' '))
+  if options.r8_flags:
+    args.extend(options.r8_flags.split(' '))
+
+  if inputs:
+    args.extend(inputs)
+
+  t0 = time.time()
+
+  if options.dump_args_file:
+    with open(options.dump_args_file, 'w') as args_file:
+      args_file.writelines([arg + os.linesep for arg in args])
+  else:
+    if options.compiler == 'd8':
+      d8.run(args, not options.no_build, not options.no_debug, options.profile,
+             options.track_memory_to_file)
+    else:
+      with utils.TempDir() as temp:
+        if app_provided_pg_conf:
+          # Ensure that output of -printmapping and -printseeds go to the output
+          # location and not where the app Proguard configuration places them.
+          if outdir.endswith('.zip') or outdir.endswith('.jar'):
+            pg_outdir = os.path.dirname(outdir)
+          else:
+            pg_outdir = outdir
+          additional_pg_conf = GenerateAdditionalProguardConfiguration(
+              temp, os.path.abspath(pg_outdir))
+          args.extend(['--pg-conf', additional_pg_conf])
+        r8.run(args, not options.no_build, not options.no_debug, options.profile,
+               options.track_memory_to_file)
+
+  if options.print_runtimeraw:
+    print('{}(RunTimeRaw): {} ms'
+        .format(options.print_runtimeraw, 1000.0 * (time.time() - t0)))
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/tools/run_proguard_dx_on_gmscore.py b/tools/run_proguard_dx_on_gmscore.py
new file mode 100755
index 0000000..a67868b
--- /dev/null
+++ b/tools/run_proguard_dx_on_gmscore.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# Copyright (c) 2017, 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.
+
+# Run ProGuard and the DX tool on GmsCore V10.
+
+from __future__ import print_function
+from os import makedirs
+from os.path import exists, join
+from subprocess import check_call
+import argparse
+import gmscore_data
+import os
+import stat
+import sys
+import time
+
+import proguard
+import utils
+
+BLAZE_BUILD_DIR = join(gmscore_data.V10_BASE,
+    'blaze-out/intel-linux-android-4.8-libcxx-x86-opt/bin/java/com/google/'
+    'android/gmscore/integ')
+PROGUARDED_OUTPUT = join(BLAZE_BUILD_DIR,
+    'GmsCore_prod_alldpi_release_all_locales_proguard.jar')
+GMSCORE_SEEDS_FILE = join(BLAZE_BUILD_DIR,
+    'GmsCore_prod_alldpi_release_all_locales_proguard.seeds')
+DX_EXECUTABLE = join(utils.REPO_ROOT, 'tools/linux/dx/bin/dx')
+
+def parse_arguments():
+  parser = argparse.ArgumentParser(
+      description = 'Run ProGuard and the DX tool on GmsCore V10.')
+  parser.add_argument('--out',
+      help = 'Output directory for the DX tool.',
+      default = os.getcwd())
+  parser.add_argument('--print-runtimeraw',
+      metavar = 'BENCHMARKNAME',
+      help = 'Prints the line \'<BENCHMARKNAME>(RunTimeRaw): <elapsed>' +
+             ' ms\' at the end where <elapsed> is the elapsed time in' +
+             ' milliseconds.')
+  return parser.parse_args()
+
+def Main():
+  options = parse_arguments()
+
+  outdir = options.out
+
+  args = ['-forceprocessing']
+
+  if not outdir.endswith('.zip') and not outdir.endswith('.jar') \
+      and not exists(outdir):
+    makedirs(outdir)
+
+  version = gmscore_data.VERSIONS['v10']
+  values = version['deploy']
+  assert 'pgconf' in values
+
+  for pgconf in values['pgconf']:
+    args.extend(['@' + pgconf])
+
+  # Remove write-protection from seeds file. The seeds file is an output of
+  # ProGuard so it aborts if this is not writeable.
+  st = os.stat(GMSCORE_SEEDS_FILE)
+  os.chmod(GMSCORE_SEEDS_FILE,
+      st.st_mode | stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)
+
+  t0 = time.time()
+
+  proguard.run(args)
+
+  # run dex on the result
+  check_call([DX_EXECUTABLE, '-JXmx5256M', '--multi-dex', '--output=' + outdir,
+      '--dex', PROGUARDED_OUTPUT])
+
+  if options.print_runtimeraw:
+    print('{}(RunTimeRaw): {} ms'
+        .format(options.print_runtimeraw, 1000.0 * (time.time() - t0)))
+
+if __name__ == '__main__':
+  sys.exit(Main())
diff --git a/tools/run_r8_on_app.py b/tools/run_r8_on_app.py
deleted file mode 100755
index 736d428..0000000
--- a/tools/run_r8_on_app.py
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2017, 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.
-
-import optparse
-import os
-import r8
-import sys
-
-import gmscore_data
-import youtube_data
-
-TYPES = ['dex', 'deploy', 'proguarded']
-APPS = ['gmscore', 'youtube']
-
-def ParseOptions():
-  result = optparse.OptionParser()
-  result.add_option('--app',
-                    help='',
-                    default='gmscore',
-                    choices=APPS)
-  result.add_option('--type',
-                    help='',
-                    default='deploy',
-                    choices=TYPES)
-  result.add_option('--out',
-                    help='',
-                    default=os.getcwd())
-  result.add_option('--no-build',
-                    help='',
-                    default=False,
-                    action='store_true')
-  result.add_option('--no-libraries',
-                    help='',
-                    default=False,
-                    action='store_true')
-  result.add_option('--no-debug',
-                    help='Run without debug asserts.',
-                    default=False,
-                    action='store_true')
-  result.add_option('--version',
-                    help='')
-  result.add_option('-k',
-                    help='Override the default ProGuard keep rules')
-  result.add_option('--r8-flags',
-                    help='Additional option(s) for R8. ' +
-                         'If passing several options use a quoted string.')
-  result.add_option('--track-memory-to-file',
-                    help='Track how much memory the jvm is using while ' +
-                    ' compiling. Output to the specified file.')
-  result.add_option('--profile',
-                    help='Profile R8 run.',
-                    default=False,
-                    action='store_true')
-  result.add_option('--dump-args-file',
-                    help='Dump a file with the arguments for the specified ' +
-                    'configuration. For use as a @<file> argument to perform ' +
-                    'the run.')
-  return result.parse_args()
-
-def main():
-  (options, args) = ParseOptions()
-  outdir = options.out
-  data = None
-  if options.app == 'gmscore':
-    options.version = options.version or 'v9'
-    data = gmscore_data
-  elif options.app == 'youtube':
-    options.version = options.version or '12.10'
-    data = youtube_data
-  else:
-    raise 'Unexpected'
-
-  if not options.version in data.VERSIONS.keys():
-    print 'No version %s for application %s' % (options.version, options.app)
-    print 'Valid versions are %s' % data.VERSIONS.keys()
-    return 1
-
-  version = data.VERSIONS[options.version]
-
-  if options.type not in version:
-    print 'No type %s for version %s' % (options.type, options.version)
-    print 'Valid types are %s' % version.keys()
-    return 1
-  values = version[options.type]
-  inputs = None
-  # For 'deploy' the JAR is located using the Proguard configuration -injars option.
-  if 'inputs' in values and options.type != 'deploy':
-    inputs = values['inputs']
-
-  args.extend(['--output', outdir])
-  if 'pgmap' in values:
-    args.extend(['--pg-map', values['pgmap']])
-  if 'pgconf' in values and not options.k:
-    for pgconf in values['pgconf']:
-      args.extend(['--pg-conf', pgconf])
-  if options.k:
-    args.extend(['--pg-conf', options.k])
-  if not options.no_libraries and 'libraries' in values:
-    for lib in values['libraries']:
-      args.extend(['--lib', lib])
-
-  if not outdir.endswith('.zip') and not outdir.endswith('.jar') and not os.path.exists(outdir):
-    os.makedirs(outdir)
-
-  if 'r8-flags' in values:
-    args.extend(values['r8-flags'].split(' '))
-  if options.r8_flags:
-    args.extend(options.r8_flags.split(' '))
-
-  if inputs:
-    args.extend(inputs)
-
-  if options.dump_args_file:
-    with open(options.dump_args_file, 'w') as args_file:
-      args_file.writelines([arg + os.linesep for arg in args])
-  else:
-    r8.run(args, not options.no_build, not options.no_debug, options.profile,
-           options.track_memory_to_file)
-
-if __name__ == '__main__':
-  sys.exit(main())
diff --git a/tools/test.bat b/tools/test.bat
new file mode 100644
index 0000000..a343096
--- /dev/null
+++ b/tools/test.bat
@@ -0,0 +1,9 @@
+@echo off
+:: Copyright (c) 2017, 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.
+setlocal
+
+PATH=%~dp0;%PATH%
+
+python "%~dp0\test.py" %*
\ No newline at end of file
diff --git a/tools/test.py b/tools/test.py
index 2f5baf8..49a6f3c 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -7,6 +7,7 @@
 # if an argument is given, run only tests with that pattern. This script will
 # force the tests to run, even if no input changed.
 
+import os
 import gradle
 import optparse
 import sys
@@ -47,6 +48,9 @@
   result.add_option('--jctf_compile_only',
       help="Don't run, only compile JCTF tests.",
       default=False, action='store_true')
+  result.add_option('--disable_assertions',
+      help="Disable assertions when running tests.",
+      default=False, action='store_true')
 
   return result.parse_args()
 
@@ -74,15 +78,23 @@
     gradle_args.append('-Ponly_jctf')
   if options.jctf_compile_only:
     gradle_args.append('-Pjctf_compile_only')
+  if options.disable_assertions:
+    gradle_args.append('-Pdisable_assertions')
   if len(args) > 0:
     gradle_args.append('--tests')
     gradle_args.append(args[0])
-
+  if os.name == 'nt':
+    # temporary hack
+    gradle_args.append('-Pno_internal')
+    gradle_args.append('-x')
+    gradle_args.append('createJctfTests')
+    gradle_args.append('-x')
+    gradle_args.append('jctfCommonJar')
+    gradle_args.append('-x')
+    gradle_args.append('jctfTestsClasses')
   vms_to_test = [options.dex_vm] if options.dex_vm != "all" else ALL_ART_VMS
   for art_vm in vms_to_test:
     gradle.RunGradle(gradle_args + ['-Pdex_vm=%s' % art_vm])
 
 if __name__ == '__main__':
   sys.exit(Main())
-
-
diff --git a/tools/test_android_cts.py b/tools/test_android_cts.py
index 384ce70..606611d 100755
--- a/tools/test_android_cts.py
+++ b/tools/test_android_cts.py
@@ -14,11 +14,9 @@
 #   cd build/aosp
 #   repo manifest -o ../../third_party/aosp_manifest.xml -r
 #
-# The baseline is the `test_result.xml` file which is created with an AOSP
-# build which uses the default (JACK) toolset.
-#
-# Use this script, with '--tool=jack' to reproduce the baseline results
-#
+# The baseline is a set of `test_result.xml` files in
+# third_party/android_cts_baseline/jack. The current test considered a success
+# if all tests pass that consistently pass in the baseline.
 
 from __future__ import print_function
 from glob import glob
@@ -30,12 +28,13 @@
 import os
 import re
 import sys
+import time
 
 import gradle
 import utils
 
-CTS_BASELINE = join(utils.REPO_ROOT,
-  'third_party/android_cts_baseline/test_result.xml')
+CTS_BASELINE_FILES_DIR = join(utils.REPO_ROOT,
+  'third_party/android_cts_baseline/jack')
 AOSP_MANIFEST_XML = join(utils.REPO_ROOT, 'third_party',
   'aosp_manifest.xml')
 AOSP_HELPER_SH = join(utils.REPO_ROOT, 'scripts', 'aosp_helper.sh')
@@ -96,97 +95,33 @@
       return False
   return True
 
-# Read the xml test result file into an in-memory tree:
-# Extract only the Module/TestCase/Test names and outcome (True|False for
-# PASS|FAIL):
-#
-#     tree[module_name][testcase_name][test_name] = True|False
-#
-def read_test_result_into_tree(filename):
-  re_module = re.compile('<Module name="([^"]*)"')
-  re_testcase = re.compile('<TestCase name="([^"]*)"')
-  re_test = re.compile('<Test result="(pass|fail)" name="([^"]*)"')
+# Return list of fully qualified names of tests passing in
+# all the files.
+def consistently_passing_tests_from_test_results(filenames):
   tree = {}
   module = None
   testcase = None
-  with open(filename) as f:
-    for line in f:
-      m = re_module.search(line)
-      if m:
-        module_name = m.groups()[0]
-        tree[module_name] = {}
-        module = tree[module_name]
-        continue
+  # Build a tree with leaves True|False|None for passing, failing and flaky
+  # tests.
+  for f in filenames:
+    for x in utils.read_cts_test_result(f):
+      if type(x) is utils.CtsModule:
+        module = tree.setdefault(x.name, {})
+      elif type(x) is utils.CtsTestCase:
+        testcase = module.setdefault(x.name, {})
+      else:
+        outcome = testcase.setdefault(x.name, x.outcome)
+        if outcome is not None and outcome != x.outcome:
+          testcase[x.name] = None
 
-      m = re_testcase.search(line)
-      if m:
-        testcase_name = m.groups()[0]
-        module[testcase_name] = {}
-        testcase = module[testcase_name]
-        continue
+  result = []
+  for module_name, module in tree.iteritems():
+    for test_case_name, test_case in module.iteritems():
+      result.extend(['{}/{}/{}'.format(module_name, test_case_name, test_name)
+          for test_name, test in test_case.iteritems()
+              if test])
 
-      m = re_test.search(line)
-      if m:
-        outcome = m.groups()[0]
-        test_name = m.groups()[1]
-        assert outcome in ["fail", "pass"]
-        testcase[test_name] = outcome == "pass"
-  return tree
-
-# Report the items with the title
-def report_key_diff(title, items, prefix = ''):
-  if len(items) > 0:
-    print(title, ":")
-    for x in items:
-      print("- {}{}".format(prefix, x))
-    print()
-
-
-def diff_sets(base_minus_result_title, result_minus_base_title,
-    base_set, result_set, prefix = ''):
-  base_minus_result = base_set - result_set
-  result_minus_base = result_set - base_set
-  report_key_diff(base_minus_result_title, base_minus_result, prefix)
-  report_key_diff(result_minus_base_title, result_minus_base, prefix)
-  return len(base_minus_result) > 0 or len(result_minus_base) > 0
-
-def diff_tree_report(baseline_tree, result_tree):
-  baseline_modules = set(baseline_tree.keys())
-  result_modules = set(result_tree.keys())
-  differ = diff_sets('Modules missing from current result',
-      'New modules appeared in current result',
-      baseline_modules, result_modules)
-  for module in (result_modules & baseline_modules):
-    baseline_module = baseline_tree[module]
-    result_module = result_tree[module]
-    baseline_testcases = set(baseline_module.keys())
-    result_testcases = set(result_module.keys())
-    differ = diff_sets('Test cases missing from current result',
-        'New test cases appeared in current result',
-        baseline_testcases, result_testcases, module + '/') \
-        or differ
-    for testcase in (result_testcases & baseline_testcases):
-      baseline_testcase = baseline_module[testcase]
-      result_testcase = result_module[testcase]
-      baseline_tests = set(baseline_testcase.keys())
-      result_tests = set(result_testcase.keys())
-      differ = diff_sets('Tests missing from current result',
-          'New tests appeared in current result',
-          baseline_tests, result_tests, module + '/' + testcase + '/') \
-          or differ
-      need_newline_at_end = False
-      for test in (result_tests & baseline_tests):
-        baseline_outcome = baseline_testcase[test]
-        result_outcome = result_testcase[test]
-        if baseline_outcome != result_outcome:
-          differ = True
-          print('Test: {}/{}/{}, change: {}'.format(
-            module, testcase, test,
-            'PASS -> FAIL' if baseline_outcome else 'FAIL -> PASS'))
-          need_newline_at_end = True
-      if need_newline_at_end:
-        print()
-  return differ
+  return result
 
 def setup_and_clean(tool_is_d8, clean_dex):
   # Two output dirs, one for the android image and one for cts tests.
@@ -296,8 +231,6 @@
   re_summary = re.compile('<Summary ')
 
   summaries = [('Summary from current test results: ', results_xml)]
-  if not args.no_baseline:
-    summaries.append(('Summary from baseline: ', CTS_BASELINE))
 
   for (title, result_file) in summaries:
     print(title, result_file)
@@ -312,10 +245,31 @@
   else:
     print('Comparing test results to baseline:\n')
 
-    result_tree = read_test_result_into_tree(results_xml)
-    baseline_tree = read_test_result_into_tree(CTS_BASELINE)
+    passing_tests = consistently_passing_tests_from_test_results([results_xml])
+    baseline_results = \
+        [f for f in glob(join(CTS_BASELINE_FILES_DIR, '*.xml'))]
+    assert len(baseline_results) != 0
 
-    r = EXIT_FAILURE if diff_tree_report(baseline_tree, result_tree) else 0
+    passing_tests_in_baseline = \
+        consistently_passing_tests_from_test_results(baseline_results)
+
+    missing_or_failing_tests = \
+        set(passing_tests_in_baseline) - set(passing_tests)
+
+    num_tests = len(missing_or_failing_tests)
+    if num_tests != 0:
+      if num_tests > 1:
+        text = '{} tests that consistently pass in the baseline' \
+          ' are missing or failing in the current test:'.format(num_tests)
+      else:
+        text = '1 test that consistently passes in the baseline' \
+          ' is missing or failing in the current test:'
+      print(text)
+      for t in missing_or_failing_tests:
+        print(t)
+      r = EXIT_FAILURE
+    else:
+      r = 0
 
   if args.save_result:
     copy2(results_xml, args.save_result)
diff --git a/tools/utils.py b/tools/utils.py
index 67cac46..8c4f710 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -6,6 +6,7 @@
 
 import hashlib
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -13,7 +14,6 @@
 
 TOOLS_DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..')))
 REPO_ROOT = os.path.realpath(os.path.join(TOOLS_DIR, '..'))
-DOWNLOAD_DEPS = os.path.join(REPO_ROOT, 'scripts', 'download-deps.sh')
 
 def PrintCmd(s):
   if type(s) is list:
@@ -22,8 +22,13 @@
   # I know this will hit os on windows eventually if we don't do this.
   sys.stdout.flush()
 
+def IsWindows():
+  return os.name == 'nt'
+
 def DownloadFromGoogleCloudStorage(sha1_file, bucket='r8-deps'):
-  cmd = ["download_from_google_storage", "-n", "-b", bucket, "-u", "-s",
+  suffix = '.bat' if IsWindows() else ''
+  download_script = 'download_from_google_storage%s' % suffix
+  cmd = [download_script, '-n', '-b', bucket, '-u', '-s',
          sha1_file]
   PrintCmd(cmd)
   subprocess.check_call(cmd)
@@ -63,9 +68,46 @@
 
  def __enter__(self):
    self._old_cwd = os.getcwd()
-   print "Enter directory = ", self._working_directory
+   print 'Enter directory = ', self._working_directory
    os.chdir(self._working_directory)
 
  def __exit__(self, *_):
-   print "Enter directory = ", self._old_cwd
+   print 'Enter directory = ', self._old_cwd
    os.chdir(self._old_cwd)
+
+# Reading Android CTS test_result.xml
+
+class CtsModule(object):
+  def __init__(self, module_name):
+    self.name = module_name
+
+class CtsTestCase(object):
+  def __init__(self, test_case_name):
+    self.name = test_case_name
+
+class CtsTest(object):
+  def __init__(self, test_name, outcome):
+    self.name = test_name
+    self.outcome = outcome
+
+# Generator yielding CtsModule, CtsTestCase or CtsTest from
+# reading through a CTS test_result.xml file.
+def read_cts_test_result(file_xml):
+  re_module = re.compile('<Module name="([^"]*)"')
+  re_test_case = re.compile('<TestCase name="([^"]*)"')
+  re_test = re.compile('<Test result="(pass|fail)" name="([^"]*)"')
+  with open(file_xml) as f:
+    for line in f:
+      m = re_module.search(line)
+      if m:
+        yield CtsModule(m.groups()[0])
+        continue
+      m = re_test_case.search(line)
+      if m:
+        yield CtsTestCase(m.groups()[0])
+        continue
+      m = re_test.search(line)
+      if m:
+        outcome = m.groups()[0]
+        assert outcome in ['fail', 'pass']
+        yield CtsTest(m.groups()[1], outcome == 'pass')
diff --git a/tools/windows/README.dx b/tools/windows/README.dx
new file mode 100644
index 0000000..348dc4a
--- /dev/null
+++ b/tools/windows/README.dx
@@ -0,0 +1,25 @@
+Dx version: 1.12
+dx.bat and dx.jar are fetched from SDK build tools 24.0.0.
+dx.bat has been modified so that the code that checks if 'java' if on current path
+is removed and replaced by a direct reference to it.
+This is done because this relies on a tool found in the SDK and not present in the
+current package.
+Diff:
+
+26,29c26,29
+< set java_exe=
+< if exist    "%~dp0..\tools\lib\find_java.bat" call    "%~dp0..\tools\lib\find_java.bat"
+< if exist "%~dp0..\..\tools\lib\find_java.bat" call "%~dp0..\..\tools\lib\find_java.bat"
+< if not defined java_exe goto :EOF
+---
+> REM set java_exe=
+> REM if exist    "%~dp0..\tools\lib\find_java.bat" call    "%~dp0..\tools\lib\find_java.bat"
+> REM if exist "%~dp0..\..\tools\lib\find_java.bat" call "%~dp0..\..\tools\lib\find_java.bat"
+> REM if not defined java_exe goto :EOF
+87c87
+< call "%java_exe%" %javaOpts% -Djava.ext.dirs="%frameworkdir%" -jar "%jarpath%" %params%
+---
+> call java %javaOpts% -Djava.ext.dirs="%frameworkdir%" -jar "%jarpath%" %params%
+
+dexmerger.bat has been copied from dx.bat, and the command line has been updated
+according to the SDK dexmerger bash script to call the right class.
\ No newline at end of file
diff --git a/tools/windows/dx.tar.gz.sha1 b/tools/windows/dx.tar.gz.sha1
new file mode 100644
index 0000000..0f3e345
--- /dev/null
+++ b/tools/windows/dx.tar.gz.sha1
@@ -0,0 +1 @@
+9adeae753e17fa0a663e4d458b406a39ded27621
\ No newline at end of file
diff --git a/tools/youtube_data.py b/tools/youtube_data.py
index 0fb39e3..b32a372 100644
--- a/tools/youtube_data.py
+++ b/tools/youtube_data.py
@@ -9,37 +9,20 @@
 THIRD_PARTY = os.path.join(utils.REPO_ROOT, 'third_party')
 BASE = os.path.join(THIRD_PARTY, 'youtube')
 
-V11_47_BASE = os.path.join(BASE, 'youtube.android_11.47')
-V11_47_PREFIX = os.path.join(V11_47_BASE, 'YouTubeRelease')
-
 V12_10_BASE = os.path.join(BASE, 'youtube.android_12.10')
 V12_10_PREFIX = os.path.join(V12_10_BASE, 'YouTubeRelease')
 
 V12_17_BASE = os.path.join(BASE, 'youtube.android_12.17')
 V12_17_PREFIX = os.path.join(V12_17_BASE, 'YouTubeRelease')
 
+V12_22_BASE = os.path.join(BASE, 'youtube.android_12.22')
+V12_22_PREFIX = os.path.join(V12_22_BASE, 'YouTubeRelease')
+
 # NOTE: we always use android.jar for SDK v25, later we might want to revise it
 #       to use proper android.jar version for each of youtube version separately.
 ANDROID_JAR = os.path.join(THIRD_PARTY, 'android_jar', 'lib-v25', 'android.jar')
 
 VERSIONS = {
-  '11.47': {
-    'dex' : {
-      'inputs': [os.path.join(V11_47_BASE, 'YouTubeRelease_unsigned.apk')],
-      'pgmap': '%s_proguard.map' % V11_47_PREFIX,
-      'libraries' : [ANDROID_JAR],
-      'r8-flags': '--ignore-missing-classes',
-    },
-    'deploy' : {
-      'inputs': ['%s_deploy.jar' % V11_47_PREFIX],
-      'pgconf': ['%s_proguard.config' % V11_47_PREFIX,
-                 '%s/proguardsettings/YouTubeRelease_proguard.config' % THIRD_PARTY],
-    },
-    'proguarded' : {
-      'inputs': ['%s_proguard.jar' % V11_47_PREFIX],
-      'pgmap': '%s_proguard.map' % V11_47_PREFIX
-    }
-  },
   '12.10': {
     'dex' : {
       'inputs': [os.path.join(V12_10_BASE, 'YouTubeRelease_unsigned.apk')],
@@ -74,4 +57,26 @@
       'pgmap': '%s_proguard.map' % V12_17_PREFIX
     }
   },
+  '12.22': {
+    'dex' : {
+      'inputs': [os.path.join(V12_22_BASE, 'YouTubeRelease_unsigned.apk')],
+      'pgmap': '%s_proguard.map' % V12_22_PREFIX,
+      'libraries' : [ANDROID_JAR],
+      'r8-flags': '--ignore-missing-classes',
+    },
+    'deploy' : {
+      'inputs': ['%s_deploy.jar' % V12_22_PREFIX],
+      'pgconf': [
+          '%s_proguard.config' % V12_22_PREFIX,
+          '%s/proguardsettings/YouTubeRelease_proguard.config' % THIRD_PARTY],
+      'multidexrules' : [
+          os.path.join(V12_22_BASE, 'mainDexClasses.rules'),
+          os.path.join(V12_22_BASE, 'main-dex-classes-release.cfg'),
+          os.path.join(V12_22_BASE, 'main_dex_YouTubeRelease_proguard.cfg')],
+    },
+    'proguarded' : {
+      'inputs': ['%s_proguard.jar' % V12_22_PREFIX],
+      'pgmap': '%s_proguard.map' % V12_22_PREFIX
+    }
+  },
 }